SchemaParser

Creates a synchronous maker for the schema's decoded type side.

When to use

Use to construct decoded schema values synchronously when invalid input should throw an Error whose cause is SchemaIssue.Issue.

Details

The returned function constructs a value from constructor input and throws an Error with the SchemaIssue.Issue in its cause when construction fails. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw an Error whose cause is the underlying Cause, instead of being converted to a schema validation error.

declare function make<S extends Constraint>(schema: S): (input: S["~type.make.in"], options?: MakeOptions) => S["Type"]

Creates an effectful maker for the schema's decoded type side.

When to use

Use to construct decoded schema values in Effect while preserving construction failures as SchemaIssue.Issue values in the error channel.

Details

The returned function accepts constructor input, applies constructor defaults, runs type-side validation unless checks are disabled, and fails with a SchemaIssue.Issue when construction fails.

declare function makeEffect<S extends Constraint>(schema: S): (input: S["~type.make.in"], options?: MakeOptions) => Effect<S["Type"], Issue>

Creates a synchronous maker that returns Option.some with the constructed value on success, or Option.none when construction fails with schema issues.

When to use

Use when you need to validate schema constructor input and only care whether construction succeeds, without exposing SchemaIssue.Issue details.

Gotchas

Only causes made entirely of schema issues are converted to Option.none. Causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw an Error whose cause is the underlying Cause.

declare function makeOption<S extends Constraint>(schema: S): (input: S["~type.make.in"], options?: MakeOptions) => Option<S["Type"]>

Creates an effectful decoder for input already typed as the schema's Encoded type.

When to use

Use when you already have input typed as the schema's Encoded type and need an Effect whose failure channel is SchemaIssue.Issue, while preserving decoding service requirements.

Details

The returned function succeeds with the decoded Type or fails with a SchemaIssue.Issue, preserving any decoding service requirements in the returned Effect.

See

• decodeUnknownEffect for untyped boundary input
• encodeEffect for the opposite direction

declare const decodeEffect: <S extends Schema.Constraint>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Effect.Effect<S["Type"], SchemaIssue.Issue, S["DecodingServices"]>

Creates a synchronous decoder for input already typed as the schema's Encoded type, reporting failure safely as an Exit.

When to use

Use when you need synchronous decoding of already typed Encoded input into an Exit whose failure contains SchemaIssue.Issue.

Details

The returned function produces Exit.Success with the decoded Type or Exit.Failure with a SchemaIssue.Issue.

Gotchas

Because this adapter runs synchronously, async decoding work can produce an Exit.Failure with a defect cause. When the cause contains both schema issues and non-schema reasons, all reasons remain in the returned Cause.

See

• decodeUnknownExit for untyped input with the same Exit result shape
• decodeEffect for preserving decoding services and failures in Effect

declare const decodeExit: <S extends Schema.ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Exit.Exit<S["Type"], SchemaIssue.Issue>

Creates a Promise-based decoder for input already typed as the schema's Encoded type.

When to use

Use when you already have input typed as the schema's Encoded type and need decoding to return a JavaScript Promise.

Details

The returned function resolves with the decoded Type on success and rejects with an Error whose cause is a SchemaIssue.Issue on decoding failure. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or other non-schema reasons reject with an Error whose cause is the underlying Cause.

See

• decodeUnknownPromise for untyped input returning a JavaScript Promise
• decodeEffect for preserving decoding services and failures in Effect

declare function decodePromise<S extends ConstraintDecoder<unknown, never>>(schema: S, options?: ParseOptions): (input: S["Encoded"], options?: ParseOptions) => Promise<S["Type"]>

Creates a decoder for input already typed as the schema's Encoded type, reporting failure safely as a Result.

When to use

Use when you already have input typed as the schema's Encoded type and want schema decoding failures represented as Result.fail with SchemaIssue.Issue.

Details

The returned function produces Result.succeed with the decoded Type on success or Result.fail with a SchemaIssue.Issue on decoding failure.

Gotchas

This synchronous adapter returns Result.fail for causes made entirely of schema issues, but causes that contain defects, interruptions, or other non-schema reasons throw instead.

