Skip to main content Link Search Menu Expand Document (external link)
effect

Schema overview

Added in v3.10.0

Table of contents

API interface

Element (interface)

Signature

export interface Element<S extends Schema.Any, Token extends Element.Token>
  extends Schema.Variance<Schema.Type<S>, Schema.Encoded<S>, Schema.Context<S>> {
  readonly _Token: Token
  readonly ast: AST.OptionalType
  readonly from: S
  annotations(annotations: Element.Annotations<Schema.Type<S>>): Element<S, Token>
}

Added in v3.10.0

TemplateLiteral (interface)

Signature

export interface TemplateLiteral<A> extends SchemaClass<A> {}

Added in v3.10.0

TemplateLiteralParser (interface)

Signature

export interface TemplateLiteralParser<Params extends array_.NonEmptyReadonlyArray<TemplateLiteralParserParameters>>
  extends Schema<
    GetTemplateLiteralParserType<Params>,
    GetTemplateLiteralParserEncoded<Params>,
    Schema.Context<Params[number]>
  > {
  readonly params: Params
}

Added in v3.10.0

propertySignature (interface)

Signature

export interface propertySignature<S extends Schema.All>
  extends PropertySignature<":", Schema.Type<S>, never, ":", Schema.Encoded<S>, false, Schema.Context<S>> {
  readonly from: S
  annotations(annotations: PropertySignature.Annotations<Schema.Type<S>>): propertySignature<S>
}

Added in v1.0.0

BigDecimal constructors

BigDecimalFromSelf (class)

Signature

export declare class BigDecimalFromSelf

Added in v3.10.0

NegativeBigDecimalFromSelf

Signature

export declare const NegativeBigDecimalFromSelf: filter<Schema<bigDecimal_.BigDecimal, bigDecimal_.BigDecimal, never>>

Added in v3.10.0

NonNegativeBigDecimalFromSelf

Signature

export declare const NonNegativeBigDecimalFromSelf: filter<
  Schema<bigDecimal_.BigDecimal, bigDecimal_.BigDecimal, never>
>

Added in v3.10.0

NonPositiveBigDecimalFromSelf

Signature

export declare const NonPositiveBigDecimalFromSelf: filter<
  Schema<bigDecimal_.BigDecimal, bigDecimal_.BigDecimal, never>
>

Added in v3.10.0

PositiveBigDecimalFromSelf

Signature

export declare const PositiveBigDecimalFromSelf: filter<Schema<bigDecimal_.BigDecimal, bigDecimal_.BigDecimal, never>>

Added in v3.10.0

BigDecimal filters

betweenBigDecimal

Signature

