Schema overview
Added in v3.10.0
Table of contents
- API interface
- BigDecimal constructors
- BigDecimal filters
- BigDecimal transformations
- Cause transformations
- Cause utils
- Chunk
- Chunk transformations
- Config validations
- Data transformations
- Date constructors
- Date filters
- Date transformations
- DateTime.Utc constructors
- DateTime.Utc transformations
- DateTime.Zoned constructors
- DateTime.Zoned transformations
- Duration constructors
- Duration filters
- Duration transformations
- Either transformations
- Either utils
- Equivalence
- Exit transformations
- Exit utils
- FiberId
- FiberId constructors
- FiberId transformations
- HashMap transformations
- HashSet transformations
- List transformations
- Map
- Map transformations
- Option transformations
- Option utils
- PropertySignature
- FromPropertySignature (class)
- PropertySignature (interface)
- PropertySignatureDeclaration (class)
- PropertySignatureTransformation (class)
- ToPropertySignature (class)
- fromKey
- makePropertySignature
- optional
- optionalToOptional
- optionalToRequired
- optionalWith
- propertySignature
- requiredToOptional
- withConstructorDefault
- withDecodingDefault
- withDefaults
- ReadonlyArray filters
- ReadonlyArray transformations
- ReadonlyMap
- ReadonlyMap transformations
- ReadonlySet
- ReadonlySet transformations
- Redacted constructors
- Redacted transformations
- Set
- Set transformations
- SortedSet transformations
- TimeZone constructors
- TimeZone transformations
- URL constructors
- URL transformations
- Uint8Array constructors
- Uint8Array transformations
- accessor
- annotations
- api interface
- Array$ (interface)
- ArrayEnsure (interface)
- Cause (interface)
- CauseFromSelf (interface)
- Chunk (interface)
- ChunkFromSelf (interface)
- Class (interface)
- Defect (interface)
- Either (interface)
- EitherFromSelf (interface)
- EitherFromUnion (interface)
- Enums (interface)
- Exit (interface)
- ExitFromSelf (interface)
- HashMap (interface)
- HashMapFromSelf (interface)
- HashSet (interface)
- HashSetFromSelf (interface)
- List (interface)
- ListFromSelf (interface)
- Literal (interface)
- Map$ (interface)
- MapFromSelf (interface)
- NonEmptyArray (interface)
- NonEmptyArrayEnsure (interface)
- NonEmptyChunk (interface)
- NonEmptyChunkFromSelf (interface)
- NullOr (interface)
- NullishOr (interface)
- Option (interface)
- OptionFromNullOr (interface)
- OptionFromNullishOr (interface)
- OptionFromSelf (interface)
- OptionFromUndefinedOr (interface)
- ReadonlyMap$ (interface)
- ReadonlyMapFromSelf (interface)
- ReadonlySet$ (interface)
- ReadonlySetFromSelf (interface)
- Record$ (interface)
- Redacted (interface)
- RedactedFromSelf (interface)
- Set$ (interface)
- SetFromSelf (interface)
- SortedSet (interface)
- SortedSetFromSelf (interface)
- Struct (interface)
- TaggedClass (interface)
- TaggedErrorClass (interface)
- TaggedRequestClass (interface)
- TaggedStruct (type alias)
- TimeZoneFromSelf (interface)
- Tuple (interface)
- TupleType (interface)
- TypeLiteral (interface)
- UndefinedOr (interface)
- Union (interface)
- brand (interface)
- extend (interface)
- filter (interface)
- filterEffect (interface)
- instanceOf (interface)
- mutable (interface)
- optional (interface)
- optionalWith (interface)
- refine (interface)
- suspend (interface)
- tag (interface)
- transform (interface)
- transformLiteral (interface)
- transformOrFail (interface)
- bigint constructors
- bigint filters
- bigint transformations
- boolean constructors
- boolean transformations
- branding
- classes
- combinators
- constructors
- decoding
- defect
- encoding
- filtering
- formatting
- guards
- model
- number constructors
- number filters
- number transformations
- primitives
- renaming
- schema id
- BetweenBigDecimalSchemaId
- BetweenBigIntSchemaId
- BetweenBigIntSchemaId (type alias)
- BetweenDateSchemaId
- BetweenDurationSchemaId
- BetweenSchemaId
- BetweenSchemaId (type alias)
- BrandSchemaId
- CapitalizedSchemaId
- EndsWithSchemaId
- FiniteSchemaId
- FiniteSchemaId (type alias)
- GreaterThanBigDecimalSchemaId
- GreaterThanBigIntSchemaId
- GreaterThanBigIntSchemaId (type alias)
- GreaterThanDateSchemaId
- GreaterThanDurationSchemaId
- GreaterThanOrEqualToBigDecimalSchemaId
- GreaterThanOrEqualToBigIntSchemaId
- GreaterThanOrEqualToBigIntSchemaId (type alias)
- GreaterThanOrEqualToDateSchemaId
- GreaterThanOrEqualToDurationSchemaId
- GreaterThanOrEqualToSchemaId
- GreaterThanOrEqualToSchemaId (type alias)
- GreaterThanSchemaId
- GreaterThanSchemaId (type alias)
- IncludesSchemaId
- InstanceOfSchemaId
- IntSchemaId
- IntSchemaId (type alias)
- ItemsCountSchemaId
- ItemsCountSchemaId (type alias)
- JsonNumberSchemaId
- JsonNumberSchemaId (type alias)
- LengthSchemaId
- LengthSchemaId (type alias)
- LessThanBigDecimalSchemaId
- LessThanBigIntSchemaId
- LessThanBigIntSchemaId (type alias)
- LessThanDateSchemaId
- LessThanDurationSchemaId
- LessThanOrEqualToBigDecimalSchemaId
- LessThanOrEqualToBigIntSchemaId
- LessThanOrEqualToBigIntSchemaId (type alias)
- LessThanOrEqualToDateSchemaId
- LessThanOrEqualToDurationSchemaId
- LessThanOrEqualToSchemaId
- LessThanOrEqualToSchemaId (type alias)
- LessThanSchemaId
- LessThanSchemaId (type alias)
- LowercasedSchemaId
- MaxItemsSchemaId
- MaxItemsSchemaId (type alias)
- MaxLengthSchemaId
- MaxLengthSchemaId (type alias)
- MinItemsSchemaId
- MinItemsSchemaId (type alias)
- MinLengthSchemaId
- MinLengthSchemaId (type alias)
- MultipleOfSchemaId
- NegativeBigDecimalSchemaId
- NonNaNSchemaId
- NonNaNSchemaId (type alias)
- NonNegativeBigDecimalSchemaId
- NonPositiveBigDecimalSchemaId
- PatternSchemaId
- PositiveBigDecimalSchemaId
- StartsWithSchemaId
- TrimmedSchemaId
- ULIDSchemaId
- UUIDSchemaId
- UncapitalizedSchemaId
- UppercasedSchemaId
- ValidDateSchemaId
- string constructors
- string filters
- string transformations
- struct transformations
- symbol
- symbol transformations
- template literal
- transformations
- utils
- Element (namespace)
- EnumsDefinition (type alias)
- IndexSignature (namespace)
- OptionalOptions (type alias)
- ParseJsonOptions (type alias)
- PropertySignature (namespace)
- Schema (namespace)
- Simplify (type alias)
- SimplifyMutable (type alias)
- Struct (namespace)
- TaggedRequest (interface)
- TaggedRequest (namespace)
- TupleType (namespace)
- TypeLiteral (namespace)
- asSchema
- asSerializable
- asSerializableWithResult
- asWithResult
- element
- encodedBoundSchema
- encodedSchema
- optionalElement
- tag
- typeSchema
- validation
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
head
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 anotherSchema.String
refinement or a string literalSchema.Number
with anotherSchema.Number
refinement or a number literalSchema.Boolean
with anotherSchema.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