See

• decodeUnknownResult for untyped input with the same Result shape
• decodeEffect for effectful or service-requiring decoding

declare const decodeResult: <S extends Schema.ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Result.Result<S["Type"], SchemaIssue.Issue>

Creates a synchronous decoder for input already typed as the schema's Encoded type.

When to use

Use to decode values already typed as the schema's Encoded input when decoding failure should throw an Error whose cause is SchemaIssue.Issue.

Details

The returned function returns the decoded Type on success and throws an Error with the SchemaIssue.Issue in its cause on decoding failure. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw an Error whose cause is the underlying Cause, instead of being converted to a schema validation error.

See

• decodeUnknownSync for untrusted or dynamically typed input
• decodeResult for returning schema issues as data
• decodeEffect for preserving decoding failures in Effect

declare const decodeSync: <S extends Schema.ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => S["Type"]

Creates an effectful decoder for unknown input.

When to use

Use when you need to decode untyped boundary input in an Effect whose failure channel is SchemaIssue.Issue, while preserving transformations and service requirements.

Details

The returned function succeeds with the schema's decoded Type or fails with a SchemaIssue.Issue. Decoding service requirements are preserved in the returned Effect. Parse options may be provided when creating the decoder and overridden when applying it.

See

• decodeEffect for input already typed as the schema's Encoded type

declare function decodeUnknownEffect<S extends Constraint>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => Effect<S["Type"], Issue, S["DecodingServices"]>

Creates a synchronous decoder for unknown input that reports failure safely as an Exit.

When to use

Use when you need to decode unknown input synchronously into an Exit whose failure contains SchemaIssue.Issue.

Details

The returned function produces Exit.Success with the decoded Type. Schema issues are represented by an Exit.Failure cause containing a SchemaIssue.Issue.

Gotchas

Because this adapter runs synchronously, async decoding work can produce an Exit.Failure with a defect cause. When the cause contains both schema issues and non-schema reasons, all reasons remain in the returned Cause.

See

• decodeExit for input already typed as the schema's Encoded type
• decodeUnknownEffect for preserving decoding services and failures in Effect
• decodeUnknownResult for returning schema issues as data
• decodeUnknownSync for throwing on decoding failure

declare function decodeUnknownExit<S extends ConstraintDecoder<unknown, never>>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => Exit<S["Type"], Issue>

Creates a Promise-based decoder for unknown input.

When to use

Use when you need to decode untyped input with a service-free schema and return a JavaScript Promise.

Details

The returned function resolves with the decoded Type on success and rejects with an Error whose cause is a SchemaIssue.Issue on decoding failure. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or other non-schema reasons reject with an Error whose cause is the underlying Cause.

See

• decodePromise for input already typed as the schema's Encoded type
• decodeUnknownEffect for schemas that require decoding services or when failures should remain in Effect

declare function decodeUnknownPromise<S extends ConstraintDecoder<unknown, never>>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => Promise<S["Type"]>

Creates a decoder for unknown input that reports failure safely as a Result.

When to use

Use when decoding untyped boundary input and you want SchemaIssue.Issue failures returned as data in a Result.

Details

The returned function produces Result.succeed with the decoded Type on success or Result.fail with a SchemaIssue.Issue on decoding failure.

Gotchas

This adapter runs synchronously. Causes made entirely of schema issues become Result.fail, but causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw instead.

See

• decodeResult for input already typed as the schema's Encoded type
• decodeUnknownEffect for effectful or service-requiring decoding

declare function decodeUnknownResult<S extends ConstraintDecoder<unknown, never>>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => Result<S["Type"], Issue>

Creates a synchronous decoder for unknown input.

When to use

Use to decode untrusted or dynamically typed input at a synchronous boundary where invalid data should throw an Error whose cause is SchemaIssue.Issue.

Details

The returned function returns the decoded Type on success and throws an Error with the SchemaIssue.Issue in its cause on decoding failure. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw an Error whose cause is the underlying Cause, instead of being converted to a schema validation error.

See