export declare const betweenBigDecimal: <A extends bigDecimal_.BigDecimal>(
  minimum: bigDecimal_.BigDecimal,
  maximum: bigDecimal_.BigDecimal,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanBigDecimal

Signature

export declare const greaterThanBigDecimal: <A extends bigDecimal_.BigDecimal>(
  min: bigDecimal_.BigDecimal,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanOrEqualToBigDecimal

Signature

export declare const greaterThanOrEqualToBigDecimal: <A extends bigDecimal_.BigDecimal>(
  min: bigDecimal_.BigDecimal,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanBigDecimal

Signature

export declare const lessThanBigDecimal: <A extends bigDecimal_.BigDecimal>(
  max: bigDecimal_.BigDecimal,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanOrEqualToBigDecimal

Signature

export declare const lessThanOrEqualToBigDecimal: <A extends bigDecimal_.BigDecimal>(
  max: bigDecimal_.BigDecimal,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

negativeBigDecimal

Signature

export declare const negativeBigDecimal: <A extends bigDecimal_.BigDecimal>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

nonNegativeBigDecimal

Signature

export declare const nonNegativeBigDecimal: <A extends bigDecimal_.BigDecimal>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

nonPositiveBigDecimal

Signature

export declare const nonPositiveBigDecimal: <A extends bigDecimal_.BigDecimal>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

positiveBigDecimal

Signature

export declare const positiveBigDecimal: <A extends bigDecimal_.BigDecimal>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

BigDecimal transformations

BigDecimal (class)

Signature

export declare class BigDecimal

Added in v3.10.0

BigDecimalFromNumber (class)

A schema that transforms a number into a BigDecimal. When encoding, this Schema will produce incorrect results if the BigDecimal exceeds the 64-bit range of a number.

Signature

export declare class BigDecimalFromNumber

Added in v3.10.0

clampBigDecimal

Clamps a BigDecimal between a minimum and a maximum value.

Signature

export declare const clampBigDecimal: (
  minimum: bigDecimal_.BigDecimal,
  maximum: bigDecimal_.BigDecimal
) => <A extends bigDecimal_.BigDecimal, I, R>(self: Schema<A, I, R>) => transform<Schema<A, I, R>, filter<Schema<A>>>

Added in v3.10.0

Cause transformations

Cause

Signature

export declare const Cause: <E extends Schema.All, D extends Schema.All>({
  defect,
  error
}: {
  readonly error: E
  readonly defect: D
}) => Cause<E, D>

Added in v3.10.0

CauseFromSelf

Signature

export declare const CauseFromSelf: <E extends Schema.All, D extends Schema.All>({
  defect,
  error
}: {
  readonly error: E
  readonly defect: D
}) => CauseFromSelf<E, D>

Added in v3.10.0

Cause utils

CauseEncoded (type alias)

Signature

export type CauseEncoded<E, D> =
  | {
      readonly _tag: "Empty"
    }
  | {
      readonly _tag: "Fail"
      readonly error: E
    }
  | {
      readonly _tag: "Die"
      readonly defect: D
    }
  | {
      readonly _tag: "Interrupt"
      readonly fiberId: FiberIdEncoded
    }
  | {
      readonly _tag: "Sequential"
      readonly left: CauseEncoded<E, D>
      readonly right: CauseEncoded<E, D>
    }
  | {
      readonly _tag: "Parallel"
      readonly left: CauseEncoded<E, D>
      readonly right: CauseEncoded<E, D>
    }

Added in v3.10.0

Chunk

ChunkFromSelf

Signature

export declare const ChunkFromSelf: <Value extends Schema.Any>(value: Value) => ChunkFromSelf<Value>

Added in v3.10.0

NonEmptyChunkFromSelf

Signature

export declare const NonEmptyChunkFromSelf: <Value extends Schema.Any>(value: Value) => NonEmptyChunkFromSelf<Value>

Added in v3.10.0

Chunk transformations

Chunk

Signature

export declare const Chunk: <Value extends Schema.Any>(value: Value) => Chunk<Value>

Added in v3.10.0

NonEmptyChunk

Signature

export declare const NonEmptyChunk: <Value extends Schema.Any>(value: Value) => NonEmptyChunk<Value>

Added in v3.10.0

Config validations

Config

Signature

export declare const Config: <A>(name: string, schema: Schema<A, string>) => config_.Config<A>

Added in v3.10.0

Data transformations

Data

Signature

export declare const Data: <
  R,
  I extends Readonly<Record<string, any>> | ReadonlyArray<any>,
  A extends Readonly<Record<string, any>> | ReadonlyArray<any>
>(
  item: Schema<A, I, R>
) => SchemaClass<A, I, R>

Added in v3.10.0

DataFromSelf

Signature

export declare const DataFromSelf: <
  R,
  I extends Readonly<Record<string, any>> | ReadonlyArray<any>,
  A extends Readonly<Record<string, any>> | ReadonlyArray<any>
>(
  item: Schema<A, I, R>
) => SchemaClass<A, I, R>

Added in v3.10.0

Date constructors

DateFromSelf (class)

Describes a schema that accommodates potentially invalid Date instances, such as new Date("Invalid Date"), without rejection.

Signature

export declare class DateFromSelf

Added in v3.10.0

ValidDateFromSelf (class)

Defines a schema that ensures only valid dates are accepted. This schema rejects values like new Date("Invalid Date"), which, despite being a Date instance, represents an invalid date. Such stringent validation ensures that all date objects processed through this schema are properly formed and represent real dates.

Signature

export declare class ValidDateFromSelf

Added in v3.10.0

Date filters

betweenDate

Signature

export declare const betweenDate: <A extends Date>(
  minimum: Date,
  maximum: Date,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanDate

Signature

export declare const greaterThanDate: <A extends Date>(
  min: Date,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanOrEqualToDate

Signature

export declare const greaterThanOrEqualToDate: <A extends Date>(
  min: Date,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanDate

Signature

export declare const lessThanDate: <A extends Date>(
  max: Date,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanOrEqualToDate

Signature

export declare const lessThanOrEqualToDate: <A extends Date>(
  max: Date,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

validDate

Defines a filter that specifically rejects invalid dates, such as new Date("Invalid Date"). This filter ensures that only properly formatted and valid date objects are accepted, enhancing data integrity by preventing erroneous date values from being processed.

Signature

export declare const validDate: (
  annotations?: Annotations.Filter<Date>
) => <I, R>(self: Schema<Date, I, R>) => filter<Schema<Date, I, R>>

Added in v3.10.0

Date transformations

Date

This schema converts a string into a Date object using the new Date constructor. It ensures that only valid date strings are accepted, rejecting any strings that would result in an invalid date, such as new Date("Invalid Date").

Signature

export declare const Date: typeof Date$

Added in v3.10.0

DateFromNumber (class)

Defines a schema that converts a number into a Date object using the new Date constructor. This schema does not validate the numerical input, allowing potentially invalid values such as NaN, Infinity, and -Infinity to be converted into Date objects. During the encoding process, any invalid Date object will be encoded to NaN.

Signature

export declare class DateFromNumber

Added in v3.10.0

DateFromString (class)

Defines a schema that attempts to convert a string to a Date object using the new Date constructor. This conversion is lenient, meaning it does not reject strings that do not form valid dates (e.g., using new Date("Invalid Date") results in a Date object, despite being invalid).

Signature

export declare class DateFromString

Added in v3.10.0

DateTime.Utc constructors

DateTimeUtcFromSelf (class)

Describes a schema that represents a DateTime.Utc instance.

Signature

export declare class DateTimeUtcFromSelf

Added in v3.10.0

DateTime.Utc transformations

DateTimeUtc (class)

Defines a schema that attempts to convert a string to a DateTime.Utc instance using the DateTime.unsafeMake constructor.

Signature

export declare class DateTimeUtc

Added in v3.10.0

DateTimeUtcFromNumber (class)

Defines a schema that attempts to convert a number to a DateTime.Utc instance using the DateTime.unsafeMake constructor.

Signature

export declare class DateTimeUtcFromNumber

Added in v3.10.0

DateTime.Zoned constructors

DateTimeZonedFromSelf (class)

Describes a schema that represents a DateTime.Zoned instance.

Signature

export declare class DateTimeZonedFromSelf

Added in v3.10.0

DateTime.Zoned transformations

DateTimeZoned (class)

Defines a schema that attempts to convert a string to a DateTime.Zoned instance.

Signature

export declare class DateTimeZoned

Added in v3.10.0

Duration constructors

DurationFromSelf (class)

Signature

export declare class DurationFromSelf

Added in v3.10.0

Duration filters

betweenDuration

Signature

export declare const betweenDuration: <A extends duration_.Duration>(
  minimum: duration_.DurationInput,
  maximum: duration_.DurationInput,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanDuration

Signature

export declare const greaterThanDuration: <A extends duration_.Duration>(
  min: duration_.DurationInput,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanOrEqualToDuration

Signature

export declare const greaterThanOrEqualToDuration: <A extends duration_.Duration>(
  min: duration_.DurationInput,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanDuration

Signature

export declare const lessThanDuration: <A extends duration_.Duration>(
  max: duration_.DurationInput,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanOrEqualToDuration

Signature

export declare const lessThanOrEqualToDuration: <A extends duration_.Duration>(
  max: duration_.DurationInput,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

Duration transformations

Duration (class)

A schema that transforms a [number, number] tuple into a Duration.

Signature

export declare class Duration

Added in v3.10.0

DurationFromMillis (class)

A schema that transforms a number tuple into a Duration. Treats the value as the number of milliseconds.

Signature

export declare class DurationFromMillis

Added in v3.10.0

DurationFromNanos (class)

A schema that transforms a bigint tuple into a Duration. Treats the value as the number of nanoseconds.

Signature

export declare class DurationFromNanos

Added in v3.10.0

clampDuration

Clamps a Duration between a minimum and a maximum value.

Signature

export declare const clampDuration: (
  minimum: duration_.DurationInput,
  maximum: duration_.DurationInput
) => <A extends duration_.Duration, I, R>(self: Schema<A, I, R>) => transform<Schema<A, I, R>, filter<Schema<A>>>

Added in v3.10.0

Either transformations

Either

Signature

export declare const Either: <R extends Schema.All, L extends Schema.All>({
  left,
  right
}: {
  readonly left: L
  readonly right: R
}) => Either<R, L>

Added in v3.10.0

EitherFromSelf

Signature

export declare const EitherFromSelf: <R extends Schema.All, L extends Schema.All>({
  left,
  right
}: {
  readonly left: L
  readonly right: R
}) => EitherFromSelf<R, L>

Added in v3.10.0

EitherFromUnion

Signature

export declare const EitherFromUnion: <R extends Schema.All, L extends Schema.All>({
  left,
  right
}: {
  readonly left: L
  readonly right: R
}) => EitherFromUnion<R, L>

Example

import * as Schema from "effect/Schema"

// Schema<string | number, Either<string, number>>
Schema.EitherFromUnion({ left: Schema.String, right: Schema.Number })

Added in v3.10.0

Either utils

EitherEncoded (type alias)

Signature

export type EitherEncoded<IR, IL> = RightEncoded<IR> | LeftEncoded<IL>

Added in v3.10.0

LeftEncoded (type alias)

Signature

export type LeftEncoded<IE> = {
  readonly _tag: "Left"
  readonly left: IE
}

Added in v3.10.0

RightEncoded (type alias)

Signature

export type RightEncoded<IA> = {
  readonly _tag: "Right"
  readonly right: IA
}

Added in v3.10.0

Equivalence

equivalence

Given a schema Schema<A, I, R>, returns an Equivalence instance for A.

Signature

export declare const equivalence: <A, I, R>(schema: Schema<A, I, R>) => Equivalence.Equivalence<A>

Added in v3.10.0

Exit transformations

Exit

Signature

export declare const Exit: <A extends Schema.All, E extends Schema.All, D extends Schema.All>({
  defect,
  failure,
  success
}: {
  readonly failure: E
  readonly success: A
  readonly defect: D
}) => Exit<A, E, D>

Added in v3.10.0

ExitFromSelf

Signature

export declare const ExitFromSelf: <A extends Schema.All, E extends Schema.All, D extends Schema.All>({
  defect,
  failure,
  success
}: {
  readonly failure: E
  readonly success: A
  readonly defect: D
}) => ExitFromSelf<A, E, D>

Added in v3.10.0

Exit utils

ExitEncoded (type alias)

Signature

export type ExitEncoded<A, E, D> =
  | {
      readonly _tag: "Failure"
      readonly cause: CauseEncoded<E, D>
    }
  | {
      readonly _tag: "Success"
      readonly value: A
    }

Added in v3.10.0

FiberId

FiberIdEncoded (type alias)

Signature

export type FiberIdEncoded =
  | {
      readonly _tag: "Composite"
      readonly left: FiberIdEncoded
      readonly right: FiberIdEncoded
    }
  | {
      readonly _tag: "None"
    }
  | {
      readonly _tag: "Runtime"
      readonly id: number
      readonly startTimeMillis: number
    }

Added in v3.10.0

FiberId constructors

FiberIdFromSelf (class)

Signature

export declare class FiberIdFromSelf

Added in v3.10.0

FiberId transformations

FiberId (class)

Signature

export declare class FiberId

Added in v3.10.0

HashMap transformations

HashMap

Signature

export declare const HashMap: <K extends Schema.Any, V extends Schema.Any>({
  key,
  value
}: {
  readonly key: K
  readonly value: V
}) => HashMap<K, V>

Added in v3.10.0

HashMapFromSelf

Signature

export declare const HashMapFromSelf: <K extends Schema.Any, V extends Schema.Any>({
  key,
  value
}: {
  readonly key: K
  readonly value: V
}) => HashMapFromSelf<K, V>

Added in v3.10.0

HashSet transformations

HashSet

Signature

export declare const HashSet: <Value extends Schema.Any>(value: Value) => HashSet<Value>

Added in v3.10.0

HashSetFromSelf

Signature

export declare const HashSetFromSelf: <Value extends Schema.Any>(value: Value) => HashSetFromSelf<Value>

Added in v3.10.0

List transformations

List

Signature

export declare const List: <Value extends Schema.Any>(value: Value) => List<Value>

Added in v3.10.0

ListFromSelf

Signature

export declare const ListFromSelf: <Value extends Schema.Any>(value: Value) => ListFromSelf<Value>

Added in v3.10.0

Map

MapFromSelf

Signature

export declare const MapFromSelf: <K extends Schema.Any, V extends Schema.Any>({
  key,
  value
}: {
  readonly key: K
  readonly value: V
}) => MapFromSelf<K, V>

Added in v3.10.0

Map transformations

Map

Signature

export declare const Map: <K extends Schema.Any, V extends Schema.Any>({
  key,
  value
}: {
  readonly key: K
  readonly value: V
}) => Map$<K, V>

Added in v3.10.0

MapFromRecord

Signature

export declare const MapFromRecord: <KA, KR, VA, VI, VR>({
  key,
  value
}: {
  key: Schema<KA, string, KR>
  value: Schema<VA, VI, VR>
}) => Schema<Map<KA, VA>, { readonly [x: string]: VI }, KR | VR>

Added in v3.10.0

Option transformations

Option

Signature

export declare const Option: <Value extends Schema.Any>(value: Value) => Option<Value>

Added in v3.10.0

OptionFromNonEmptyTrimmedString

Transforms strings into an Option type, effectively filtering out empty or whitespace-only strings by trimming them and checking their length. Returns none for invalid inputs and some for valid non-empty strings.

Signature

export declare const OptionFromNonEmptyTrimmedString: transform<
  typeof String$,
  OptionFromSelf<typeof NonEmptyTrimmedString>
>

Example

import { Schema } from "effect"

console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("")) // Option.none()
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)(" a ")) // Option.some("a")
console.log(Schema.decodeSync(Schema.OptionFromNonEmptyTrimmedString)("a")) // Option.some("a")

Added in v3.10.0

OptionFromNullOr

Signature

export declare const OptionFromNullOr: <Value extends Schema.Any>(value: Value) => OptionFromNullOr<Value>

Added in v3.10.0

OptionFromNullishOr

Signature

export declare const OptionFromNullishOr: <Value extends Schema.Any>(
  value: Value,
  onNoneEncoding: null | undefined
) => OptionFromNullishOr<Value>

Added in v3.10.0

OptionFromSelf

Signature

export declare const OptionFromSelf: <Value extends Schema.Any>(value: Value) => OptionFromSelf<Value>

Added in v3.10.0

OptionFromUndefinedOr

Signature

export declare const OptionFromUndefinedOr: <Value extends Schema.Any>(value: Value) => OptionFromUndefinedOr<Value>

Added in v3.10.0

Option utils

OptionEncoded (type alias)

Signature

export type OptionEncoded<I> =
  | {
      readonly _tag: "None"
    }
  | {
      readonly _tag: "Some"
      readonly value: I
    }

Added in v3.10.0

PropertySignature

FromPropertySignature (class)

Signature

export declare class FromPropertySignature { constructor(
    type: AST.AST,
    isOptional: boolean,
    readonly isReadonly: boolean,
    annotations: AST.Annotations,
    readonly fromKey?: PropertyKey | undefined
  ) }

Added in v3.10.0

PropertySignature (interface)

Signature

export interface PropertySignature<
  TypeToken extends PropertySignature.Token,
  Type,
  Key extends PropertyKey,
  EncodedToken extends PropertySignature.Token,
  Encoded,
  HasDefault extends boolean = false,
  R = never
> extends Schema.Variance<Type, Encoded, R>,
    Pipeable {
  readonly [PropertySignatureTypeId]: null
  readonly _TypeToken: TypeToken
  readonly _EncodedToken: EncodedToken
  readonly _HasDefault: HasDefault
  readonly _Key: Key
  readonly ast: PropertySignature.AST

  annotations(
    annotations: PropertySignature.Annotations<Type>
  ): PropertySignature<TypeToken, Type, Key, EncodedToken, Encoded, HasDefault, R>
}

Added in v3.10.0

PropertySignatureDeclaration (class)

Signature

export declare class PropertySignatureDeclaration { constructor(
    type: AST.AST,
    isOptional: boolean,
    readonly isReadonly: boolean,
    annotations: AST.Annotations,
    readonly defaultValue: (() => unknown) | undefined
  ) }

Added in v3.10.0

toString (method)

Signature

toString()

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "PropertySignatureDeclaration"

Added in v3.10.0

PropertySignatureTransformation (class)

Signature

export declare class PropertySignatureTransformation { constructor(
    readonly from: FromPropertySignature,
    readonly to: ToPropertySignature,
    readonly decode: AST.PropertySignatureTransformation["decode"],
    readonly encode: AST.PropertySignatureTransformation["encode"]
  ) }

Added in v3.10.0

toString (method)

Signature

toString()

Added in v3.10.0

_tag (property)

Signature

readonly _tag: "PropertySignatureTransformation"

Added in v3.10.0

ToPropertySignature (class)

Signature

export declare class ToPropertySignature { constructor(
    type: AST.AST,
    isOptional: boolean,
    readonly isReadonly: boolean,
    annotations: AST.Annotations,
    readonly defaultValue: (() => unknown) | undefined
  ) }

Added in v3.10.0

fromKey

Enhances a property signature by specifying a different key for it in the Encoded type.

Signature

export declare const fromKey: {
  <Key extends PropertyKey>(
    key: Key
  ): <
    TypeToken extends PropertySignature.Token,
    Type,
    EncodedToken extends PropertySignature.Token,
    Encoded,
    HasDefault extends boolean,
    R
  >(
    self: PropertySignature<TypeToken, Type, PropertyKey, EncodedToken, Encoded, HasDefault, R>
  ) => PropertySignature<TypeToken, Type, Key, EncodedToken, Encoded, HasDefault, R>
  <
    Type,
    TypeToken extends PropertySignature.Token,
    Encoded,
    EncodedToken extends PropertySignature.Token,
    HasDefault extends boolean,
    R,
    Key extends PropertyKey
  >(
    self: PropertySignature<TypeToken, Type, PropertyKey, EncodedToken, Encoded, HasDefault, R>,
    key: Key
  ): PropertySignature<TypeToken, Type, Key, EncodedToken, Encoded, HasDefault, R>
}

Added in v3.10.0

makePropertySignature

Signature

export declare const makePropertySignature: <
  TypeToken extends PropertySignature.Token,
  Type,
  Key extends PropertyKey,
  EncodedToken extends PropertySignature.Token,
  Encoded,
  HasDefault extends boolean = false,
  R = never
>(
  ast: PropertySignature.AST
) => PropertySignatureImpl<TypeToken, Type, Key, EncodedToken, Encoded, HasDefault, R>

Added in v3.10.0

optional

Signature

export declare const optional: <S extends Schema.All>(self: S) => optional<S>

Added in v3.10.0

optionalToOptional

Converts an optional property to another optional property through a transformation Option -> Option.

  • decode:
    • none as argument means the value is missing in the input.
    • none as return value means the value will be missing in the output.
  • encode:
    • none as argument means the value is missing in the input.
    • none as return value means the value will be missing in the output.

Signature

export declare const optionalToOptional: <FA, FI, FR, TA, TI, TR>(
  from: Schema<FA, FI, FR>,
  to: Schema<TA, TI, TR>,
  options: {
    readonly decode: (o: option_.Option<FA>) => option_.Option<TI>
    readonly encode: (o: option_.Option<TI>) => option_.Option<FA>
  }
) => PropertySignature<"?:", TA, never, "?:", FI, false, FR | TR>

Added in v3.10.0

optionalToRequired

Converts an optional property to a required one through a transformation Option -> Type.

  • decode: none as argument means the value is missing in the input.
  • encode: none as return value means the value will be missing in the output.

Signature

export declare const optionalToRequired: <FA, FI, FR, TA, TI, TR>(
  from: Schema<FA, FI, FR>,
  to: Schema<TA, TI, TR>,
  options: { readonly decode: (o: option_.Option<FA>) => TI; readonly encode: (ti: TI) => option_.Option<FA> }
) => PropertySignature<":", TA, never, "?:", FI, false, FR | TR>

Added in v3.10.0

optionalWith

Signature

export declare const optionalWith: {
  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(
    options: Options
  ): (self: S) => optionalWith<S, Options>
  <S extends Schema.All, Options extends OptionalOptions<Schema.Type<S>>>(
    self: S,
    options: Options
  ): optionalWith<S, Options>
}

Added in v3.10.0

propertySignature

Lifts a Schema into a PropertySignature.

Signature

export declare const propertySignature: <S extends Schema.All>(self: S) => propertySignature<S>

Added in v3.10.0

requiredToOptional

Converts an optional property to a required one through a transformation Type -> Option.

  • decode: none as return value means the value will be missing in the output.
  • encode: none as argument means the value is missing in the input.

Signature

export declare const requiredToOptional: <FA, FI, FR, TA, TI, TR>(
  from: Schema<FA, FI, FR>,
  to: Schema<TA, TI, TR>,
  options: { readonly decode: (fa: FA) => option_.Option<TI>; readonly encode: (o: option_.Option<TI>) => FA }
) => PropertySignature<"?:", TA, never, ":", FI, false, FR | TR>

Added in v3.10.0

withConstructorDefault

Enhances a property signature with a default constructor value.

Signature

export declare const withConstructorDefault: {
  <Type>(
    defaultValue: () => Types.NoInfer<Type>
  ): <
    TypeToken extends PropertySignature.Token,
    Key extends PropertyKey,
    EncodedToken extends PropertySignature.Token,
    Encoded,
    R
  >(
    self: PropertySignature<TypeToken, Type, Key, EncodedToken, Encoded, boolean, R>
  ) => PropertySignature<TypeToken, Type, Key, EncodedToken, Encoded, true, R>
  <
    TypeToken extends PropertySignature.Token,
    Type,
    Key extends PropertyKey,
    EncodedToken extends PropertySignature.Token,
    Encoded,
    R
  >(
    self: PropertySignature<TypeToken, Type, Key, EncodedToken, Encoded, boolean, R>,
    defaultValue: () => Types.NoInfer<Type>
  ): PropertySignature<TypeToken, Type, Key, EncodedToken, Encoded, true, R>
}

Added in v3.10.0

withDecodingDefault

Enhances a property signature with a default decoding value.

Signature

export declare const withDecodingDefault: {
  <Type>(
    defaultValue: () => Types.NoInfer<Type>
  ): <Key extends PropertyKey, Encoded, HasDefault extends boolean, R>(
    self: PropertySignature<"?:", Type, Key, "?:", Encoded, HasDefault, R>
  ) => PropertySignature<":", Exclude<Type, undefined>, Key, "?:", Encoded, HasDefault, R>
  <Type, Key extends PropertyKey, Encoded, HasDefault extends boolean, R>(
    self: PropertySignature<"?:", Type, Key, "?:", Encoded, HasDefault, R>,
    defaultValue: () => Types.NoInfer<Type>
  ): PropertySignature<":", Exclude<Type, undefined>, Key, "?:", Encoded, HasDefault, R>
}

Added in v3.10.0

withDefaults

Enhances a property signature with a default decoding value and a default constructor value.

Signature

export declare const withDefaults: {
  <Type>(defaults: {
    constructor: () => Types.NoInfer<Exclude<Type, undefined>>
    decoding: () => Types.NoInfer<Type>
  }): <Key extends PropertyKey, Encoded, R>(
    self: PropertySignature<"?:", Type, Key, "?:", Encoded, boolean, R>
  ) => PropertySignature<":", Exclude<Type, undefined>, Key, "?:", Encoded, true, R>
  <Type, Key extends PropertyKey, Encoded, R>(
    self: PropertySignature<"?:", Type, Key, "?:", Encoded, boolean, R>,
    defaults: { constructor: () => Types.NoInfer<Exclude<Type, undefined>>; decoding: () => Types.NoInfer<Type> }
  ): PropertySignature<":", Exclude<Type, undefined>, Key, "?:", Encoded, true, R>
}

Added in v3.10.0

ReadonlyArray filters

itemsCount

Signature

export declare const itemsCount: <A>(
  n: number,
  annotations?: Annotations.Filter<ReadonlyArray<A>>
) => <I, R>(self: Schema<ReadonlyArray<A>, I, R>) => filter<Schema<ReadonlyArray<A>, I, R>>

Added in v3.10.0

maxItems

Signature

export declare const maxItems: <A>(
  n: number,
  annotations?: Annotations.Filter<ReadonlyArray<A>>
) => <I, R>(self: Schema<ReadonlyArray<A>, I, R>) => filter<Schema<ReadonlyArray<A>, I, R>>

Added in v3.10.0

minItems

Signature

export declare const minItems: <A>(
  n: number,
  annotations?: Annotations.Filter<ReadonlyArray<A>>
) => <I, R>(self: Schema<ReadonlyArray<A>, I, R>) => filter<Schema<ReadonlyArray<A>, I, R>>

Added in v3.10.0

ReadonlyArray transformations

getNumberIndexedAccess

Signature

export declare const getNumberIndexedAccess: <A extends ReadonlyArray<any>, I extends ReadonlyArray<any>, R>(
  self: Schema<A, I, R>
) => SchemaClass<A[number], I[number], R>

Added in v3.10.0

Get the first element of a ReadonlyArray, or None if the array is empty.

Signature

export declare const head: <A, I, R>(self: Schema<ReadonlyArray<A>, I, R>) => SchemaClass<option_.Option<A>, I, R>

Added in v3.10.0

headOrElse

Retrieves the first element of a ReadonlyArray.

If the array is empty, it returns the fallback argument if provided; otherwise, it fails.

Signature

export declare const headOrElse: {
  <A>(fallback?: LazyArg<A>): <I, R>(self: Schema<ReadonlyArray<A>, I, R>) => SchemaClass<A, I, R>
  <A, I, R>(self: Schema<ReadonlyArray<A>, I, R>, fallback?: LazyArg<A>): SchemaClass<A, I, R>
}

Added in v3.10.0

ReadonlyMap

ReadonlyMapFromSelf

Signature

export declare const ReadonlyMapFromSelf: <K extends Schema.Any, V extends Schema.Any>({
  key,
  value
}: {
  readonly key: K
  readonly value: V
}) => ReadonlyMapFromSelf<K, V>

Added in v3.10.0

ReadonlyMap transformations

ReadonlyMap

Signature

export declare const ReadonlyMap: <K extends Schema.Any, V extends Schema.Any>({
  key,
  value
}: {
  readonly key: K
  readonly value: V
}) => ReadonlyMap$<K, V>

Added in v3.10.0

ReadonlyMapFromRecord

Signature

export declare const ReadonlyMapFromRecord: <KA, KR, VA, VI, VR>({
  key,
  value
}: {
  key: Schema<KA, string, KR>
  value: Schema<VA, VI, VR>
}) => Schema<ReadonlyMap<KA, VA>, { readonly [x: string]: VI }, KR | VR>

Added in v3.10.0

ReadonlySet

ReadonlySetFromSelf

Signature

export declare const ReadonlySetFromSelf: <Value extends Schema.Any>(value: Value) => ReadonlySetFromSelf<Value>

Added in v3.10.0

ReadonlySet transformations

ReadonlySet

Signature

export declare const ReadonlySet: <Value extends Schema.Any>(value: Value) => ReadonlySet$<Value>

Added in v3.10.0

Redacted constructors

RedactedFromSelf

Signature

export declare const RedactedFromSelf: <Value extends Schema.Any>(value: Value) => RedactedFromSelf<Value>

Added in v3.10.0

Redacted transformations

Redacted

A schema that transforms any type A into a Redacted<A>.

Signature

export declare const Redacted: <Value extends Schema.Any>(value: Value) => Redacted<Value>

Added in v3.10.0

Set

SetFromSelf

Signature

export declare const SetFromSelf: <Value extends Schema.Any>(value: Value) => SetFromSelf<Value>

Added in v3.10.0

Set transformations

Set

Signature

export declare const Set: <Value extends Schema.Any>(value: Value) => Set$<Value>

Added in v3.10.0

SortedSet transformations

SortedSet

Signature

export declare const SortedSet: <Value extends Schema.Any>(
  value: Value,
  ordA: Order.Order<Schema.Type<Value>>
) => SortedSet<Value>

Added in v3.10.0

SortedSetFromSelf

Signature

export declare const SortedSetFromSelf: <Value extends Schema.Any>(
  value: Value,
  ordA: Order.Order<Schema.Type<Value>>,
  ordI: Order.Order<Schema.Encoded<Value>>
) => SortedSetFromSelf<Value>

Added in v3.10.0

TimeZone constructors

TimeZoneFromSelf

Signature

export declare const TimeZoneFromSelf: TimeZoneFromSelf

Added in v3.10.0

TimeZoneNamedFromSelf (class)

Describes a schema that represents a TimeZone.Named instance.

Signature

export declare class TimeZoneNamedFromSelf

Added in v3.10.0

TimeZoneOffsetFromSelf (class)

Describes a schema that represents a TimeZone.Offset instance.

Signature

export declare class TimeZoneOffsetFromSelf

Added in v3.10.0

TimeZone transformations

TimeZone (class)

Defines a schema that attempts to convert a string to a TimeZone using the DateTime.zoneFromString constructor.

Signature

export declare class TimeZone

Added in v3.10.0

TimeZoneNamed (class)

Defines a schema that attempts to convert a string to a TimeZone.Named instance using the DateTime.zoneUnsafeMakeNamed constructor.

Signature

export declare class TimeZoneNamed

Added in v3.10.0

TimeZoneOffset (class)

Defines a schema that converts a number to a TimeZone.Offset instance using the DateTime.zoneMakeOffset constructor.

Signature

export declare class TimeZoneOffset

Added in v3.10.0

URL constructors

URLFromSelf (class)

Defines a schema that represents a URL object.

Signature

export declare class URLFromSelf

Added in v3.11.0

URL transformations

URL

Defines a schema that attempts to convert a string to a URL object using the new URL constructor.

Signature

export declare const URL: typeof URL$

Added in v3.11.0

Uint8Array constructors

Uint8ArrayFromSelf

Signature

export declare const Uint8ArrayFromSelf: Schema<Uint8Array, Uint8Array, never>

Added in v3.10.0

Uint8Array transformations

Uint8Array

A schema that transforms an array of numbers into a Uint8Array.

Signature

export declare const Uint8Array: Schema<Uint8Array, readonly number[], never>

Added in v3.10.0

Uint8ArrayFromBase64

Decodes a base64 (RFC4648) encoded string into a Uint8Array.

Signature

export declare const Uint8ArrayFromBase64: Schema<Uint8Array, string, never>

Added in v3.10.0

Uint8ArrayFromBase64Url

Decodes a base64 (URL) encoded string into a Uint8Array.

Signature

export declare const Uint8ArrayFromBase64Url: Schema<Uint8Array, string, never>

Added in v3.10.0

Uint8ArrayFromHex

Decodes a hex encoded string into a Uint8Array.

Signature

export declare const Uint8ArrayFromHex: Schema<Uint8Array, string, never>

Added in v3.10.0

accessor

exitSchema

Signature

export declare const exitSchema: <SA, SI, FA, FI, R>(
  self: WithResult<SA, SI, FA, FI, R>
) => Schema<exit_.Exit<SA, FA>, ExitEncoded<SI, FI, unknown>, R>

Added in v3.10.0

failureSchema

Signature

export declare const failureSchema: <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Schema<FA, FI, R>

Added in v3.10.0

serializableSchema

Signature

export declare const serializableSchema: <A, I, R>(self: Serializable<A, I, R>) => Schema<A, I, R>

Added in v3.10.0

successSchema

Signature

export declare const successSchema: <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Schema<SA, SI, R>

Added in v3.10.0

annotations

Annotable (interface)

Signature

export interface Annotable<Self extends Schema<A, I, R>, A, I = A, R = never> extends Schema<A, I, R> {
  annotations(annotations: Annotations.GenericSchema<A>): Self
}

Added in v3.10.0

Annotable (namespace)

Added in v3.10.0

All (type alias)

Signature

export type All =
  | Any
  | Annotable<any, any, never, unknown>
  | Annotable<any, never, any, unknown>
  | Annotable<any, never, never, unknown>

Added in v3.10.0

Any (type alias)

Signature

export type Any = Annotable<any, any, any, unknown>

Added in v3.10.0

Self (type alias)

Signature

export type Self<S extends All> = ReturnType<S["annotations"]>

Added in v3.10.0

AnnotableClass (interface)

Signature

export interface AnnotableClass<Self extends Schema<A, I, R>, A, I = A, R = never> extends Annotable<Self, A, I, R> {
  new (_: never): Schema.Variance<A, I, R>
}

Added in v3.10.0

Annotations (namespace)

Added in v3.10.0

Doc (interface)

Signature

export interface Doc<A> extends AST.Annotations {
  readonly title?: AST.TitleAnnotation
  readonly description?: AST.DescriptionAnnotation
  readonly documentation?: AST.DocumentationAnnotation
  readonly examples?: AST.ExamplesAnnotation<A>
  readonly default?: AST.DefaultAnnotation<A>
}

Added in v3.10.0

Filter (interface)

Signature

export interface Filter<A, P = A> extends Schema<A, readonly [P]> {}

Added in v3.10.0

GenericSchema (interface)

Signature

export interface GenericSchema<A> extends Schema<A> {
  readonly arbitrary?: (..._: any) => LazyArbitrary<A>
  readonly pretty?: (..._: any) => pretty_.Pretty<A>
  readonly equivalence?: (..._: any) => Equivalence.Equivalence<A>
}

Added in v3.11.6

Schema (interface)

Signature

export interface Schema<A, TypeParameters extends ReadonlyArray<any> = readonly []> extends Doc<A> {
  readonly identifier?: AST.IdentifierAnnotation
  readonly message?: AST.MessageAnnotation
  readonly schemaId?: AST.SchemaIdAnnotation
  readonly jsonSchema?: AST.JSONSchemaAnnotation
  readonly arbitrary?: ArbitraryAnnotation<A, TypeParameters>
  readonly pretty?: pretty_.PrettyAnnotation<A, TypeParameters>
  readonly equivalence?: AST.EquivalenceAnnotation<A, TypeParameters>
  readonly concurrency?: AST.ConcurrencyAnnotation
  readonly batching?: AST.BatchingAnnotation
  readonly parseIssueTitle?: AST.ParseIssueTitleAnnotation
  readonly parseOptions?: AST.ParseOptions
  readonly decodingFallback?: AST.DecodingFallbackAnnotation<A>
}

Added in v3.10.0

annotations

Merges a set of new annotations with existing ones, potentially overwriting any duplicates.

Signature

export declare const annotations: {
  <S extends Annotable.All>(annotations: Annotations.GenericSchema<Schema.Type<S>>): (self: S) => Annotable.Self<S>
  <S extends Annotable.All>(self: S, annotations: Annotations.GenericSchema<Schema.Type<S>>): Annotable.Self<S>
}

Added in v3.10.0

api interface

Array$ (interface)

Signature

export interface Array$<Value extends Schema.Any> extends TupleType<[], [Value]> {
  readonly value: Value
  annotations(annotations: Annotations.Schema<TupleType.Type<[], [Value]>>): Array$<Value>
}

Added in v3.10.0

ArrayEnsure (interface)

Signature

export interface ArrayEnsure<Value extends Schema.Any>
  extends AnnotableClass<
    ArrayEnsure<Value>,
    ReadonlyArray<Schema.Type<Value>>,
    Schema.Encoded<Value> | ReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

Cause (interface)

Signature

export interface Cause<E extends Schema.All, D extends Schema.All>
  extends AnnotableClass<
    Cause<E, D>,
    cause_.Cause<Schema.Type<E>>,
    CauseEncoded<Schema.Encoded<E>, Schema.Encoded<D>>,
    Schema.Context<E> | Schema.Context<D>
  > {}

Added in v3.10.0

CauseFromSelf (interface)

Signature

export interface CauseFromSelf<E extends Schema.All, D extends Schema.All>
  extends AnnotableClass<
    CauseFromSelf<E, D>,
    cause_.Cause<Schema.Type<E>>,
    cause_.Cause<Schema.Encoded<E>>,
    Schema.Context<E> | Schema.Context<D>
  > {}

Added in v3.10.0

Chunk (interface)

Signature

export interface Chunk<Value extends Schema.Any>
  extends AnnotableClass<
    Chunk<Value>,
    chunk_.Chunk<Schema.Type<Value>>,
    ReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

ChunkFromSelf (interface)

Signature

export interface ChunkFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    ChunkFromSelf<Value>,
    chunk_.Chunk<Schema.Type<Value>>,
    chunk_.Chunk<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

Class (interface)

Signature

export interface Class<Self, Fields extends Struct.Fields, I, R, C, Inherited, Proto>
  extends Schema<Self, Simplify<I>, R> {
  new (
    props: RequiredKeys<C> extends never ? void | Simplify<C> : Simplify<C>,
    options?: MakeOptions
  ): Struct.Type<Fields> & Inherited & Proto

  /** @since 3.10.0 */
  readonly ast: AST.Transformation

  make<Args extends Array<any>, X>(this: { new (...args: Args): X }, ...args: Args): X

  annotations(annotations: Annotations.Schema<Self>): SchemaClass<Self, Simplify<I>, R>

  readonly fields: { readonly [K in keyof Fields]: Fields[K] }

  readonly identifier: string

  /**
   * @example
   * ```ts
   * import { Schema } from "effect"
   *
   * class MyClass extends Schema.Class<MyClass>("MyClass")({
   *  myField: Schema.String
   * }) {
   *  myMethod() {
   *    return this.myField + "my"
   *  }
   * }
   *
   * class NextClass extends MyClass.extend<NextClass>("NextClass")({
   *  nextField: Schema.Number
   * }) {
   *  nextMethod() {
   *    return this.myMethod() + this.myField + this.nextField
   *  }
   * }
   * ```
   */
  extend<Extended = never>(
    identifier: string
  ): <NewFields extends Struct.Fields>(
    fields: NewFields | HasFields<NewFields>,
    annotations?: ClassAnnotations<Extended, Struct.Type<Fields & NewFields>>
  ) => [Extended] extends [never]
    ? MissingSelfGeneric<"Base.extend">
    : Class<
        Extended,
        Fields & NewFields,
        I & Struct.Encoded<NewFields>,
        R | Struct.Context<NewFields>,
        C & Struct.Constructor<NewFields>,
        Self,
        Proto
      >

  /**
   * @example
   * ```ts
   * import { Effect, Schema } from "effect"
   *
   * class MyClass extends Schema.Class<MyClass>("MyClass")({
   *   myField: Schema.String
   * }) {
   *   myMethod() {
   *     return this.myField + "my"
   *   }
   * }
   *
   * class NextClass extends MyClass.transformOrFail<NextClass>("NextClass")({
   *   nextField: Schema.Number
   * }, {
   *   decode: (i) =>
   *     Effect.succeed({
   *       myField: i.myField,
   *       nextField: i.myField.length
   *     }),
   *   encode: (a) => Effect.succeed({ myField: a.myField })
   * }) {
   *   nextMethod() {
   *     return this.myMethod() + this.myField + this.nextField
   *   }
   * }
   * ```
   */
  transformOrFail<Transformed = never>(
    identifier: string
  ): <NewFields extends Struct.Fields, R2, R3>(
    fields: NewFields,
    options: {
      readonly decode: (
        input: Simplify<Struct.Type<Fields>>,
        options: ParseOptions,
        ast: AST.Transformation
      ) => Effect.Effect<Simplify<Struct.Type<Fields & NewFields>>, ParseResult.ParseIssue, R2>
      readonly encode: (
        input: Simplify<Struct.Type<Fields & NewFields>>,
        options: ParseOptions,
        ast: AST.Transformation
      ) => Effect.Effect<Struct.Type<Fields>, ParseResult.ParseIssue, R3>
    },
    annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
  ) => [Transformed] extends [never]
    ? MissingSelfGeneric<"Base.transformOrFail">
    : Class<
        Transformed,
        Fields & NewFields,
        I,
        R | Struct.Context<NewFields> | R2 | R3,
        C & Struct.Constructor<NewFields>,
        Self,
        Proto
      >

  /**
   * @example
   * ```ts
   * import { Effect, Schema } from "effect"
   *
   * class MyClass extends Schema.Class<MyClass>("MyClass")({
   *   myField: Schema.String
   * }) {
   *   myMethod() {
   *     return this.myField + "my"
   *   }
   * }
   *
   * class NextClass extends MyClass.transformOrFailFrom<NextClass>("NextClass")({
   *   nextField: Schema.Number
   * }, {
   *   decode: (i) =>
   *     Effect.succeed({
   *       myField: i.myField,
   *       nextField: i.myField.length
   *     }),
   *   encode: (a) => Effect.succeed({ myField: a.myField })
   * }) {
   *   nextMethod() {
   *     return this.myMethod() + this.myField + this.nextField
   *   }
   * }
   * ```
   */
  transformOrFailFrom<Transformed = never>(
    identifier: string
  ): <NewFields extends Struct.Fields, R2, R3>(
    fields: NewFields,
    options: {
      readonly decode: (
        input: Simplify<I>,
        options: ParseOptions,
        ast: AST.Transformation
      ) => Effect.Effect<Simplify<I & Struct.Encoded<NewFields>>, ParseResult.ParseIssue, R2>
      readonly encode: (
        input: Simplify<I & Struct.Encoded<NewFields>>,
        options: ParseOptions,
        ast: AST.Transformation
      ) => Effect.Effect<I, ParseResult.ParseIssue, R3>
    },
    annotations?: ClassAnnotations<Transformed, Struct.Type<Fields & NewFields>>
  ) => [Transformed] extends [never]
    ? MissingSelfGeneric<"Base.transformOrFailFrom">
    : Class<
        Transformed,
        Fields & NewFields,
        I,
        R | Struct.Context<NewFields> | R2 | R3,
        C & Struct.Constructor<NewFields>,
        Self,
        Proto
      >
}

Added in v3.10.0

Defect (interface)

Signature

export interface Defect extends transform<typeof Unknown, typeof Unknown> {}

Added in v3.10.0

Either (interface)

Signature

export interface Either<R extends Schema.All, L extends Schema.All>
  extends AnnotableClass<
    Either<R, L>,
    either_.Either<Schema.Type<R>, Schema.Type<L>>,
    EitherEncoded<Schema.Encoded<R>, Schema.Encoded<L>>,
    Schema.Context<R> | Schema.Context<L>
  > {}

Added in v3.10.0

EitherFromSelf (interface)

Signature

export interface EitherFromSelf<R extends Schema.All, L extends Schema.All>
  extends AnnotableClass<
    EitherFromSelf<R, L>,
    either_.Either<Schema.Type<R>, Schema.Type<L>>,
    either_.Either<Schema.Encoded<R>, Schema.Encoded<L>>,
    Schema.Context<R> | Schema.Context<L>
  > {}

Added in v3.10.0

EitherFromUnion (interface)

Signature

export interface EitherFromUnion<R extends Schema.All, L extends Schema.All>
  extends AnnotableClass<
    EitherFromUnion<R, L>,
    either_.Either<Schema.Type<R>, Schema.Type<L>>,
    Schema.Encoded<R> | Schema.Encoded<L>,
    Schema.Context<R> | Schema.Context<L>
  > {}

Added in v3.10.0

Enums (interface)

Signature

export interface Enums<A extends EnumsDefinition> extends AnnotableClass<Enums<A>, A[keyof A]> {
  readonly enums: A
}

Added in v3.10.0

Exit (interface)

Signature

export interface Exit<A extends Schema.All, E extends Schema.All, D extends Schema.All>
  extends AnnotableClass<
    Exit<A, E, D>,
    exit_.Exit<Schema.Type<A>, Schema.Type<E>>,
    ExitEncoded<Schema.Encoded<A>, Schema.Encoded<E>, Schema.Encoded<D>>,
    Schema.Context<A> | Schema.Context<E> | Schema.Context<D>
  > {}

Added in v3.10.0

ExitFromSelf (interface)

Signature

export interface ExitFromSelf<A extends Schema.All, E extends Schema.All, D extends Schema.All>
  extends AnnotableClass<
    ExitFromSelf<A, E, D>,
    exit_.Exit<Schema.Type<A>, Schema.Type<E>>,
    exit_.Exit<Schema.Encoded<A>, Schema.Encoded<E>>,
    Schema.Context<A> | Schema.Context<E> | Schema.Context<D>
  > {}

Added in v3.10.0

HashMap (interface)

Signature

export interface HashMap<K extends Schema.Any, V extends Schema.Any>
  extends AnnotableClass<
    HashMap<K, V>,
    hashMap_.HashMap<Schema.Type<K>, Schema.Type<V>>,
    ReadonlyArray<readonly [Schema.Encoded<K>, Schema.Encoded<V>]>,
    Schema.Context<K> | Schema.Context<V>
  > {}

Added in v3.10.0

HashMapFromSelf (interface)

Signature

export interface HashMapFromSelf<K extends Schema.Any, V extends Schema.Any>
  extends AnnotableClass<
    HashMapFromSelf<K, V>,
    hashMap_.HashMap<Schema.Type<K>, Schema.Type<V>>,
    hashMap_.HashMap<Schema.Encoded<K>, Schema.Encoded<V>>,
    Schema.Context<K> | Schema.Context<V>
  > {}

Added in v3.10.0

HashSet (interface)

Signature

export interface HashSet<Value extends Schema.Any>
  extends AnnotableClass<
    HashSet<Value>,
    hashSet_.HashSet<Schema.Type<Value>>,
    ReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

HashSetFromSelf (interface)

Signature

export interface HashSetFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    HashSetFromSelf<Value>,
    hashSet_.HashSet<Schema.Type<Value>>,
    hashSet_.HashSet<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

List (interface)

Signature

export interface List<Value extends Schema.Any>
  extends AnnotableClass<
    List<Value>,
    list_.List<Schema.Type<Value>>,
    ReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

ListFromSelf (interface)

Signature

export interface ListFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    ListFromSelf<Value>,
    list_.List<Schema.Type<Value>>,
    list_.List<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

Literal (interface)

Signature

export interface Literal<Literals extends array_.NonEmptyReadonlyArray<AST.LiteralValue>>
  extends AnnotableClass<Literal<Literals>, Literals[number]> {
  readonly literals: Readonly<Literals>
}

Added in v3.10.0

Map$ (interface)

Signature

export interface Map$<K extends Schema.Any, V extends Schema.Any>
  extends AnnotableClass<
    Map$<K, V>,
    Map<Schema.Type<K>, Schema.Type<V>>,
    ReadonlyArray<readonly [Schema.Encoded<K>, Schema.Encoded<V>]>,
    Schema.Context<K> | Schema.Context<V>
  > {}

Added in v3.10.0

MapFromSelf (interface)

Signature

export interface MapFromSelf<K extends Schema.Any, V extends Schema.Any>
  extends AnnotableClass<
    MapFromSelf<K, V>,
    Map<Schema.Type<K>, Schema.Type<V>>,
    ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>,
    Schema.Context<K> | Schema.Context<V>
  > {}

Added in v3.10.0

NonEmptyArray (interface)

Signature

export interface NonEmptyArray<Value extends Schema.Any> extends TupleType<[Value], [Value]> {
  readonly value: Value
  annotations(annotations: Annotations.Schema<TupleType.Type<[Value], [Value]>>): NonEmptyArray<Value>
}

Added in v3.10.0

NonEmptyArrayEnsure (interface)

Signature

export interface NonEmptyArrayEnsure<Value extends Schema.Any>
  extends AnnotableClass<
    NonEmptyArrayEnsure<Value>,
    array_.NonEmptyReadonlyArray<Schema.Type<Value>>,
    Schema.Encoded<Value> | array_.NonEmptyReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

NonEmptyChunk (interface)

Signature

export interface NonEmptyChunk<Value extends Schema.Any>
  extends AnnotableClass<
    NonEmptyChunk<Value>,
    chunk_.NonEmptyChunk<Schema.Type<Value>>,
    array_.NonEmptyReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

NonEmptyChunkFromSelf (interface)

Signature

export interface NonEmptyChunkFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    NonEmptyChunkFromSelf<Value>,
    chunk_.NonEmptyChunk<Schema.Type<Value>>,
    chunk_.NonEmptyChunk<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

NullOr (interface)

Signature

export interface NullOr<S extends Schema.All> extends Union<[S, typeof Null]> {
  annotations(annotations: Annotations.Schema<Schema.Type<S> | null>): NullOr<S>
}

Added in v3.10.0

NullishOr (interface)

Signature

export interface NullishOr<S extends Schema.All> extends Union<[S, typeof Null, typeof Undefined]> {
  annotations(annotations: Annotations.Schema<Schema.Type<S> | null | undefined>): NullishOr<S>
}

Added in v3.10.0

Option (interface)

Signature

export interface Option<Value extends Schema.Any>
  extends AnnotableClass<
    Option<Value>,
    option_.Option<Schema.Type<Value>>,
    OptionEncoded<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

OptionFromNullOr (interface)

Signature

export interface OptionFromNullOr<Value extends Schema.Any>
  extends AnnotableClass<
    OptionFromNullOr<Value>,
    option_.Option<Schema.Type<Value>>,
    Schema.Encoded<Value> | null,
    Schema.Context<Value>
  > {}

Added in v3.10.0

OptionFromNullishOr (interface)

Signature

export interface OptionFromNullishOr<Value extends Schema.Any>
  extends AnnotableClass<
    OptionFromNullishOr<Value>,
    option_.Option<Schema.Type<Value>>,
    Schema.Encoded<Value> | null | undefined,
    Schema.Context<Value>
  > {}

Added in v3.10.0

OptionFromSelf (interface)

Signature

export interface OptionFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    OptionFromSelf<Value>,
    option_.Option<Schema.Type<Value>>,
    option_.Option<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

OptionFromUndefinedOr (interface)

Signature

export interface OptionFromUndefinedOr<Value extends Schema.Any>
  extends AnnotableClass<
    OptionFromUndefinedOr<Value>,
    option_.Option<Schema.Type<Value>>,
    Schema.Encoded<Value> | undefined,
    Schema.Context<Value>
  > {}

Added in v3.10.0

ReadonlyMap$ (interface)

Signature

export interface ReadonlyMap$<K extends Schema.Any, V extends Schema.Any>
  extends AnnotableClass<
    ReadonlyMap$<K, V>,
    ReadonlyMap<Schema.Type<K>, Schema.Type<V>>,
    ReadonlyArray<readonly [Schema.Encoded<K>, Schema.Encoded<V>]>,
    Schema.Context<K> | Schema.Context<V>
  > {}

Added in v3.10.0

ReadonlyMapFromSelf (interface)

Signature

export interface ReadonlyMapFromSelf<K extends Schema.Any, V extends Schema.Any>
  extends AnnotableClass<
    ReadonlyMapFromSelf<K, V>,
    ReadonlyMap<Schema.Type<K>, Schema.Type<V>>,
    ReadonlyMap<Schema.Encoded<K>, Schema.Encoded<V>>,
    Schema.Context<K> | Schema.Context<V>
  > {}

Added in v3.10.0

ReadonlySet$ (interface)

Signature

export interface ReadonlySet$<Value extends Schema.Any>
  extends AnnotableClass<
    ReadonlySet$<Value>,
    ReadonlySet<Schema.Type<Value>>,
    ReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

ReadonlySetFromSelf (interface)

Signature

export interface ReadonlySetFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    ReadonlySetFromSelf<Value>,
    ReadonlySet<Schema.Type<Value>>,
    ReadonlySet<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

Record$ (interface)

Signature

export interface Record$<K extends Schema.All, V extends Schema.All> extends TypeLiteral<{}, [{ key: K; value: V }]> {
  readonly key: K
  readonly value: V
  annotations(annotations: Annotations.Schema<Simplify<TypeLiteral.Type<{}, [{ key: K; value: V }]>>>): Record$<K, V>
}

Added in v3.10.0

Redacted (interface)

Signature

export interface Redacted<Value extends Schema.Any>
  extends AnnotableClass<
    Redacted<Value>,
    redacted_.Redacted<Schema.Type<Value>>,
    Schema.Encoded<Value>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

RedactedFromSelf (interface)

Signature

export interface RedactedFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    RedactedFromSelf<Value>,
    redacted_.Redacted<Schema.Type<Value>>,
    redacted_.Redacted<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

Set$ (interface)

Signature

export interface Set$<Value extends Schema.Any>
  extends AnnotableClass<
    Set$<Value>,
    Set<Schema.Type<Value>>,
    ReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

SetFromSelf (interface)

Signature

export interface SetFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    SetFromSelf<Value>,
    Set<Schema.Type<Value>>,
    ReadonlySet<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

SortedSet (interface)

Signature

export interface SortedSet<Value extends Schema.Any>
  extends AnnotableClass<
    SortedSet<Value>,
    sortedSet_.SortedSet<Schema.Type<Value>>,
    ReadonlyArray<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

SortedSetFromSelf (interface)

Signature

export interface SortedSetFromSelf<Value extends Schema.Any>
  extends AnnotableClass<
    SortedSetFromSelf<Value>,
    sortedSet_.SortedSet<Schema.Type<Value>>,
    sortedSet_.SortedSet<Schema.Encoded<Value>>,
    Schema.Context<Value>
  > {}

Added in v3.10.0

Struct (interface)

Signature

export interface Struct<Fields extends Struct.Fields> extends TypeLiteral<Fields, []> {
  annotations(annotations: Annotations.Schema<Simplify<Struct.Type<Fields>>>): Struct<Fields>
  pick<Keys extends ReadonlyArray<keyof Fields>>(...keys: Keys): Struct<Simplify<Pick<Fields, Keys[number]>>>
  omit<Keys extends ReadonlyArray<keyof Fields>>(...keys: Keys): Struct<Simplify<Omit<Fields, Keys[number]>>>
}

Added in v3.10.0

TaggedClass (interface)

Signature

export interface TaggedClass<Self, Tag extends string, Fields extends Struct.Fields>
  extends Class<
    Self,
    Fields,
    Struct.Encoded<Fields>,
    Struct.Context<Fields>,
    Struct.Constructor<Omit<Fields, "_tag">>,
    {},
    {}
  > {
  readonly _tag: Tag
}

Added in v3.10.0

TaggedErrorClass (interface)

Signature

export interface TaggedErrorClass<Self, Tag extends string, Fields extends Struct.Fields>
  extends Class<
    Self,
    Fields,
    Struct.Encoded<Fields>,
    Struct.Context<Fields>,
    Struct.Constructor<Omit<Fields, "_tag">>,
    {},
    cause_.YieldableError
  > {
  readonly _tag: Tag
}

Added in v3.10.0

TaggedRequestClass (interface)

Signature

export interface TaggedRequestClass<
  Self,
  Tag extends string,
  Payload extends Struct.Fields,
  Success extends Schema.All,
  Failure extends Schema.All
> extends Class<
    Self,
    Payload,
    Struct.Encoded<Payload>,
    Struct.Context<Payload>,
    Struct.Constructor<Omit<Payload, "_tag">>,
    TaggedRequest<
      Tag,
      Self,
      Struct.Encoded<Payload>,
      Struct.Context<Payload>,
      Schema.Type<Success>,
      Schema.Encoded<Success>,
      Schema.Type<Failure>,
      Schema.Encoded<Failure>,
      Schema.Context<Success> | Schema.Context<Failure>
    >,
    {}
  > {
  readonly _tag: Tag
  readonly success: Success
  readonly failure: Failure
}

Added in v3.10.0

TaggedStruct (type alias)

Signature

export type TaggedStruct<Tag extends AST.LiteralValue, Fields extends Struct.Fields> = Struct<
  { _tag: tag<Tag> } & Fields
>

Added in v3.10.0

TimeZoneFromSelf (interface)

Signature

export interface TimeZoneFromSelf extends Union<[typeof TimeZoneOffsetFromSelf, typeof TimeZoneNamedFromSelf]> {
  annotations(annotations: Annotations.Schema<dateTime.TimeZone>): TimeZoneFromSelf
}

Added in v3.10.0

Tuple (interface)

Signature

export interface Tuple<Elements extends TupleType.Elements> extends TupleType<Elements, []> {
  annotations(annotations: Annotations.Schema<TupleType.Type<Elements, []>>): Tuple<Elements>
}

Added in v3.10.0

TupleType (interface)

Signature

export interface TupleType<Elements extends TupleType.Elements, Rest extends TupleType.Rest>
  extends AnnotableClass<
    TupleType<Elements, Rest>,
    TupleType.Type<Elements, Rest>,
    TupleType.Encoded<Elements, Rest>,
    Schema.Context<Elements[number]> | Schema.Context<Rest[number]>
  > {
  readonly elements: Readonly<Elements>
  readonly rest: Readonly<Rest>
}

Added in v3.10.0

TypeLiteral (interface)

Signature

export interface TypeLiteral<Fields extends Struct.Fields, Records extends IndexSignature.Records>
  extends AnnotableClass<
    TypeLiteral<Fields, Records>,
    Simplify<TypeLiteral.Type<Fields, Records>>,
    Simplify<TypeLiteral.Encoded<Fields, Records>>,
    Struct.Context<Fields> | IndexSignature.Context<Records>
  > {
  readonly fields: { readonly [K in keyof Fields]: Fields[K] }
  readonly records: Readonly<Records>
  annotations(
    annotations: Annotations.Schema<Simplify<TypeLiteral.Type<Fields, Records>>>
  ): TypeLiteral<Fields, Records>
  make(
    props: RequiredKeys<TypeLiteral.Constructor<Fields, Records>> extends never
      ? void | Simplify<TypeLiteral.Constructor<Fields, Records>>
      : Simplify<TypeLiteral.Constructor<Fields, Records>>,
    options?: MakeOptions
  ): Simplify<TypeLiteral.Type<Fields, Records>>
}

Added in v3.10.0

UndefinedOr (interface)

Signature

export interface UndefinedOr<S extends Schema.All> extends Union<[S, typeof Undefined]> {
  annotations(annotations: Annotations.Schema<Schema.Type<S> | undefined>): UndefinedOr<S>
}

Added in v3.10.0

Union (interface)

Signature

export interface Union<Members extends ReadonlyArray<Schema.All>>
  extends AnnotableClass<
    Union<Members>,
    Schema.Type<Members[number]>,
    Schema.Encoded<Members[number]>,
    Schema.Context<Members[number]>
  > {
  readonly members: Readonly<Members>
  annotations(annotations: Annotations.Schema<Schema.Type<Members[number]>>): Union<Members>
}

Added in v3.10.0

brand (interface)

Signature

export interface brand<S extends Schema.Any, B extends string | symbol>
  extends BrandSchema<Schema.Type<S> & Brand<B>, Schema.Encoded<S>, Schema.Context<S>> {
  annotations(annotations: Annotations.Schema<Schema.Type<S> & Brand<B>>): brand<S, B>
}

Added in v3.10.0

extend (interface)

Signature

export interface extend<Self extends Schema.Any, That extends Schema.Any>
  extends AnnotableClass<
    extend<Self, That>,
    Schema.Type<Self> & Schema.Type<That>,
    Schema.Encoded<Self> & Schema.Encoded<That>,
    Schema.Context<Self> | Schema.Context<That>
  > {}

Added in v3.10.0

filter (interface)

Signature

export interface filter<From extends Schema.Any> extends refine<Schema.Type<From>, From> {}

Added in v3.10.0

filterEffect (interface)

Signature

export interface filterEffect<S extends Schema.Any, FD = never>
  extends transformOrFail<S, SchemaClass<Schema.Type<S>>, FD> {}

Added in v3.10.0

instanceOf (interface)

Signature

export interface instanceOf<A> extends AnnotableClass<instanceOf<A>, A> {}

Added in v3.10.0

mutable (interface)

Signature

export interface mutable<S extends Schema.Any>
  extends AnnotableClass<
    mutable<S>,
    SimplifyMutable<Schema.Type<S>>,
    SimplifyMutable<Schema.Encoded<S>>,
    Schema.Context<S>
  > {}

Added in v3.10.0

optional (interface)

Signature

export interface optional<S extends Schema.All>
  extends PropertySignature<
    "?:",
    Schema.Type<S> | undefined,
    never,
    "?:",
    Schema.Encoded<S> | undefined,
    false,
    Schema.Context<S>
  > {
  readonly from: S
  annotations(annotations: PropertySignature.Annotations<Schema.Type<S> | undefined>): optional<S>
}

Added in v3.10.0

optionalWith (interface)

Signature

export interface optionalWith<S extends Schema.All, Options>
  extends PropertySignature<
    Types.Has<Options, "as" | "default"> extends true ? ":" : "?:",
    | (Types.Has<Options, "as"> extends true ? option_.Option<Schema.Type<S>> : Schema.Type<S>)
    | (Types.Has<Options, "as" | "default" | "exact"> extends true ? never : undefined),
    never,
    "?:",
    | Schema.Encoded<S>
    | (Types.Has<Options, "nullable"> extends true ? null : never)
    | (Types.Has<Options, "exact"> extends true ? never : undefined),
    Types.Has<Options, "default">,
    Schema.Context<S>
  > {
  readonly from: S
  annotations(
    annotations: PropertySignature.Annotations<
      | (Types.Has<Options, "as"> extends true ? option_.Option<Schema.Type<S>> : Schema.Type<S>)
      | (Types.Has<Options, "as" | "default" | "exact"> extends true ? never : undefined)
    >
  ): optionalWith<S, Options>
}

Added in v3.10.0

refine (interface)

Signature

export interface refine<A, From extends Schema.Any>
  extends AnnotableClass<refine<A, From>, A, Schema.Encoded<From>, Schema.Context<From>> {
  readonly [RefineSchemaId]: From // required for `type HasFields = ...`
  readonly from: From
  readonly filter: (
    a: Schema.Type<From>,
    options: ParseOptions,
    self: AST.Refinement
  ) => option_.Option<ParseResult.ParseIssue>
  make(a: Schema.Type<From>, options?: MakeOptions): A
}

Added in v3.10.0

suspend (interface)

Signature

export interface suspend<A, I, R> extends AnnotableClass<suspend<A, I, R>, A, I, R> {}

Added in v3.10.0

tag (interface)

Signature

export interface tag<Tag extends AST.LiteralValue> extends PropertySignature<":", Tag, never, ":", Tag, true, never> {}

Added in v3.10.0

transform (interface)

Signature

export interface transform<From extends Schema.Any, To extends Schema.Any> extends transformOrFail<From, To> {
  annotations(annotations: Annotations.Schema<Schema.Type<To>>): transform<From, To>
}

Added in v3.10.0

transformLiteral (interface)

Signature

export interface transformLiteral<Type, Encoded> extends Annotable<transformLiteral<Type, Encoded>, Type, Encoded> {}

Added in v3.10.0

transformOrFail (interface)

Signature

export interface transformOrFail<From extends Schema.Any, To extends Schema.Any, R = never>
  extends AnnotableClass<
    transformOrFail<From, To, R>,
    Schema.Type<To>,
    Schema.Encoded<From>,
    Schema.Context<From> | Schema.Context<To> | R
  > {
  readonly from: From
  readonly to: To
}

Added in v3.10.0

bigint constructors

NegativeBigInt

Signature

export declare const NegativeBigInt: filter<Schema<bigint, string, never>>

Added in v3.10.0

NegativeBigIntFromSelf

Signature

export declare const NegativeBigIntFromSelf: filter<Schema<bigint, bigint, never>>

Added in v3.10.0

NonNegativeBigInt

Signature

export declare const NonNegativeBigInt: filter<Schema<bigint, string, never>>

Added in v3.10.0

NonNegativeBigIntFromSelf

Signature

export declare const NonNegativeBigIntFromSelf: filter<Schema<bigint, bigint, never>>

Added in v3.10.0

NonPositiveBigInt

Signature

export declare const NonPositiveBigInt: filter<Schema<bigint, string, never>>

Added in v3.10.0

NonPositiveBigIntFromSelf

Signature

export declare const NonPositiveBigIntFromSelf: filter<Schema<bigint, bigint, never>>

Added in v3.10.0

PositiveBigInt

Signature

export declare const PositiveBigInt: filter<Schema<bigint, string, never>>

Added in v3.10.0

PositiveBigIntFromSelf

Signature

export declare const PositiveBigIntFromSelf: filter<Schema<bigint, bigint, never>>

Added in v3.10.0

bigint filters

betweenBigInt

Signature

export declare const betweenBigInt: <A extends bigint>(
  min: bigint,
  max: bigint,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanBigInt

Signature

export declare const greaterThanBigInt: <A extends bigint>(
  min: bigint,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanOrEqualToBigInt

Signature

export declare const greaterThanOrEqualToBigInt: <A extends bigint>(
  min: bigint,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanBigInt

Signature

export declare const lessThanBigInt: <A extends bigint>(
  max: bigint,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanOrEqualToBigInt

Signature

export declare const lessThanOrEqualToBigInt: <A extends bigint>(
  max: bigint,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

negativeBigInt

Signature

export declare const negativeBigInt: <A extends bigint>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

nonNegativeBigInt

Signature

export declare const nonNegativeBigInt: <A extends bigint>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

nonPositiveBigInt

Signature

export declare const nonPositiveBigInt: <A extends bigint>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

positiveBigInt

Signature

export declare const positiveBigInt: <A extends bigint>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

bigint transformations

BigInt

This schema transforms a string into a bigint by parsing the string using the BigInt function.

It returns an error if the value can’t be converted (for example when non-numeric characters are provided).

Signature

export declare const BigInt: typeof BigInt$

Added in v3.10.0

BigIntFromNumber (class)

This schema transforms a number into a bigint by parsing the number using the BigInt function.

It returns an error if the value can’t be safely encoded as a number due to being out of range.

Signature

export declare class BigIntFromNumber

Added in v3.10.0

clampBigInt

Clamps a bigint between a minimum and a maximum value.

Signature

export declare const clampBigInt: (
  minimum: bigint,
  maximum: bigint
) => <A extends bigint, I, R>(self: Schema<A, I, R>) => transform<Schema<A, I, R>, filter<Schema<A>>>

Added in v3.10.0

boolean constructors

BooleanFromUnknown (class)

Converts an arbitrary value to a boolean by testing whether it is truthy. Uses !!val to coerce the value to a boolean.

Signature

export declare class BooleanFromUnknown

Added in v3.10.0

boolean transformations

BooleanFromString (class)

Converts an string value into its corresponding boolean (“true” as true and “false” as false).

Signature

export declare class BooleanFromString

Added in v3.11.0

Not (class)

Signature

export declare class Not

Added in v3.10.0

branding

BrandSchema (interface)

Signature

export interface BrandSchema<A extends Brand<any>, I = A, R = never>
  extends AnnotableClass<BrandSchema<A, I, R>, A, I, R> {
  make(a: Brand.Unbranded<A>, options?: MakeOptions): A
}

Added in v3.10.0

brand

Returns a nominal branded schema by applying a brand to a given schema.

Schema<A> + B -> Schema<A & Brand<B>>

Signature

export declare const brand: <S extends Schema.AnyNoContext, B extends string | symbol>(
  brand: B,
  annotations?: Annotations.Schema<Schema.Type<S> & Brand<B>>
) => (self: S) => brand<S, B>

Example

import * as Schema from "effect/Schema"

const Int = Schema.Number.pipe(Schema.int(), Schema.brand("Int"))
type Int = Schema.Schema.Type<typeof Int> // number & Brand<"Int">

Added in v3.10.0

classes

Class

Signature

export declare const Class: <Self = never>(
  identifier: string
) => <Fields extends Struct.Fields>(
  fieldsOr: Fields | HasFields<Fields>,
  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
) => [Self] extends [never]
  ? MissingSelfGeneric<"Class">
  : Class<Self, Fields, Struct.Encoded<Fields>, Struct.Context<Fields>, Struct.Constructor<Fields>, {}, {}>

Example

import { Schema } from "effect"

class MyClass extends Schema.Class<MyClass>("MyClass")({
  someField: Schema.String
}) {
  someMethod() {
    return this.someField + "bar"
  }
}

Added in v3.10.0

TaggedClass

Signature

export declare const TaggedClass: <Self = never>(
  identifier?: string
) => <Tag extends string, Fields extends Struct.Fields>(
  tag: Tag,
  fieldsOr: Fields | HasFields<Fields>,
  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
) => [Self] extends [never]
  ? MissingSelfGeneric<"TaggedClass", `"Tag", `>
  : TaggedClass<Self, Tag, { readonly _tag: tag<Tag> } & Fields>

Example

import { Schema } from "effect"

class MyClass extends Schema.TaggedClass<MyClass>("MyClass")("MyClass", {
  a: Schema.String
}) {}

Added in v3.10.0

TaggedError

Signature

export declare const TaggedError: <Self = never>(
  identifier?: string
) => <Tag extends string, Fields extends Struct.Fields>(
  tag: Tag,
  fieldsOr: Fields | HasFields<Fields>,
  annotations?: ClassAnnotations<Self, Struct.Type<Fields>>
) => [Self] extends [never]
  ? MissingSelfGeneric<"TaggedError", `"Tag", `>
  : TaggedErrorClass<Self, Tag, { readonly _tag: tag<Tag> } & Fields>

Example

import { Schema } from "effect"

class MyError extends Schema.TaggedError<MyError>("MyError")("MyError", {
  module: Schema.String,
  method: Schema.String,
  description: Schema.String
}) {
  get message(): string {
    return `${this.module}.${this.method}: ${this.description}`
  }
}

Added in v3.10.0

TaggedRequest

Signature

export declare const TaggedRequest: <Self = never>(
  identifier?: string
) => <Tag extends string, Payload extends Struct.Fields, Success extends Schema.All, Failure extends Schema.All>(
  tag: Tag,
  options: { failure: Failure; success: Success; payload: Payload },
  annotations?: Annotations.Schema<Self>
) => [Self] extends [never]
  ? MissingSelfGeneric<"TaggedRequest", `"Tag", SuccessSchema, FailureSchema, `>
  : TaggedRequestClass<Self, Tag, { readonly _tag: tag<Tag> } & Payload, Success, Failure>

Example

import { Schema } from "effect"

class MyRequest extends Schema.TaggedRequest<MyRequest>("MyRequest")("MyRequest", {
  failure: Schema.String,
  success: Schema.Number,
  payload: { id: Schema.String }
}) {}

Added in v3.10.0

combinators

NullOr

Signature

export declare const NullOr: <S extends Schema.All>(self: S) => NullOr<S>

Added in v3.10.0

NullishOr

Signature

export declare const NullishOr: <S extends Schema.All>(self: S) => NullishOr<S>

Added in v3.10.0

UndefinedOr

Signature

export declare const UndefinedOr: <S extends Schema.All>(self: S) => UndefinedOr<S>

Added in v3.10.0

Union

Signature

export declare function Union<Members extends AST.Members<Schema.All>>(...members: Members): Union<Members>
export declare function Union<Member extends Schema.All>(member: Member): Member
export declare function Union(): typeof Never
export declare function Union<Members extends ReadonlyArray<Schema.All>>(
  ...members: Members
): Schema<Schema.Type<Members[number]>, Schema.Encoded<Members[number]>, Schema.Context<Members[number]>>

Added in v3.10.0

attachPropertySignature

Attaches a property signature with the specified key and value to the schema. This API is useful when you want to add a property to your schema which doesn’t describe the shape of the input, but rather maps to another schema, for example when you want to add a discriminant to a simple union.

Signature

export declare const attachPropertySignature: {
  <K extends PropertyKey, V extends AST.LiteralValue | symbol, A>(
    key: K,
    value: V,
    annotations?: Annotations.Schema<Simplify<A & { readonly [k in K]: V }>>
  ): <I, R>(schema: SchemaClass<A, I, R>) => SchemaClass<Simplify<A & { readonly [k in K]: V }>, I, R>
  <A, I, R, K extends PropertyKey, V extends AST.LiteralValue | symbol>(
    schema: Schema<A, I, R>,
    key: K,
    value: V,
    annotations?: Annotations.Schema<Simplify<A & { readonly [k in K]: V }>>
  ): SchemaClass<Simplify<A & { readonly [k in K]: V }>, I, R>
}

Example

import * as S from "effect/Schema"
import { pipe } from "effect/Function"

const Circle = S.Struct({ radius: S.Number })
const Square = S.Struct({ sideLength: S.Number })
const Shape = S.Union(
  Circle.pipe(S.attachPropertySignature("kind", "circle")),
  Square.pipe(S.attachPropertySignature("kind", "square"))
)

assert.deepStrictEqual(S.decodeSync(Shape)({ radius: 10 }), {
  kind: "circle",
  radius: 10
})

Added in v3.10.0

compose

Signature

export declare const compose: {
  <D, C extends B, R2, B>(to: Schema<D, C, R2>): <A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>
  <D, C, R2>(to: Schema<D, C, R2>): <B extends C, A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>
  <C, B, R2>(
    to: Schema<C, B, R2>,
    options?: { readonly strict: true }
  ): <A, R1>(from: Schema<B, A, R1>) => SchemaClass<C, A, R1 | R2>
  <D, C, R2>(
    to: Schema<D, C, R2>,
    options: { readonly strict: false }
  ): <B, A, R1>(from: Schema<B, A, R1>) => SchemaClass<D, A, R1 | R2>
  <B, A, R1, D, C extends B, R2>(from: Schema<B, A, R1>, to: Schema<D, C, R2>): SchemaClass<D, A, R1 | R2>
  <B extends C, A, R1, D, C, R2>(from: Schema<B, A, R1>, to: Schema<D, C, R2>): SchemaClass<D, A, R1 | R2>
  <B, A, R1, C, R2>(
    from: Schema<B, A, R1>,
    to: Schema<C, B, R2>,
    options?: { readonly strict: true }
  ): SchemaClass<C, A, R1 | R2>
  <B, A, R1, D, C, R2>(
    from: Schema<B, A, R1>,
    to: Schema<D, C, R2>,
    options: { readonly strict: false }
  ): SchemaClass<D, A, R1 | R2>
}

Added in v3.10.0

extend

Extends a schema with another schema.

Not all extensions are supported, and their support depends on the nature of the involved schemas.

Possible extensions include:

  • Schema.String with another Schema.String refinement or a string literal
  • Schema.Number with another Schema.Number refinement or a number literal
  • Schema.Boolean with another Schema.Boolean refinement or a boolean literal
  • A struct with another struct where overlapping fields support extension
  • A struct with in index signature
  • A struct with a union of supported schemas
  • A refinement of a struct with a supported schema
  • A suspend of a struct with a supported schema

Signature

export declare const extend: {
  <That extends Schema.Any>(that: That): <Self extends Schema.Any>(self: Self) => extend<Self, That>
  <Self extends Schema.Any, That extends Schema.Any>(self: Self, that: That): extend<Self, That>
}

Example

import * as Schema from "effect/Schema"

const schema = Schema.Struct({
  a: Schema.String,
  b: Schema.String
})

// const extended: Schema<
//   {
//     readonly a: string
//     readonly b: string
//   } & {
//     readonly c: string
//   } & {
//     readonly [x: string]: string
//   }
// >
const extended = Schema.asSchema(
  schema.pipe(
    Schema.extend(Schema.Struct({ c: Schema.String })), // <= you can add more fields
    Schema.extend(Schema.Record({ key: Schema.String, value: Schema.String })) // <= you can add index signatures
  )
)

Added in v3.10.0

keyof

Signature

export declare const keyof: <A, I, R>(self: Schema<A, I, R>) => SchemaClass<keyof A>

Added in v3.10.0

mutable

Creates a new schema with shallow mutability applied to its properties.

Signature

export declare const mutable: <S extends Schema.Any>(schema: S) => mutable<S>

Added in v3.10.0

partial

Signature

export declare const partial: <A, I, R>(
  self: Schema<A, I, R>
) => SchemaClass<{ [K in keyof A]?: A[K] | undefined }, { [K in keyof I]?: I[K] | undefined }, R>

Added in v3.10.0

partialWith

Signature

export declare const partialWith: {
  <const Options extends { readonly exact: true }>(
    options: Options
  ): <A, I, R>(self: Schema<A, I, R>) => SchemaClass<{ [K in keyof A]?: A[K] }, { [K in keyof I]?: I[K] }, R>
  <A, I, R, const Options extends { readonly exact: true } | undefined>(
    self: Schema<A, I, R>,
    options: Options
  ): SchemaClass<{ [K in keyof A]?: A[K] }, { [K in keyof I]?: I[K] }, R>
}

Added in v3.10.0

required

Signature

export declare const required: <A, I, R>(
  self: Schema<A, I, R>
) => SchemaClass<{ [K in keyof A]-?: A[K] }, { [K in keyof I]-?: I[K] }, R>

Added in v3.10.0

constructors

Array

Signature

export declare const Array: <Value extends Schema.Any>(value: Value) => Array$<Value>

Added in v3.10.0

ArrayEnsure

Signature

export declare const ArrayEnsure: <Value extends Schema.Any>(value: Value) => ArrayEnsure<Value>

Added in v3.10.0

Enums

Signature

export declare const Enums: <A extends EnumsDefinition>(enums: A) => Enums<A>

Added in v3.10.0

Literal

Signature

export declare function Literal<Literals extends array_.NonEmptyReadonlyArray<AST.LiteralValue>>(
  ...literals: Literals
): Literal<Literals>
export declare function Literal(): Never
export declare function Literal<Literals extends ReadonlyArray<AST.LiteralValue>>(
  ...literals: Literals
): Schema<Literals[number]>

Added in v3.10.0

NonEmptyArray

Signature

export declare const NonEmptyArray: <Value extends Schema.Any>(value: Value) => NonEmptyArray<Value>

Added in v3.10.0

NonEmptyArrayEnsure

Signature

export declare const NonEmptyArrayEnsure: <Value extends Schema.Any>(value: Value) => NonEmptyArrayEnsure<Value>

Added in v3.10.0

Record

Signature

export declare const Record: <K extends Schema.All, V extends Schema.All>(options: {
  readonly key: K
  readonly value: V
}) => Record$<K, V>

Added in v3.10.0

Struct

Signature

export declare function Struct<Fields extends Struct.Fields, const Records extends IndexSignature.NonEmptyRecords>(
  fields: Fields,
  ...records: Records
): TypeLiteral<Fields, Records>
export declare function Struct<Fields extends Struct.Fields>(fields: Fields): Struct<Fields>

Added in v3.10.0

TaggedStruct

A tagged struct is a struct that has a tag property that is used to distinguish between different types of objects.

The tag is optional when using the make method.

Signature

export declare const TaggedStruct: <Tag extends AST.LiteralValue, Fields extends Struct.Fields>(
  value: Tag,
  fields: Fields
) => TaggedStruct<Tag, Fields>

Example

import { Schema } from "effect"

const User = Schema.TaggedStruct("User", {
  name: Schema.String,
  age: Schema.Number
})

assert.deepStrictEqual(User.make({ name: "John", age: 44 }), { _tag: "User", name: "John", age: 44 })

Added in v3.10.0

Tuple

Signature

export declare function Tuple<
  const Elements extends TupleType.Elements,
  Rest extends array_.NonEmptyReadonlyArray<TupleType.Rest[number]>
>(elements: Elements, ...rest: Rest): TupleType<Elements, Rest>
export declare function Tuple<Elements extends TupleType.Elements>(...elements: Elements): Tuple<Elements>

Added in v3.10.0

UniqueSymbolFromSelf

Signature

export declare const UniqueSymbolFromSelf: <S extends symbol>(symbol: S) => SchemaClass<S>

Added in v3.10.0

declare

The constraint R extends Schema.Context<P[number]> enforces dependencies solely from typeParameters. This ensures that when you call Schema.to or Schema.from, you receive a schema with a never context.

Signature

export declare const declare: {
  <A>(is: (input: unknown) => input is A, annotations?: Annotations.Schema<A>): SchemaClass<A>
  <const P extends ReadonlyArray<Schema.All>, I, A>(
    typeParameters: P,
    options: {
      readonly decode: (
        ...typeParameters: { readonly [K in keyof P]: Schema<Schema.Type<P[K]>, Schema.Encoded<P[K]>, never> }
      ) => (
        input: unknown,
        options: ParseOptions,
        ast: AST.Declaration
      ) => Effect.Effect<A, ParseResult.ParseIssue, never>
      readonly encode: (
        ...typeParameters: { readonly [K in keyof P]: Schema<Schema.Type<P[K]>, Schema.Encoded<P[K]>, never> }
      ) => (
        input: unknown,
        options: ParseOptions,
        ast: AST.Declaration
      ) => Effect.Effect<I, ParseResult.ParseIssue, never>
    },
    annotations?: Annotations.Schema<A, { readonly [K in keyof P]: Schema.Type<P[K]> }>
  ): SchemaClass<A, I, Schema.Context<P[number]>>
}

Added in v3.10.0

fromBrand

Signature

export declare const fromBrand: <C extends Brand<string | symbol>, A extends Brand.Unbranded<C>>(
  constructor: Brand.Constructor<C>,
  annotations?: Annotations.Filter<C, A>
) => <I, R>(self: Schema<A, I, R>) => BrandSchema<A & C, I, R>

Added in v3.10.0

instanceOf

Signature

export declare const instanceOf: <A extends abstract new (...args: any) => any>(
  constructor: A,
  annotations?: Annotations.Schema<InstanceType<A>>
) => instanceOf<InstanceType<A>>

Added in v3.10.0

make

Signature

export declare const make: <A, I = A, R = never>(ast: AST.AST) => SchemaClass<A, I, R>

Added in v3.10.0

pickLiteral

Creates a new Schema from a literal schema.

Signature

export declare const pickLiteral: <A extends AST.LiteralValue, L extends array_.NonEmptyReadonlyArray<A>>(
  ...literals: L
) => <I, R>(_schema: Schema<A, I, R>) => Literal<[...L]>

Example

import * as Schema from "effect/Schema"
import { Either } from "effect"

const schema = Schema.Literal("a", "b", "c").pipe(Schema.pickLiteral("a", "b"))

assert.deepStrictEqual(Schema.decodeSync(schema)("a"), "a")
assert.deepStrictEqual(Schema.decodeSync(schema)("b"), "b")
assert.strictEqual(Either.isLeft(Schema.decodeUnknownEither(schema)("c")), true)

Added in v3.10.0

suspend

Signature

export declare const suspend: <A, I, R>(f: () => Schema<A, I, R>) => suspend<A, I, R>

Added in v3.10.0

transformLiteral

Creates a new Schema which transforms literal values.

Signature

export declare const transformLiteral: <Encoded extends AST.LiteralValue, Type extends AST.LiteralValue>(
  from: Encoded,
  to: Type
) => transformLiteral<Type, Encoded>

Example

import * as S from "effect/Schema"

const schema = S.transformLiteral(0, "a")

assert.deepStrictEqual(S.decodeSync(schema)(0), "a")

Added in v3.10.0

transformLiterals

Creates a new Schema which maps between corresponding literal values.

Signature

export declare function transformLiterals<
  const A extends AST.Members<readonly [from: AST.LiteralValue, to: AST.LiteralValue]>
>(...pairs: A): Union<{ -readonly [I in keyof A]: transformLiteral<A[I][1], A[I][0]> }>
export declare function transformLiterals<Encoded extends AST.LiteralValue, Type extends AST.LiteralValue>(
  pairs: [Encoded, Type]
): transformLiteral<Type, Encoded>
export declare function transformLiterals<
  const A extends ReadonlyArray<readonly [from: AST.LiteralValue, to: AST.LiteralValue]>
>(...pairs: A): Schema<A[number][1], A[number][0]>

Example

import * as S from "effect/Schema"

const Animal = S.transformLiterals([0, "cat"], [1, "dog"], [2, "cow"])

assert.deepStrictEqual(S.decodeSync(Animal)(1), "dog")

Added in v3.10.0

decoding

decode

Signature

export declare const decode: <A, I, R>(
  schema: Schema<A, I, R>,
  options?: ParseOptions
) => (i: I, overrideOptions?: ParseOptions) => Effect.Effect<A, ParseResult.ParseError, R>

Added in v3.10.0

decodeEither

Signature

export declare const decodeEither: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (i: I, overrideOptions?: ParseOptions) => either_.Either<A, ParseResult.ParseError>

Added in v3.10.0

decodeOption

Signature

export declare const decodeOption: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (i: I, overrideOptions?: ParseOptions) => option_.Option<A>

Added in v3.10.0

decodePromise

Signature

export declare const decodePromise: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (i: I, overrideOptions?: ParseOptions) => Promise<A>

Added in v3.10.0

decodeSync

Signature

export declare const decodeSync: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (i: I, overrideOptions?: ParseOptions) => A

Added in v3.10.0

decodeUnknown

Signature

export declare const decodeUnknown: <A, I, R>(
  schema: Schema<A, I, R>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => Effect.Effect<A, ParseResult.ParseError, R>

Added in v3.10.0

decodeUnknownEither

Signature

export declare const decodeUnknownEither: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => either_.Either<A, ParseResult.ParseError>

Added in v3.10.0

decodeUnknownOption

Signature

export declare const decodeUnknownOption: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => option_.Option<A>

Added in v3.10.0

decodeUnknownPromise

Signature

export declare const decodeUnknownPromise: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => Promise<A>

Added in v3.10.0

decodeUnknownSync

Signature

export declare const decodeUnknownSync: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => A

Added in v3.10.0

deserialize

Signature

export declare const deserialize: {
  (value: unknown): <A, I, R>(self: Serializable<A, I, R>) => Effect.Effect<A, ParseResult.ParseError, R>
  <A, I, R>(self: Serializable<A, I, R>, value: unknown): Effect.Effect<A, ParseResult.ParseError, R>
}

Added in v3.10.0

deserializeExit

Signature

export declare const deserializeExit: {
  (
    value: unknown
  ): <SA, SI, FA, FI, R>(
    self: WithResult<SA, SI, FA, FI, R>
  ) => Effect.Effect<exit_.Exit<SA, FA>, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(
    self: WithResult<SA, SI, FA, FI, R>,
    value: unknown
  ): Effect.Effect<exit_.Exit<SA, FA>, ParseResult.ParseError, R>
}

Added in v3.10.0

deserializeFailure

Signature

export declare const deserializeFailure: {
  (
    value: unknown
  ): <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<FA, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: unknown): Effect.Effect<FA, ParseResult.ParseError, R>
}

Added in v3.10.0

deserializeSuccess

Signature

export declare const deserializeSuccess: {
  (
    value: unknown
  ): <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<SA, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: unknown): Effect.Effect<SA, ParseResult.ParseError, R>
}

Added in v3.10.0

defect

Defect

Defines a schema for handling JavaScript errors (Error instances) and other types of defects. It decodes objects into Error instances if they match the expected structure (i.e., have a message and optionally a name and stack), or converts other values to their string representations.

When encoding, it converts Error instances back into plain objects containing only the error’s name and message, or other values into their string forms.

This is useful for serializing and deserializing errors across network boundaries where error objects do not natively serialize.

Signature

export declare const Defect: Defect

Added in v3.10.0

encoding

encode

Signature

export declare const encode: <A, I, R>(
  schema: Schema<A, I, R>,
  options?: ParseOptions
) => (a: A, overrideOptions?: ParseOptions) => Effect.Effect<I, ParseResult.ParseError, R>

Added in v3.10.0

encodeEither

Signature

export declare const encodeEither: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (a: A, overrideOptions?: ParseOptions) => either_.Either<I, ParseResult.ParseError>

Added in v3.10.0

encodeOption

Signature

export declare const encodeOption: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (input: A, overrideOptions?: ParseOptions) => option_.Option<I>

Added in v3.10.0

encodePromise

Signature

export declare const encodePromise: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (a: A, overrideOptions?: ParseOptions) => Promise<I>

Added in v3.10.0

encodeSync

Signature

export declare const encodeSync: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (a: A, overrideOptions?: ParseOptions) => I

Added in v3.10.0

encodeUnknown

Signature

export declare const encodeUnknown: <A, I, R>(
  schema: Schema<A, I, R>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => Effect.Effect<I, ParseResult.ParseError, R>

Added in v3.10.0

encodeUnknownEither

Signature

export declare const encodeUnknownEither: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => either_.Either<I, ParseResult.ParseError>

Added in v3.10.0

encodeUnknownOption

Signature

export declare const encodeUnknownOption: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => option_.Option<I>

Added in v3.10.0

encodeUnknownPromise

Signature

export declare const encodeUnknownPromise: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => Promise<I>

Added in v3.10.0

encodeUnknownSync

Signature

export declare const encodeUnknownSync: <A, I>(
  schema: Schema<A, I, never>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => I

Added in v3.10.0

serialize

Signature

export declare const serialize: <A, I, R>(self: Serializable<A, I, R>) => Effect.Effect<I, ParseResult.ParseError, R>

Added in v3.10.0

serializeExit

Signature

export declare const serializeExit: {
  <SA, FA>(
    value: exit_.Exit<SA, FA>
  ): <SI, FI, R>(
    self: WithResult<SA, SI, FA, FI, R>
  ) => Effect.Effect<ExitEncoded<SI, FI, unknown>, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(
    self: WithResult<SA, SI, FA, FI, R>,
    value: exit_.Exit<SA, FA>
  ): Effect.Effect<ExitEncoded<SI, FI, unknown>, ParseResult.ParseError, R>
}

Added in v3.10.0

serializeFailure

Signature

export declare const serializeFailure: {
  <FA>(value: FA): <SA, SI, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<FI, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: FA): Effect.Effect<FI, ParseResult.ParseError, R>
}

Added in v3.10.0

serializeSuccess

Signature

export declare const serializeSuccess: {
  <SA>(value: SA): <SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>) => Effect.Effect<SI, ParseResult.ParseError, R>
  <SA, SI, FA, FI, R>(self: WithResult<SA, SI, FA, FI, R>, value: SA): Effect.Effect<SI, ParseResult.ParseError, R>
}

Added in v3.10.0

filtering

FilterIssue (interface)

Signature

export interface FilterIssue {
  readonly path: ReadonlyArray<PropertyKey>
  readonly message: string
}

Added in v3.10.0

FilterOutput (type alias)

Signature

export type FilterOutput = undefined | boolean | string | ParseResult.ParseIssue | FilterIssue

Added in v3.10.0

filter

Signature

export declare function filter<C extends A, B extends A, A = C>(
  refinement: (a: A, options: ParseOptions, self: AST.Refinement) => a is B,
  annotations?: Annotations.Filter<C & B, C>
): <I, R>(self: Schema<C, I, R>) => refine<C & B, Schema<A, I, R>>
export declare function filter<A, B extends A>(
  refinement: (a: A, options: ParseOptions, self: AST.Refinement) => a is B,
  annotations?: Annotations.Filter<B, A>
): <I, R>(self: Schema<A, I, R>) => refine<B, Schema<A, I, R>>
export declare function filter<S extends Schema.Any>(
  predicate: (a: Types.NoInfer<Schema.Type<S>>, options: ParseOptions, self: AST.Refinement) => FilterReturnType,
  annotations?: Annotations.Filter<Types.NoInfer<Schema.Type<S>>>
): (self: S) => filter<S>

Added in v3.10.0

formatting

format

Signature

export declare const format: <S extends Schema.All>(schema: S) => string

Added in v3.10.0

guards

isPropertySignature

Signature

export declare const isPropertySignature: (u: unknown) => u is PropertySignature.All

Added in v3.10.0

isSchema

Tests if a value is a Schema.

Signature

export declare const isSchema: (u: unknown) => u is Schema.Any

Added in v3.10.0

model

Schema (interface)

Signature

export interface Schema<in out A, in out I = A, out R = never> extends Schema.Variance<A, I, R>, Pipeable {
  readonly Type: A
  readonly Encoded: I
  readonly Context: R
  readonly ast: AST.AST
  /**
   * Merges a set of new annotations with existing ones, potentially overwriting
   * any duplicates.
   */
  annotations(annotations: Annotations.GenericSchema<A>): Schema<A, I, R>
}

Added in v3.10.0

SchemaClass (interface)

Signature

export interface SchemaClass<A, I = A, R = never> extends AnnotableClass<SchemaClass<A, I, R>, A, I, R> {}

Added in v3.10.0

Serializable (interface)

The Serializable trait allows objects to define their own schema for serialization.

Signature

export interface Serializable<A, I, R> {
  readonly [symbolSerializable]: Schema<A, I, R>
}

Added in v3.10.0

Serializable (namespace)

Added in v3.10.0

All (type alias)

Signature

export type All =
  | Any
  | Serializable<any, never, unknown>
  | Serializable<never, any, unknown>
  | Serializable<never, never, unknown>

Added in v3.10.0

Any (type alias)

Signature

export type Any = Serializable<any, any, unknown>

Added in v3.10.0

Context (type alias)

Signature

export type Context<T> = T extends Serializable<infer _A, infer _I, infer R> ? R : never

Added in v3.10.0

Encoded (type alias)

Signature

export type Encoded<T> = T extends Serializable<infer _A, infer I, infer _R> ? I : never

Added in v3.10.0

Type (type alias)

Signature

export type Type<T> = T extends Serializable<infer A, infer _I, infer _R> ? A : never

Added in v3.10.0

SerializableWithResult (interface)

The SerializableWithResult trait is specifically designed to model remote procedures that require serialization of their input and output, managing both successful and failed outcomes.

This trait combines functionality from both the Serializable and WithResult traits to handle data serialization and the bifurcation of operation results into success or failure categories.

Signature

export interface SerializableWithResult<A, I, R, Success, SuccessEncoded, Failure, FailureEncoded, ResultR>
  extends Serializable<A, I, R>,
    WithResult<Success, SuccessEncoded, Failure, FailureEncoded, ResultR> {}

Added in v3.10.0

SerializableWithResult (namespace)

Added in v3.10.0

All (type alias)

Signature

export type All = Any | SerializableWithResult<any, any, any, any, any, never, never, unknown>

Added in v3.10.0

Any (type alias)

Signature

export type Any = SerializableWithResult<any, any, any, any, any, any, any, unknown>

Added in v3.10.0

Context (type alias)

Signature

export type Context<P> =
  P extends SerializableWithResult<infer _S, infer _SI, infer SR, infer _A, infer _AI, infer _E, infer _EI, infer RR>
    ? SR | RR
    : never

Added in v3.10.0

WithResult (interface)

The WithResult trait is designed to encapsulate the outcome of an operation, distinguishing between success and failure cases. Each case is associated with a schema that defines the structure and types of the success or failure data.

Signature

export interface WithResult<Success, SuccessEncoded, Failure, FailureEncoded, ResultR> {
  readonly [symbolWithResult]: {
    readonly success: Schema<Success, SuccessEncoded, ResultR>
    readonly failure: Schema<Failure, FailureEncoded, ResultR>
  }
}

Added in v3.10.0

WithResult (namespace)

Added in v3.10.0

All (type alias)

Signature

export type All = Any | WithResult<any, any, never, never, unknown>

Added in v3.10.0

Any (type alias)

Signature

export type Any = WithResult<any, any, any, any, unknown>

Added in v3.10.0

Context (type alias)

Signature

export type Context<T> = T extends WithResult<infer _SA, infer _SI, infer _FA, infer _FI, infer R> ? R : never

Added in v3.10.0

Failure (type alias)

Signature

export type Failure<T> = T extends WithResult<infer _A, infer _I, infer _E, infer _EI, infer _R> ? _E : never

Added in v3.10.0

FailureEncoded (type alias)

Signature

export type FailureEncoded<T> = T extends WithResult<infer _A, infer _I, infer _E, infer _EI, infer _R> ? _EI : never

Added in v3.10.0

Success (type alias)

Signature

export type Success<T> = T extends WithResult<infer _A, infer _I, infer _E, infer _EI, infer _R> ? _A : never

Added in v3.10.0

SuccessEncoded (type alias)

Signature

export type SuccessEncoded<T> = T extends WithResult<infer _A, infer _I, infer _E, infer _EI, infer _R> ? _I : never

Added in v3.10.0

number constructors

Finite (class)

Signature

export declare class Finite

Added in v3.10.0

Int (class)

Signature

export declare class Int

Added in v3.10.0

JsonNumber (class)

The JsonNumber is a schema for representing JSON numbers. It ensures that the provided value is a valid number by filtering out NaN and (+/-) Infinity. This is useful when you want to validate and represent numbers in JSON format.

Signature

export declare class JsonNumber

Example

import * as Schema from "effect/Schema"

const is = Schema.is(S.JsonNumber)

assert.deepStrictEqual(is(42), true)
assert.deepStrictEqual(is(Number.NaN), false)
assert.deepStrictEqual(is(Number.POSITIVE_INFINITY), false)
assert.deepStrictEqual(is(Number.NEGATIVE_INFINITY), false)

Added in v3.10.0

Negative (class)

Signature

export declare class Negative

Added in v3.10.0

NonNaN (class)

Signature

export declare class NonNaN

Added in v3.10.0

NonNegative (class)

Signature

export declare class NonNegative

Added in v3.10.0

NonPositive (class)

Signature

export declare class NonPositive

Added in v3.10.0

Positive (class)

Signature

export declare class Positive

Added in v3.10.0

number filters

between

This filter checks whether the provided number falls within the specified minimum and maximum values.

Signature

export declare const between: <A extends number>(
  min: number,
  max: number,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

finite

Ensures that the provided value is a finite number.

This schema filters out non-finite numeric values, allowing only finite numbers to pass through.

Signature

export declare const finite: <A extends number>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThan

This filter checks whether the provided number is greater than the specified minimum.

Signature

export declare const greaterThan: <A extends number>(
  min: number,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

greaterThanOrEqualTo

This filter checks whether the provided number is greater than or equal to the specified minimum.

Signature

export declare const greaterThanOrEqualTo: <A extends number>(
  min: number,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

int

Signature

export declare const int: <A extends number>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThan

This filter checks whether the provided number is less than the specified maximum.

Signature

export declare const lessThan: <A extends number>(
  max: number,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lessThanOrEqualTo

This schema checks whether the provided number is less than or equal to the specified maximum.

Signature

export declare const lessThanOrEqualTo: <A extends number>(
  max: number,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

multipleOf

Signature

export declare const multipleOf: <A extends number>(
  divisor: number,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

negative

Signature

export declare const negative: <A extends number>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

nonNaN

Signature

export declare const nonNaN: <A extends number>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

nonNegative

Signature

export declare const nonNegative: <A extends number>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

nonPositive

Signature

export declare const nonPositive: <A extends number>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

positive

Signature

export declare const positive: <A extends number>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

number transformations

NumberFromString (class)

This schema transforms a string into a number by parsing the string using the parse function of the effect/Number module.

It returns an error if the value can’t be converted (for example when non-numeric characters are provided).

The following special string values are supported: “NaN”, “Infinity”, “-Infinity”.

Signature

export declare class NumberFromString

Added in v3.10.0

clamp

Clamps a number between a minimum and a maximum value.

Signature

export declare const clamp: (
  minimum: number,
  maximum: number
) => <A extends number, I, R>(self: Schema<A, I, R>) => transform<Schema<A, I, R>, filter<Schema<A>>>

Added in v3.10.0

parseNumber

Transforms a string into a number by parsing the string using the parse function of the effect/Number module.

It returns an error if the value can’t be converted (for example when non-numeric characters are provided).

The following special string values are supported: “NaN”, “Infinity”, “-Infinity”.

Signature

export declare const parseNumber: <A extends string, I, R>(
  self: Schema<A, I, R>
) => transformOrFail<Schema<A, I, R>, typeof Number$>

Added in v3.10.0

primitives

Any (class)

Signature

export declare class Any

Added in v3.10.0

BigIntFromSelf (class)

Signature

export declare class BigIntFromSelf

Added in v3.10.0

Boolean

Signature

export declare const Boolean: typeof Boolean$

Added in v3.10.0

Never (class)

Signature

export declare class Never

Added in v3.10.0

Null (class)

Signature

export declare class Null

Added in v3.10.0

Number

Signature

export declare const Number: typeof Number$

Added in v3.10.0

Object

Signature

export declare const Object: typeof Object$

Added in v3.10.0

String

Signature

export declare const String: typeof String$

Added in v3.10.0

SymbolFromSelf (class)

Signature

export declare class SymbolFromSelf

Added in v3.10.0

Undefined (class)

Signature

export declare class Undefined

Added in v3.10.0

Unknown (class)

Signature

export declare class Unknown

Added in v3.10.0

Void (class)

Signature

export declare class Void

Added in v3.10.0

renaming

rename

Signature

export declare const rename: {
  <A, const M extends { readonly [K in keyof A]?: PropertyKey } & { readonly [K in Exclude<keyof M, keyof A>]: never }>(
    mapping: M
  ): <I, R>(self: Schema<A, I, R>) => SchemaClass<Simplify<Rename<A, M>>, I, R>
  <
    A,
    I,
    R,
    const M extends { readonly [K in keyof A]?: PropertyKey } & { readonly [K in Exclude<keyof M, keyof A>]: never }
  >(
    self: Schema<A, I, R>,
    mapping: M
  ): SchemaClass<Simplify<Rename<A, M>>, I, R>
}

Added in v3.10.0

schema id

BetweenBigDecimalSchemaId

Signature

export declare const BetweenBigDecimalSchemaId: typeof BetweenBigDecimalSchemaId

Added in v3.10.0

BetweenBigIntSchemaId

Signature

export declare const BetweenBigIntSchemaId: typeof BetweenBigIntSchemaId

Added in v3.10.0

BetweenBigIntSchemaId (type alias)

Signature

export type BetweenBigIntSchemaId = typeof BetweenBigIntSchemaId

Added in v3.10.0

BetweenDateSchemaId

Signature

export declare const BetweenDateSchemaId: typeof BetweenDateSchemaId

Added in v3.10.0

BetweenDurationSchemaId

Signature

export declare const BetweenDurationSchemaId: typeof BetweenDurationSchemaId

Added in v3.10.0

BetweenSchemaId

Signature

export declare const BetweenSchemaId: typeof BetweenSchemaId

Added in v3.10.0

BetweenSchemaId (type alias)

Signature

export type BetweenSchemaId = typeof BetweenSchemaId

Added in v3.10.0

BrandSchemaId

Signature

export declare const BrandSchemaId: typeof BrandSchemaId

Added in v3.10.0

CapitalizedSchemaId

Signature

export declare const CapitalizedSchemaId: typeof CapitalizedSchemaId

Added in v3.10.0

EndsWithSchemaId

Signature

export declare const EndsWithSchemaId: typeof EndsWithSchemaId

Added in v3.10.0

FiniteSchemaId

Signature

export declare const FiniteSchemaId: typeof FiniteSchemaId

Added in v3.10.0

FiniteSchemaId (type alias)

Signature

export type FiniteSchemaId = typeof FiniteSchemaId

Added in v3.10.0

GreaterThanBigDecimalSchemaId

Signature

export declare const GreaterThanBigDecimalSchemaId: typeof GreaterThanBigDecimalSchemaId

Added in v3.10.0

GreaterThanBigIntSchemaId

Signature

export declare const GreaterThanBigIntSchemaId: typeof GreaterThanBigIntSchemaId

Added in v3.10.0

GreaterThanBigIntSchemaId (type alias)

Signature

export type GreaterThanBigIntSchemaId = typeof GreaterThanBigIntSchemaId

Added in v3.10.0

GreaterThanDateSchemaId

Signature

export declare const GreaterThanDateSchemaId: typeof GreaterThanDateSchemaId

Added in v3.10.0

GreaterThanDurationSchemaId

Signature

export declare const GreaterThanDurationSchemaId: typeof GreaterThanDurationSchemaId

Added in v3.10.0

GreaterThanOrEqualToBigDecimalSchemaId

Signature

export declare const GreaterThanOrEqualToBigDecimalSchemaId: typeof GreaterThanOrEqualToBigDecimalSchemaId

Added in v3.10.0

GreaterThanOrEqualToBigIntSchemaId

Signature

export declare const GreaterThanOrEqualToBigIntSchemaId: typeof GreaterThanOrEqualToBigIntSchemaId

Added in v3.10.0

GreaterThanOrEqualToBigIntSchemaId (type alias)

Signature

export type GreaterThanOrEqualToBigIntSchemaId = typeof GreaterThanOrEqualToBigIntSchemaId

Added in v3.10.0

GreaterThanOrEqualToDateSchemaId

Signature

export declare const GreaterThanOrEqualToDateSchemaId: typeof GreaterThanOrEqualToDateSchemaId

Added in v3.10.0

GreaterThanOrEqualToDurationSchemaId

Signature

export declare const GreaterThanOrEqualToDurationSchemaId: typeof GreaterThanOrEqualToDurationSchemaId

Added in v3.10.0

GreaterThanOrEqualToSchemaId

Signature

export declare const GreaterThanOrEqualToSchemaId: typeof GreaterThanOrEqualToSchemaId

Added in v3.10.0

GreaterThanOrEqualToSchemaId (type alias)

Signature

export type GreaterThanOrEqualToSchemaId = typeof GreaterThanOrEqualToSchemaId

Added in v3.10.0

GreaterThanSchemaId

Signature

export declare const GreaterThanSchemaId: typeof GreaterThanSchemaId

Added in v3.10.0

GreaterThanSchemaId (type alias)

Signature

export type GreaterThanSchemaId = typeof GreaterThanSchemaId

Added in v3.10.0

IncludesSchemaId

Signature

export declare const IncludesSchemaId: typeof IncludesSchemaId

Added in v3.10.0

InstanceOfSchemaId

Signature

export declare const InstanceOfSchemaId: typeof InstanceOfSchemaId

Added in v3.10.0

IntSchemaId

Signature

export declare const IntSchemaId: typeof IntSchemaId

Added in v3.10.0

IntSchemaId (type alias)

Signature

export type IntSchemaId = typeof IntSchemaId

Added in v3.10.0

ItemsCountSchemaId

Signature

export declare const ItemsCountSchemaId: typeof ItemsCountSchemaId

Added in v3.10.0

ItemsCountSchemaId (type alias)

Signature

export type ItemsCountSchemaId = typeof ItemsCountSchemaId

Added in v3.10.0

JsonNumberSchemaId

Signature

export declare const JsonNumberSchemaId: typeof JsonNumberSchemaId

Added in v3.10.0

JsonNumberSchemaId (type alias)

Signature

export type JsonNumberSchemaId = typeof JsonNumberSchemaId

Added in v3.10.0

LengthSchemaId

Signature

export declare const LengthSchemaId: typeof LengthSchemaId

Added in v3.10.0

LengthSchemaId (type alias)

Signature

export type LengthSchemaId = typeof LengthSchemaId

Added in v3.10.0

LessThanBigDecimalSchemaId

Signature

export declare const LessThanBigDecimalSchemaId: typeof LessThanBigDecimalSchemaId

Added in v3.10.0

LessThanBigIntSchemaId

Signature

export declare const LessThanBigIntSchemaId: typeof LessThanBigIntSchemaId

Added in v3.10.0

LessThanBigIntSchemaId (type alias)

Signature

export type LessThanBigIntSchemaId = typeof LessThanBigIntSchemaId

Added in v3.10.0

LessThanDateSchemaId

Signature

export declare const LessThanDateSchemaId: typeof LessThanDateSchemaId

Added in v3.10.0

LessThanDurationSchemaId

Signature

export declare const LessThanDurationSchemaId: typeof LessThanDurationSchemaId

Added in v3.10.0

LessThanOrEqualToBigDecimalSchemaId

Signature

export declare const LessThanOrEqualToBigDecimalSchemaId: typeof LessThanOrEqualToBigDecimalSchemaId

Added in v3.10.0

LessThanOrEqualToBigIntSchemaId

Signature

export declare const LessThanOrEqualToBigIntSchemaId: typeof LessThanOrEqualToBigIntSchemaId

Added in v3.10.0

LessThanOrEqualToBigIntSchemaId (type alias)

Signature

export type LessThanOrEqualToBigIntSchemaId = typeof LessThanOrEqualToBigIntSchemaId

Added in v3.10.0

LessThanOrEqualToDateSchemaId

Signature

export declare const LessThanOrEqualToDateSchemaId: typeof LessThanOrEqualToDateSchemaId

Added in v3.10.0

LessThanOrEqualToDurationSchemaId

Signature

export declare const LessThanOrEqualToDurationSchemaId: typeof LessThanOrEqualToDurationSchemaId

Added in v3.10.0

LessThanOrEqualToSchemaId

Signature

export declare const LessThanOrEqualToSchemaId: typeof LessThanOrEqualToSchemaId

Added in v3.10.0

LessThanOrEqualToSchemaId (type alias)

Signature

export type LessThanOrEqualToSchemaId = typeof LessThanOrEqualToSchemaId

Added in v3.10.0

LessThanSchemaId

Signature

export declare const LessThanSchemaId: typeof LessThanSchemaId

Added in v3.10.0

LessThanSchemaId (type alias)

Signature

export type LessThanSchemaId = typeof LessThanSchemaId

Added in v3.10.0

LowercasedSchemaId

Signature

export declare const LowercasedSchemaId: typeof LowercasedSchemaId

Added in v3.10.0

MaxItemsSchemaId

Signature

export declare const MaxItemsSchemaId: typeof MaxItemsSchemaId

Added in v3.10.0

MaxItemsSchemaId (type alias)

Signature

export type MaxItemsSchemaId = typeof MaxItemsSchemaId

Added in v3.10.0

MaxLengthSchemaId

Signature

export declare const MaxLengthSchemaId: typeof MaxLengthSchemaId

Added in v3.10.0

MaxLengthSchemaId (type alias)

Signature

export type MaxLengthSchemaId = typeof MaxLengthSchemaId

Added in v3.10.0

MinItemsSchemaId

Signature

export declare const MinItemsSchemaId: typeof MinItemsSchemaId

Added in v3.10.0

MinItemsSchemaId (type alias)

Signature

export type MinItemsSchemaId = typeof MinItemsSchemaId

Added in v3.10.0

MinLengthSchemaId

Signature

export declare const MinLengthSchemaId: typeof MinLengthSchemaId

Added in v3.10.0

MinLengthSchemaId (type alias)

Signature

export type MinLengthSchemaId = typeof MinLengthSchemaId

Added in v3.10.0

MultipleOfSchemaId

Signature

export declare const MultipleOfSchemaId: typeof MultipleOfSchemaId

Added in v3.10.0

NegativeBigDecimalSchemaId

Signature

export declare const NegativeBigDecimalSchemaId: typeof NegativeBigDecimalSchemaId

Added in v3.10.0

NonNaNSchemaId

Signature

export declare const NonNaNSchemaId: typeof NonNaNSchemaId

Added in v3.10.0

NonNaNSchemaId (type alias)

Signature

export type NonNaNSchemaId = typeof NonNaNSchemaId

Added in v3.10.0

NonNegativeBigDecimalSchemaId

Signature

export declare const NonNegativeBigDecimalSchemaId: typeof NonNegativeBigDecimalSchemaId

Added in v3.10.0

NonPositiveBigDecimalSchemaId

Signature

export declare const NonPositiveBigDecimalSchemaId: typeof NonPositiveBigDecimalSchemaId

Added in v3.10.0

PatternSchemaId

Signature

export declare const PatternSchemaId: typeof PatternSchemaId

Added in v3.10.0

PositiveBigDecimalSchemaId

Signature

export declare const PositiveBigDecimalSchemaId: typeof PositiveBigDecimalSchemaId

Added in v3.10.0

StartsWithSchemaId

Signature

export declare const StartsWithSchemaId: typeof StartsWithSchemaId

Added in v3.10.0

TrimmedSchemaId

Signature

export declare const TrimmedSchemaId: typeof TrimmedSchemaId

Added in v3.10.0

ULIDSchemaId

Signature

export declare const ULIDSchemaId: typeof ULIDSchemaId

Added in v3.10.0

UUIDSchemaId

Signature

export declare const UUIDSchemaId: typeof UUIDSchemaId

Added in v3.10.0

UncapitalizedSchemaId

Signature

export declare const UncapitalizedSchemaId: typeof UncapitalizedSchemaId

Added in v3.10.0

UppercasedSchemaId

Signature

export declare const UppercasedSchemaId: typeof UppercasedSchemaId

Added in v3.10.0

ValidDateSchemaId

Signature

export declare const ValidDateSchemaId: typeof ValidDateSchemaId

Added in v3.10.0

string constructors

Capitalized (class)

Signature

export declare class Capitalized

Added in v3.10.0

Char (class)

A schema representing a single character.

Signature

export declare class Char

Added in v3.10.0

Lowercased (class)

Signature

export declare class Lowercased

Added in v3.10.0

NonEmptyString (class)

Signature

export declare class NonEmptyString

Added in v3.10.0

NonEmptyTrimmedString (class)

Useful for validating strings that must contain meaningful characters without leading or trailing whitespace.

Signature

export declare class NonEmptyTrimmedString

Example

import { Schema } from "effect"

console.log(Schema.decodeOption(Schema.NonEmptyTrimmedString)("")) // Option.none()
console.log(Schema.decodeOption(Schema.NonEmptyTrimmedString)(" a ")) // Option.none()
console.log(Schema.decodeOption(Schema.NonEmptyTrimmedString)("a")) // Option.some("a")

Added in v3.10.0

Trimmed (class)

Signature

export declare class Trimmed

Added in v3.10.0

ULID (class)

Represents a Universally Unique Lexicographically Sortable Identifier (ULID).

ULIDs are designed to be compact, URL-safe, and ordered, making them suitable for use as identifiers. This schema ensures that the provided string adheres to the standard ULID format.

Signature

export declare class ULID

Added in v3.10.0

UUID (class)

Represents a Universally Unique Identifier (UUID).

This schema ensures that the provided string adheres to the standard UUID format.

Signature

export declare class UUID

Added in v3.10.0

Uncapitalized (class)

Signature

export declare class Uncapitalized

Added in v3.10.0

Uppercased (class)

Signature

export declare class Uppercased

Added in v3.10.0

string filters

capitalized

Verifies that a string is capitalized.

Signature

export declare const capitalized: <A extends string>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

endsWith

Signature

export declare const endsWith: <A extends string>(
  endsWith: string,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

includes

Signature

export declare const includes: <A extends string>(
  searchString: string,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

length

Signature

export declare const length: <A extends string>(
  length: number | { readonly min: number; readonly max: number },
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

lowercased

Verifies that a string is lowercased.

Signature

export declare const lowercased: <A extends string>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

maxLength

Signature

export declare const maxLength: <A extends string>(
  maxLength: number,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

minLength

Signature

export declare const minLength: <A extends string>(
  minLength: number,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

nonEmptyString

Signature

export declare const nonEmptyString: <A extends string>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

pattern

Signature

export declare const pattern: <A extends string>(
  regex: RegExp,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

startsWith

Signature

export declare const startsWith: <A extends string>(
  startsWith: string,
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

trimmed

Verifies that a string contains no leading or trailing whitespaces.

Note. This combinator does not make any transformations, it only validates. If what you were looking for was a combinator to trim strings, then check out the trim combinator.

Signature

export declare const trimmed: <A extends string>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

uncapitalized

Verifies that a string is uncapitalized.

Signature

export declare const uncapitalized: <A extends string>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

uppercased

Verifies that a string is uppercased.

Signature

export declare const uppercased: <A extends string>(
  annotations?: Annotations.Filter<A>
) => <I, R>(self: Schema<A, I, R>) => filter<Schema<A, I, R>>

Added in v3.10.0

string transformations

Capitalize (class)

This schema converts a string to capitalized one.

Signature

export declare class Capitalize

Added in v3.10.0

Lowercase (class)

This schema converts a string to lowercase.

Signature

export declare class Lowercase

Added in v3.10.0

StringFromBase64

Decodes a base64 (RFC4648) encoded string into a UTF-8 string.

Signature

export declare const StringFromBase64: Schema<string, string, never>

Added in v3.10.0

StringFromBase64Url

Decodes a base64 (URL) encoded string into a UTF-8 string.

Signature

export declare const StringFromBase64Url: Schema<string, string, never>

Added in v3.10.0

StringFromHex

Decodes a hex encoded string into a UTF-8 string.

Signature

export declare const StringFromHex: Schema<string, string, never>

Added in v3.10.0

Trim (class)

This schema allows removing whitespaces from the beginning and end of a string.

Signature

export declare class Trim

Added in v3.10.0

Uncapitalize (class)

This schema converts a string to uncapitalized one.

Signature

export declare class Uncapitalize

Added in v3.10.0

Uppercase (class)

This schema converts a string to uppercase.

Signature

export declare class Uppercase

Added in v3.10.0

parseJson

The ParseJson combinator provides a method to convert JSON strings into the unknown type using the underlying functionality of JSON.parse. It also utilizes JSON.stringify for encoding.

You can optionally provide a ParseJsonOptions to configure both JSON.parse and JSON.stringify executions.

Optionally, you can pass a schema Schema<A, I, R> to obtain an A type instead of unknown.

Signature

export declare const parseJson: {
  <A, I, R>(schema: Schema<A, I, R>, options?: ParseJsonOptions): SchemaClass<A, string, R>
  (options?: ParseJsonOptions): SchemaClass<unknown, string>
}

Example

import * as Schema from "effect/Schema"

assert.deepStrictEqual(Schema.decodeUnknownSync(Schema.parseJson())(`{"a":"1"}`), { a: "1" })
assert.deepStrictEqual(
  Schema.decodeUnknownSync(Schema.parseJson(Schema.Struct({ a: Schema.NumberFromString })))(`{"a":"1"}`),
  { a: 1 }
)

Added in v3.10.0

split

Returns a schema that allows splitting a string into an array of strings.

Signature

export declare const split: (separator: string) => transform<typeof String$, Array$<typeof String$>>

Added in v3.10.0

struct transformations

omit

Signature

export declare const omit: <A, I, Keys extends ReadonlyArray<keyof A & keyof I>>(
  ...keys: Keys
) => <R>(self: Schema<A, I, R>) => SchemaClass<Simplify<Omit<A, Keys[number]>>, Simplify<Omit<I, Keys[number]>>, R>

Added in v3.10.0

pick

Signature

export declare const pick: <A, I, Keys extends ReadonlyArray<keyof A & keyof I>>(
  ...keys: Keys
) => <R>(self: Schema<A, I, R>) => SchemaClass<Simplify<Pick<A, Keys[number]>>, Simplify<Pick<I, Keys[number]>>, R>

Added in v3.10.0

pluck

Given a schema Schema<A, I, R> and a key key: K, this function extracts a specific field from the A type, producing a new schema that represents a transformation from the { readonly [key]: I[K] } type to A[K].

Signature

export declare const pluck: {
  <A, I, K extends keyof A & keyof I>(
    key: K
  ): <R>(schema: Schema<A, I, R>) => Schema<A[K], { readonly [P in K]: I[P] }, R>
  <A, I, R, K extends keyof A & keyof I>(schema: Schema<A, I, R>, key: K): Schema<A[K], { readonly [P in K]: I[P] }, R>
}

Example

import * as Schema from "effect/Schema"

// ---------------------------------------------
// use case: pull out a single field from a
// struct through a transformation
// ---------------------------------------------

const mytable = Schema.Struct({
  column1: Schema.NumberFromString,
  column2: Schema.Number
})

// const pullOutColumn: S.Schema<number, {
//     readonly column1: string;
// }, never>
const pullOutColumn = mytable.pipe(Schema.pluck("column1"))

console.log(
  Schema.decodeUnknownEither(Schema.Array(pullOutColumn))([
    { column1: "1", column2: 100 },
    { column1: "2", column2: 300 }
  ])
)
// Output: { _id: 'Either', _tag: 'Right', right: [ 1, 2 ] }

Added in v3.10.0

symbol

PropertySignatureTypeId

Signature

export declare const PropertySignatureTypeId: typeof PropertySignatureTypeId

Added in v3.10.0

PropertySignatureTypeId (type alias)

Signature

export type PropertySignatureTypeId = typeof PropertySignatureTypeId

Added in v3.10.0

RefineSchemaId

Signature

export declare const RefineSchemaId: typeof RefineSchemaId

Added in v3.10.0

RefineSchemaId (type alias)

Signature

export type RefineSchemaId = typeof RefineSchemaId

Added in v3.10.0

TypeId

Signature

export declare const TypeId: typeof TypeId

Added in v3.10.0

TypeId (type alias)

Signature

export type TypeId = typeof TypeId

Added in v3.10.0

symbolSerializable

Signature

export declare const symbolSerializable: typeof symbolSerializable

Added in v3.10.0

symbolWithResult

Signature

export declare const symbolWithResult: typeof symbolWithResult

Added in v3.10.0

symbol transformations

Symbol

This schema transforms a string into a symbol.

Signature

export declare const Symbol: typeof Symbol$

Added in v3.10.0

template literal

TemplateLiteral

Signature

export declare const TemplateLiteral: <Params extends array_.NonEmptyReadonlyArray<TemplateLiteralParameter>>(
  ...[head, ...tail]: Params
) => TemplateLiteral<GetTemplateLiteralType<Params>>

Added in v3.10.0

TemplateLiteralParser

Signature

export declare const TemplateLiteralParser: <
  Params extends array_.NonEmptyReadonlyArray<TemplateLiteralParserParameters>
>(
  ...params: Params
) => TemplateLiteralParser<Params>

Added in v3.10.0

transformations

filterEffect

Signature

export declare const filterEffect: {
  <S extends Schema.Any, FD>(
    f: (
      a: Types.NoInfer<Schema.Type<S>>,
      options: ParseOptions,
      self: AST.Transformation
    ) => Effect.Effect<FilterReturnType, never, FD>
  ): (self: S) => filterEffect<S, FD>
  <S extends Schema.Any, RD>(
    self: S,
    f: (
      a: Types.NoInfer<Schema.Type<S>>,
      options: ParseOptions,
      self: AST.Transformation
    ) => Effect.Effect<FilterReturnType, never, RD>
  ): filterEffect<S, RD>
}

Added in v3.10.0

transform

Create a new Schema by transforming the input and output of an existing Schema using the provided mapping functions.

Signature

export declare const transform: {
  <To extends Schema.Any, From extends Schema.Any>(
    to: To,
    options:
      | {
          readonly decode: (fromA: Schema.Type<From>, fromI: Schema.Encoded<From>) => Schema.Encoded<To>
          readonly encode: (toI: Schema.Encoded<To>, toA: Schema.Type<To>) => Schema.Type<From>
          readonly strict?: true
        }
      | {
          readonly decode: (fromA: Schema.Type<From>, fromI: Schema.Encoded<From>) => unknown
          readonly encode: (toI: Schema.Encoded<To>, toA: Schema.Type<To>) => unknown
          readonly strict: false
        }
  ): (from: From) => transform<From, To>
  <To extends Schema.Any, From extends Schema.Any>(
    from: From,
    to: To,
    options:
      | {
          readonly decode: (fromA: Schema.Type<From>, fromI: Schema.Encoded<From>) => Schema.Encoded<To>
          readonly encode: (toI: Schema.Encoded<To>, toA: Schema.Type<To>) => Schema.Type<From>
          readonly strict?: true
        }
      | {
          readonly decode: (fromA: Schema.Type<From>, fromI: Schema.Encoded<From>) => unknown
          readonly encode: (toI: Schema.Encoded<To>, toA: Schema.Type<To>) => unknown
          readonly strict: false
        }
  ): transform<From, To>
}

Added in v3.10.0

transformOrFail

Create a new Schema by transforming the input and output of an existing Schema using the provided decoding functions.

Signature

export declare const transformOrFail: {
  <To extends Schema.Any, From extends Schema.Any, RD, RE>(
    to: To,
    options:
      | {
          readonly decode: (
            fromA: Schema.Type<From>,
            options: ParseOptions,
            ast: AST.Transformation,
            fromI: Schema.Encoded<From>
          ) => Effect.Effect<Schema.Encoded<To>, ParseResult.ParseIssue, RD>
          readonly encode: (
            toI: Schema.Encoded<To>,
            options: ParseOptions,
            ast: AST.Transformation,
            toA: Schema.Type<To>
          ) => Effect.Effect<Schema.Type<From>, ParseResult.ParseIssue, RE>
          readonly strict?: true
        }
      | {
          readonly decode: (
            fromA: Schema.Type<From>,
            options: ParseOptions,
            ast: AST.Transformation,
            fromI: Schema.Encoded<From>
          ) => Effect.Effect<unknown, ParseResult.ParseIssue, RD>
          readonly encode: (
            toI: Schema.Encoded<To>,
            options: ParseOptions,
            ast: AST.Transformation,
            toA: Schema.Type<To>
          ) => Effect.Effect<unknown, ParseResult.ParseIssue, RE>
          readonly strict: false
        }
  ): (from: From) => transformOrFail<From, To, RD | RE>
  <To extends Schema.Any, From extends Schema.Any, RD, RE>(
    from: From,
    to: To,
    options:
      | {
          readonly decode: (
            fromA: Schema.Type<From>,
            options: ParseOptions,
            ast: AST.Transformation,
            fromI: Schema.Encoded<From>
          ) => Effect.Effect<Schema.Encoded<To>, ParseResult.ParseIssue, RD>
          readonly encode: (
            toI: Schema.Encoded<To>,
            options: ParseOptions,
            ast: AST.Transformation,
            toA: Schema.Type<To>
          ) => Effect.Effect<Schema.Type<From>, ParseResult.ParseIssue, RE>
          readonly strict?: true
        }
      | {
          readonly decode: (
            fromA: Schema.Type<From>,
            options: ParseOptions,
            ast: AST.Transformation,
            fromI: Schema.Encoded<From>
          ) => Effect.Effect<unknown, ParseResult.ParseIssue, RD>
          readonly encode: (
            toI: Schema.Encoded<To>,
            options: ParseOptions,
            ast: AST.Transformation,
            toA: Schema.Type<To>
          ) => Effect.Effect<unknown, ParseResult.ParseIssue, RE>
          readonly strict: false
        }
  ): transformOrFail<From, To, RD | RE>
}

Added in v3.10.0

utils

Element (namespace)

Added in v3.10.0

Annotations (interface)

Signature

export interface Annotations<A> extends Annotations.Doc<A> {
  readonly missingMessage?: AST.MissingMessageAnnotation
}

Added in v3.10.0

Token (type alias)

Signature

export type Token = "" | "?"

Added in v3.10.0

EnumsDefinition (type alias)

Signature

export type EnumsDefinition = { [x: string]: string | number }

Added in v3.10.0

IndexSignature (namespace)

Added in v3.10.0

Context (type alias)

Signature

export type Context<Records extends IndexSignature.Records> = {
  [K in keyof Records]: Schema.Context<Records[K]["key"]> | Schema.Context<Records[K]["value"]>
}[number]

Added in v3.10.0

Encoded (type alias)

Signature

export type Encoded<Records extends IndexSignature.Records> = Types.UnionToIntersection<
  {
    [K in keyof Records]: {
      readonly [P in Schema.Encoded<Records[K]["key"]>]: Schema.Encoded<Records[K]["value"]>
    }
  }[number]
>

Added in v3.10.0

NonEmptyRecords (type alias)

Signature

export type NonEmptyRecords = array_.NonEmptyReadonlyArray<Record>

Added in v3.10.0

Record (type alias)

Signature

export type Record = { readonly key: Schema.All; readonly value: Schema.All }

Added in v3.10.0

Records (type alias)

Signature

export type Records = ReadonlyArray<Record>

Added in v3.10.0

Type (type alias)

Signature

export type Type<Records extends IndexSignature.Records> = Types.UnionToIntersection<
  {
    [K in keyof Records]: {
      readonly [P in Schema.Type<Records[K]["key"]>]: Schema.Type<Records[K]["value"]>
    }
  }[number]
>

Added in v3.10.0

OptionalOptions (type alias)

Signature

export type OptionalOptions<A> =
  | {
      readonly default?: never
      readonly as?: never
      readonly exact?: true
      readonly nullable?: true
    }
  | {
      readonly default: LazyArg<A>
      readonly as?: never
      readonly exact?: true
      readonly nullable?: true
    }
  | {
      readonly as: "Option"
      readonly default?: never
      readonly exact?: never
      readonly nullable?: never
      readonly onNoneEncoding?: LazyArg<option_.Option<undefined>>
    }
  | {
      readonly as: "Option"
      readonly default?: never
      readonly exact?: never
      readonly nullable: true
      readonly onNoneEncoding?: LazyArg<option_.Option<null | undefined>>
    }
  | {
      readonly as: "Option"
      readonly default?: never
      readonly exact: true
      readonly nullable?: never
      readonly onNoneEncoding?: never
    }
  | {
      readonly as: "Option"
      readonly default?: never
      readonly exact: true
      readonly nullable: true
      readonly onNoneEncoding?: LazyArg<option_.Option<null>>
    }
  | undefined

Added in v3.10.0

ParseJsonOptions (type alias)

Signature

export type ParseJsonOptions = {
  readonly reviver?: Parameters<typeof JSON.parse>[1]
  readonly replacer?: Parameters<typeof JSON.stringify>[1]
  readonly space?: Parameters<typeof JSON.stringify>[2]
}

Added in v3.10.0

PropertySignature (namespace)

Added in v3.10.0

Annotations (interface)

Signature

export interface Annotations<A> extends Annotations.Doc<A> {
  readonly missingMessage?: AST.MissingMessageAnnotation
}

Added in v3.10.0

AST (type alias)

Signature

export type AST = PropertySignatureDeclaration | PropertySignatureTransformation

Added in v3.10.0

All (type alias)

Signature

export type All<Key extends PropertyKey = PropertyKey> =
  | Any<Key>
  | PropertySignature<Token, never, Key, Token, any, boolean, unknown>
  | PropertySignature<Token, any, Key, Token, never, boolean, unknown>
  | PropertySignature<Token, never, Key, Token, never, boolean, unknown>

Added in v3.10.0

Any (type alias)

Signature

export type Any<Key extends PropertyKey = PropertyKey> = PropertySignature<
  Token,
  any,
  Key,
  Token,
  any,
  boolean,
  unknown
>

Added in v3.10.0

Token (type alias)

Signature

export type Token = "?:" | ":"

Added in v3.10.0

Schema (namespace)

Added in v3.10.0

Variance (interface)

Signature

export interface Variance<A, I, R> {
  readonly [TypeId]: {
    readonly _A: Types.Invariant<A>
    readonly _I: Types.Invariant<I>
    readonly _R: Types.Covariant<R>
  }
}

Added in v3.10.0

All (type alias)

Any schema, including never.

Signature

export type All = Any | Schema<any, never, unknown> | Schema<never, any, unknown> | Schema<never, never, unknown>

Added in v3.10.0

Any (type alias)

Any schema, except for never.

Signature

export type Any = Schema<any, any, unknown>

Added in v3.10.0

AnyNoContext (type alias)

Any schema with Context = never, except for never.

Signature

export type AnyNoContext = Schema<any, any, never>

Added in v3.10.0

AsSchema (type alias)

Type-level counterpart of Schema.asSchema function.

Signature

export type AsSchema<S extends All> = Schema<Type<S>, Encoded<S>, Context<S>>

Added in v3.10.0

Context (type alias)

Signature

export type Context<S> = S extends Schema.Variance<infer _A, infer _I, infer R> ? R : never

Added in v3.10.0

Encoded (type alias)

Signature

export type Encoded<S> = S extends Schema.Variance<infer _A, infer I, infer _R> ? I : never

Added in v3.10.0

ToAsserts (type alias)

Signature

export type ToAsserts<S extends AnyNoContext> = (
  input: unknown,
  options?: AST.ParseOptions
) => asserts input is Schema.Type<S>

Added in v3.10.0

Type (type alias)

Signature

export type Type<S> = S extends Schema.Variance<infer A, infer _I, infer _R> ? A : never

Added in v3.10.0

Simplify (type alias)

Signature

export type Simplify<A> = { [K in keyof A]: A[K] } & {}

Added in v3.10.0

SimplifyMutable (type alias)

Signature

export type SimplifyMutable<A> = {
  -readonly [K in keyof A]: A[K]
} extends infer B
  ? B
  : never

Added in v3.10.0

Struct (namespace)

Added in v3.10.0

Constructor (type alias)

Signature

export type Constructor<F extends Fields> =
  Types.UnionToIntersection<
    {
      [K in keyof F]: F[K] extends OptionalPropertySignature
        ? { readonly [H in K]?: Schema.Type<F[H]> }
        : F[K] extends PropertySignatureWithDefault
          ? { readonly [H in K]?: Schema.Type<F[H]> }
          : { readonly [h in K]: Schema.Type<F[h]> }
    }[keyof F]
  > extends infer Q
    ? Q
    : never

Added in v3.10.0

Context (type alias)

Signature

export type Context<F extends Fields> = Schema.Context<F[keyof F]>

Added in v3.10.0

Encoded (type alias)

Signature

export type Encoded<F extends Fields> = {
  readonly [K in Exclude<keyof F, EncodedTokenKeys<F>> as Key<F, K>]: Schema.Encoded<F[K]>
} & { readonly [K in EncodedTokenKeys<F> as Key<F, K>]?: Schema.Encoded<F[K]> }

Added in v3.10.0

Fields (type alias)

Signature

export type Fields = {
  readonly [x: PropertyKey]: Schema.All | PropertySignature.All
}

Added in v3.10.0

Type (type alias)

Signature

export type Type<F extends Fields> =
  Types.UnionToIntersection<
    {
      [K in keyof F]: F[K] extends OptionalPropertySignature
        ? { readonly [H in K]?: Schema.Type<F[H]> }
        : { readonly [h in K]: Schema.Type<F[h]> }
    }[keyof F]
  > extends infer Q
    ? Q
    : never

Added in v3.10.0

TaggedRequest (interface)

Signature

export interface TaggedRequest<
  Tag extends string,
  A,
  I,
  R,
  SuccessType,
  SuccessEncoded,
  FailureType,
  FailureEncoded,
  ResultR
> extends Request.Request<SuccessType, FailureType>,
    SerializableWithResult<A, I, R, SuccessType, SuccessEncoded, FailureType, FailureEncoded, ResultR> {
  readonly _tag: Tag
}

Added in v3.10.0

TaggedRequest (namespace)

Added in v3.10.0

All (type alias)

Signature

export type All = Any | TaggedRequest<string, any, any, any, any, any, never, never, unknown>

Added in v3.10.0

Any (type alias)

Signature

export type Any = TaggedRequest<string, any, any, any, any, any, any, any, unknown>

Added in v3.10.0

TupleType (namespace)

Added in v3.10.0

Elements (type alias)

Signature

export type Elements = ReadonlyArray<Schema.Any | Element<Schema.Any, Element.Token>>

Added in v3.10.0

Encoded (type alias)

Signature

export type Encoded<Elements extends TupleType.Elements, Rest extends TupleType.Rest> = Rest extends [
  infer Head,
  ...infer Tail
]
  ? Readonly<
      [
        ...ElementsEncoded<Elements>,
        ...ReadonlyArray<Schema.Encoded<Head>>,
        ...{ readonly [K in keyof Tail]: Schema.Encoded<Tail[K]> }
      ]
    >
  : ElementsEncoded<Elements>

Added in v3.10.0

Rest (type alias)

Signature

export type Rest = ReadonlyArray<Schema.Any | Element<Schema.Any, "">>

Added in v3.10.0

Type (type alias)

Signature

export type Type<Elements extends TupleType.Elements, Rest extends TupleType.Rest> = Rest extends [
  infer Head,
  ...infer Tail
]
  ? Readonly<
      [
        ...ElementsType<Elements>,
        ...ReadonlyArray<Schema.Type<Head>>,
        ...{ readonly [K in keyof Tail]: Schema.Type<Tail[K]> }
      ]
    >
  : ElementsType<Elements>

Added in v3.10.0

TypeLiteral (namespace)

Added in v3.10.0

Constructor (type alias)

Signature

export type Constructor<
  Fields extends Struct.Fields,
  Records extends IndexSignature.Records
> = Struct.Constructor<Fields> & IndexSignature.Type<Records>

Added in v3.10.0

Encoded (type alias)

Signature

export type Encoded<Fields extends Struct.Fields, Records extends IndexSignature.Records> = Struct.Encoded<Fields> &
  IndexSignature.Encoded<Records>

Added in v3.10.0

Type (type alias)

Signature

export type Type<Fields extends Struct.Fields, Records extends IndexSignature.Records> = Struct.Type<Fields> &
  IndexSignature.Type<Records>

Added in v3.10.0

asSchema

Signature

export declare const asSchema: <S extends Schema.All>(
  schema: S
) => Schema<Schema.Type<S>, Schema.Encoded<S>, Schema.Context<S>>

Added in v3.10.0

asSerializable

Signature

export declare const asSerializable: <S extends Serializable.All>(
  serializable: S
) => Serializable<Serializable.Type<S>, Serializable.Encoded<S>, Serializable.Context<S>>

Added in v3.10.0

asSerializableWithResult

Signature

export declare const asSerializableWithResult: <SWR extends SerializableWithResult.All>(
  procedure: SWR
) => SerializableWithResult<
  Serializable.Type<SWR>,
  Serializable.Encoded<SWR>,
  Serializable.Context<SWR>,
  WithResult.Success<SWR>,
  WithResult.SuccessEncoded<SWR>,
  WithResult.Failure<SWR>,
  WithResult.FailureEncoded<SWR>,
  WithResult.Context<SWR>
>

Added in v3.10.0

asWithResult

Signature

export declare const asWithResult: <WR extends WithResult.All>(
  withExit: WR
) => WithResult<
  WithResult.Success<WR>,
  WithResult.SuccessEncoded<WR>,
  WithResult.Failure<WR>,
  WithResult.FailureEncoded<WR>,
  WithResult.Context<WR>
>

Added in v3.10.0

element

Signature

export declare const element: <S extends Schema.Any>(self: S) => Element<S, "">

Added in v3.10.0

encodedBoundSchema

The encodedBoundSchema function is similar to encodedSchema but preserves the refinements up to the first transformation point in the original schema.

Signature

export declare const encodedBoundSchema: <A, I, R>(schema: Schema<A, I, R>) => SchemaClass<I>

Added in v3.10.0

encodedSchema

The encodedSchema function allows you to extract the Encoded portion of a schema, creating a new schema that conforms to the properties defined in the original schema without retaining any refinements or transformations that were applied previously.

Signature

export declare const encodedSchema: <A, I, R>(schema: Schema<A, I, R>) => SchemaClass<I>

Added in v3.10.0

optionalElement

Signature

export declare const optionalElement: <S extends Schema.Any>(self: S) => Element<S, "?">

Added in v3.10.0

tag

Returns a property signature that represents a tag. A tag is a literal value that is used to distinguish between different types of objects. The tag is optional when using the make method.

Signature

export declare const tag: <Tag extends AST.LiteralValue>(tag: Tag) => tag<Tag>

Example

import { Schema } from "effect"

const User = Schema.Struct({
  _tag: Schema.tag("User"),
  name: Schema.String,
  age: Schema.Number
})

assert.deepStrictEqual(User.make({ name: "John", age: 44 }), { _tag: "User", name: "John", age: 44 })

Added in v3.10.0

typeSchema

The typeSchema function allows you to extract the Type portion of a schema, creating a new schema that conforms to the properties defined in the original schema without considering the initial encoding or transformation processes.

Signature

export declare const typeSchema: <A, I, R>(schema: Schema<A, I, R>) => SchemaClass<A>

Added in v3.10.0

validation

asserts

By default the option exact is set to true.

Signature

export declare const asserts: <A, I, R>(
  schema: Schema<A, I, R>,
  options?: ParseOptions
) => (u: unknown, overrideOptions?: ParseOptions) => asserts u is A

Added in v3.10.0