• decodeSync for input already typed as the schema's Encoded type
• decodeUnknownEffect for preserving decoding failures in Effect
• decodeUnknownResult for returning schema issues as data

declare function decodeUnknownSync<S extends ConstraintDecoder<unknown, never>>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => S["Type"]

Creates an effectful encoder for input already typed as the schema's decoded Type.

When to use

Use when you need to encode values already typed as the schema's decoded Type in an Effect whose failure channel is SchemaIssue.Issue, while preserving service requirements.

Details

The returned function succeeds with the schema's Encoded value or fails with a SchemaIssue.Issue, preserving any encoding service requirements in the returned Effect.

See

• encodeUnknownEffect for encoding unknown input before the value is statically typed as the schema's Type

declare const encodeEffect: <S extends Schema.Constraint>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaIssue.Issue, S["EncodingServices"]>

Creates a synchronous encoder for input already typed as the schema's decoded Type, reporting failure safely as an Exit.

When to use

Use when you need synchronous encoding of already typed schema values into an Exit whose failure contains SchemaIssue.Issue.

Details

The returned function produces Exit.Success with the schema's Encoded value or Exit.Failure with a SchemaIssue.Issue.

Gotchas

Because this adapter runs synchronously, async encoding work can produce an Exit.Failure with a defect cause. When the cause contains both schema issues and non-schema reasons, all reasons remain in the returned Cause.

See

• encodeUnknownExit for unknown input with the same Exit result shape
• encodeEffect for effectful encoding that preserves service requirements

declare const encodeExit: <S extends Schema.ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Exit.Exit<S["Encoded"], SchemaIssue.Issue>

Creates a Promise-based encoder for input already typed as the schema's decoded Type.

When to use

Use when you already have values typed as the schema's decoded Type and need encoding to return a JavaScript Promise.

Details

The returned function resolves with the schema's Encoded value on success and rejects with an Error whose cause is a SchemaIssue.Issue on encoding failure. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or other non-schema reasons reject with an Error whose cause is the underlying Cause.

See

• encodeUnknownPromise for encoding untyped input
• encodeEffect for effectful encoding or schemas with encoding service requirements

declare const encodePromise: <S extends Schema.ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]>

Creates an encoder for input already typed as the schema's decoded Type, reporting failure safely as a Result.

When to use

Use when you already have input typed as the schema's decoded Type and want encoding failures returned as Result.fail with SchemaIssue.Issue.

Details

The returned function produces Result.succeed with the schema's Encoded value on success or Result.fail with a SchemaIssue.Issue on encoding failure.

Gotchas

This synchronous adapter returns Result.fail for causes made entirely of schema issues, but causes that contain defects, interruptions, or other non-schema reasons throw instead.

See

• encodeUnknownResult for the same Result shape when the input is not already typed

declare const encodeResult: <S extends Schema.ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Result.Result<S["Encoded"], SchemaIssue.Issue>

Creates a synchronous encoder for input already typed as the schema's decoded Type.

When to use

Use to encode already typed schema values synchronously when encoding failure should throw an Error whose cause is SchemaIssue.Issue.

Details

The returned function returns the schema's Encoded value on success and throws an Error with the SchemaIssue.Issue in its cause on encoding failure. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw an Error whose cause is the underlying Cause, instead of being converted to a schema validation error.

See

• encodeUnknownSync for unknown input with the same throwing boundary
• encodeResult for returning schema issues as data
• encodeEffect for effectful encoding that preserves service requirements

declare const encodeSync: <S extends Schema.ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => S["Encoded"]

Creates an effectful encoder for unknown input.

When to use

Use when you need to encode untyped boundary input in an Effect whose failure channel is SchemaIssue.Issue, while preserving service requirements.

Details

The returned function succeeds with the schema's Encoded value or fails with a SchemaIssue.Issue. Encoding service requirements are preserved in the returned Effect. Parse options may be provided when creating the encoder and overridden when applying it.

See

• encodeEffect for the typed-input variant when the value is already typed as the schema's decoded Type

declare function encodeUnknownEffect<S extends Constraint>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => Effect<S["Encoded"], Issue, S["EncodingServices"]>

Creates a synchronous encoder for unknown input that reports failure safely as an Exit.

When to use

Use when you need synchronous encoding of unknown input into an Exit whose failure contains SchemaIssue.Issue.

Details

The returned function produces Exit.Success with the schema's Encoded value or Exit.Failure with a SchemaIssue.Issue.

Gotchas

Because this adapter runs synchronously, async encoding work can produce an Exit.Failure with a defect cause. When the cause contains both schema issues and non-schema reasons, all reasons remain in the returned Cause.

See

• encodeExit for input already typed as the schema's decoded Type
• encodeUnknownEffect for effectful encoding that preserves service requirements

declare function encodeUnknownExit<S extends ConstraintEncoder<unknown, never>>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => Exit<S["Encoded"], Issue>

Creates a Promise-based encoder for unknown input.

When to use

Use when you need to encode untrusted or dynamically typed values with a service-free schema and return a JavaScript Promise.

Details

The returned function resolves with the schema's Encoded value on success and rejects with an Error whose cause is a SchemaIssue.Issue on encoding failure. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or other non-schema reasons reject with an Error whose cause is the underlying Cause.

See

• encodePromise for input already typed as the schema's decoded Type
• encodeUnknownEffect for schemas that require encoding services or when failures should remain in Effect

declare function encodeUnknownPromise<S extends ConstraintEncoder<unknown, never>>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => Promise<S["Encoded"]>

Creates an encoder for unknown input that reports failure safely as a Result.

When to use

Use when encoding values from an unknown or dynamically typed boundary synchronously, and you want SchemaIssue.Issue failures returned as Result data.

Details

The returned function produces Result.succeed with the schema's Encoded value on success or Result.fail with a SchemaIssue.Issue on encoding failure.

Gotchas

This adapter runs synchronously. Causes made entirely of schema issues become Result.fail, but causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw instead.

See

• encodeResult for input already typed as the schema's decoded Type
• encodeUnknownEffect for effectful encoding, including schemas with encoding service requirements

declare function encodeUnknownResult<S extends ConstraintEncoder<unknown, never>>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => Result<S["Encoded"], Issue>

Creates a synchronous encoder for unknown input.

When to use

Use when you need to encode values from untyped input in synchronous code and want encoding failures to throw an Error whose cause is SchemaIssue.Issue.

Details

The returned function returns the schema's Encoded value on success and throws an Error with the SchemaIssue.Issue in its cause on encoding failure. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw an Error whose cause is the underlying Cause, instead of being converted to a schema validation error.

See

• encodeSync for input already typed as the schema's decoded Type
• encodeUnknownEffect for effectful encoding that preserves service requirements

declare function encodeUnknownSync<S extends ConstraintEncoder<unknown, never>>(schema: S, options?: ParseOptions): (input: unknown, options?: ParseOptions) => S["Encoded"]

Asserts that an input satisfies the schema's decoded type side.

When to use

Use to assert that an input satisfies the decoded side of a schema when schema validation failures should throw an Error whose cause is SchemaIssue.Issue.

Details

The assertion returns normally when validation succeeds. When the input does not satisfy the schema with a schema-only failure, it throws an Error with the SchemaIssue.Issue in its cause. Schema validation failures use the generic message "Schema validation failed". Format the cause explicitly with SchemaIssue.makeFormatterDefault() when human-readable details are needed.

Gotchas

Causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw an Error whose cause is the underlying Cause, instead of being converted to a schema validation error.

declare function asserts<S extends Constraint, I>(schema: S, input: I): asserts input is I & S["Type"]

Creates a type guard that checks whether an input satisfies the schema's decoded type side.

When to use

Use to build a type guard for checking the decoded side of a schema without exposing issue details.

Details

The guard returns true on successful validation and false when validation fails only with schema issues, without exposing issue details.

Gotchas

Only causes made entirely of schema issues are converted to false. Causes that contain defects, interruptions, or asynchronous work at this synchronous boundary throw an Error whose cause is the underlying Cause.

declare function is<S extends Constraint>(schema: S): <I>(input: I) => input is I & S["Type"]