<Su extends Schema.Top>(success: Su): Method<
undefined,
Su,
Schema.Never,
true
>
<Su extends Schema.Top, const F extends Schema.Struct.Fields>(
success: Su,
options: { readonly payload: F }
): Method<F, Su, Schema.Never, true>
<Su extends Schema.Top, P extends Schema.Top>(
success: Su,
options: { readonly payload: P }
): Method<P, Su, Schema.Never, true>
<Su extends Schema.Top, E extends Schema.Top>(
success: Su,
options: { readonly error: E }
): Method<undefined, Su, E, true>
<
Su extends Schema.Top,
const F extends Schema.Struct.Fields,
E extends Schema.Top
>(
success: Su,
options: { readonly payload: F; readonly error: E }
): Method<F, Su, E, true>
<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(
success: Su,
options: { readonly payload: P; readonly error: E }
): Method<P, Su, E, true>Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a resource's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),export function function stream<Su extends Schema.Top>(success: Su): Method<undefined, Su, Schema.Never, true> (+5 overloads)Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a resource's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),
stream<function (type parameter) Su in stream<Su extends Schema.Top>(success: Su): Method<undefined, Su, Schema.Never, true>Su extends import SchemaSchema.Top>(
success: Su extends Schema.Topsuccess: function (type parameter) Su in stream<Su extends Schema.Top>(success: Su): Method<undefined, Su, Schema.Never, true>Su,
): interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<undefined, function (type parameter) Su in stream<Su extends Schema.Top>(success: Su): Method<undefined, Su, Schema.Never, true>Su, import SchemaSchema.Never, true>;
export function function stream<Su extends Schema.Top, const F extends Schema.Struct.Fields>(success: Su, options: {
readonly payload: F;
}): Method<F, Su, Schema.Never, true> (+5 overloads)
Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a resource's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),
stream<function (type parameter) Su in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields>(success: Su, options: {
readonly payload: F;
}): Method<F, Su, Schema.Never, true>
import SchemaSchema.Top, const function (type parameter) F in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields>(success: Su, options: {
readonly payload: F;
}): Method<F, Su, Schema.Never, true>
import SchemaSchema.Struct.type Struct<Fields extends Struct.Fields>.Fields = {
readonly [x: string]: Schema.Constraint;
readonly [x: number]: Schema.Constraint;
readonly [x: symbol]: Schema.Constraint;
}
Constraint for a struct field map: an object whose values are schemas.
Fields>(
success: Su extends Schema.Topsuccess: function (type parameter) Su in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields>(success: Su, options: {
readonly payload: F;
}): Method<F, Su, Schema.Never, true>
options: {
readonly payload: F
}
payload: const F extends Schema.Struct.Fieldspayload: function (type parameter) F in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields>(success: Su, options: {
readonly payload: F;
}): Method<F, Su, Schema.Never, true>
interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<function (type parameter) F in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields>(success: Su, options: {
readonly payload: F;
}): Method<F, Su, Schema.Never, true>
function (type parameter) Su in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields>(success: Su, options: {
readonly payload: F;
}): Method<F, Su, Schema.Never, true>
import SchemaSchema.Never, true>;
// whole-schema payload — the value is passed/decoded directly (mirrors `Rpc.make`'s schema form).
export function function stream<Su extends Schema.Top, P extends Schema.Top>(success: Su, options: {
readonly payload: P;
}): Method<P, Su, Schema.Never, true> (+5 overloads)
Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a resource's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),
stream<function (type parameter) Su in stream<Su extends Schema.Top, P extends Schema.Top>(success: Su, options: {
readonly payload: P;
}): Method<P, Su, Schema.Never, true>
import SchemaSchema.Top, function (type parameter) P in stream<Su extends Schema.Top, P extends Schema.Top>(success: Su, options: {
readonly payload: P;
}): Method<P, Su, Schema.Never, true>
import SchemaSchema.Top>(
success: Su extends Schema.Topsuccess: function (type parameter) Su in stream<Su extends Schema.Top, P extends Schema.Top>(success: Su, options: {
readonly payload: P;
}): Method<P, Su, Schema.Never, true>
options: {
readonly payload: P
}
payload: P extends Schema.Toppayload: function (type parameter) P in stream<Su extends Schema.Top, P extends Schema.Top>(success: Su, options: {
readonly payload: P;
}): Method<P, Su, Schema.Never, true>
interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<function (type parameter) P in stream<Su extends Schema.Top, P extends Schema.Top>(success: Su, options: {
readonly payload: P;
}): Method<P, Su, Schema.Never, true>
function (type parameter) Su in stream<Su extends Schema.Top, P extends Schema.Top>(success: Su, options: {
readonly payload: P;
}): Method<P, Su, Schema.Never, true>
import SchemaSchema.Never, true>;
export function function stream<Su extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly error: E;
}): Method<undefined, Su, E, true> (+5 overloads)
Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a resource's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),
stream<function (type parameter) Su in stream<Su extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly error: E;
}): Method<undefined, Su, E, true>
import SchemaSchema.Top, function (type parameter) E in stream<Su extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly error: E;
}): Method<undefined, Su, E, true>
import SchemaSchema.Top>(
success: Su extends Schema.Topsuccess: function (type parameter) Su in stream<Su extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly error: E;
}): Method<undefined, Su, E, true>
options: {
readonly error: E
}
error: E extends Schema.Toperror: function (type parameter) E in stream<Su extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly error: E;
}): Method<undefined, Su, E, true>
interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<undefined, function (type parameter) Su in stream<Su extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly error: E;
}): Method<undefined, Su, E, true>
function (type parameter) E in stream<Su extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly error: E;
}): Method<undefined, Su, E, true>
function stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true> (+5 overloads)
Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a resource's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),
stream<
function (type parameter) Su in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
import SchemaSchema.Top,
const function (type parameter) F in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
import SchemaSchema.Struct.type Struct<Fields extends Struct.Fields>.Fields = {
readonly [x: string]: Schema.Constraint;
readonly [x: number]: Schema.Constraint;
readonly [x: symbol]: Schema.Constraint;
}
Constraint for a struct field map: an object whose values are schemas.
Fields,
function (type parameter) E in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
import SchemaSchema.Top,
>(
success: Su extends Schema.Topsuccess: function (type parameter) Su in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
options: {
readonly payload: F
readonly error: E
}
payload: const F extends Schema.Struct.Fieldspayload: function (type parameter) F in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
error: E extends Schema.Toperror: function (type parameter) E in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<function (type parameter) F in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
function (type parameter) Su in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
function (type parameter) E in stream<Su extends Schema.Top, const F extends Schema.Struct.Fields, E extends Schema.Top>(success: Su, options: {
readonly payload: F;
readonly error: E;
}): Method<F, Su, E, true>
function stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true> (+5 overloads)
Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a resource's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),
stream<
function (type parameter) Su in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
import SchemaSchema.Top,
function (type parameter) P in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
import SchemaSchema.Top,
function (type parameter) E in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
import SchemaSchema.Top,
>(
success: Su extends Schema.Topsuccess: function (type parameter) Su in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
options: {
readonly payload: P
readonly error: E
}
payload: P extends Schema.Toppayload: function (type parameter) P in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
error: E extends Schema.Toperror: function (type parameter) E in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
interface Method<P extends Schema.Struct.Fields | Schema.Top | undefined, Su extends Schema.Top, E extends Schema.Top, Str extends boolean = false, Ann extends MethodAnnotations = MethodAnnotations, Client = Derive>One method of a resource contract — built by
effect
/
effectFn
/
Hyperlink.stream
. Carries its kind, schemas
(payload / success / error), whether it's a stream (a push source vs a one-shot
read), and tool annotations. .annotate({...}) returns a copy with merged annotations,
mirroring Effect's schema idiom.
For a streaming method, success is the element schema and error is the stream
error schema — they become an RpcSchema.Stream on the wire, and the service member
surfaces as a Stream rather than an Effect.
Method<function (type parameter) P in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
function (type parameter) Su in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
function (type parameter) E in stream<Su extends Schema.Top, P extends Schema.Top, E extends Schema.Top>(success: Su, options: {
readonly payload: P;
readonly error: E;
}): Method<P, Su, E, true>
function stream<Su extends Schema.Top>(success: Su): Method<undefined, Su, Schema.Never, true> (+5 overloads)Define a stream (a live, idempotent push source) whose elements are success. The
service member surfaces as a Stream<Success, Error> (a property, or (payload) => Stream
when a payload is declared) rather than an Effect — drive dashboard atoms, a CLI
--watch, or a TUI from it. Conventionally named changes when it carries a resource's
whole observable state (a snapshot stream); back it with a SubscriptionRef's .changes.
Counts as a query for tools (an idempotent read). success is the element schema and
error (if any) is the stream error schema; both must be encodable (they cross RPC).
payload is a single schema or struct fields — same as Effect's Rpc.make.
changes: Hyperlink.stream(QueueSnapshot).annotate({ description: "Live queue state." }),
tail: Hyperlink.stream(LogLine, { payload: Schema.Struct({ since: Schema.Number }) }),
stream(
success: Schema.Top(parameter) success: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, any>) => Schema.Top;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Top;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Top;
rebuild: (ast: AST) => Schema.Top;
make: (input: unknown, options?: Schema.MakeOptions) => unknown;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<unknown>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<unknown, Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import SchemaSchema.Top,
options: | {
readonly payload?:
| Schema.Struct.Fields
| Schema.Top
readonly error?: Schema.Top
}
| undefined
payload?: | Schema.Top
| Schema.Struct.Fields
| undefined
import SchemaSchema.Struct.type Struct<Fields extends Struct.Fields>.Fields = {
readonly [x: string]: Schema.Constraint;
readonly [x: number]: Schema.Constraint;
readonly [x: symbol]: Schema.Constraint;
}
Constraint for a struct field map: an object whose values are schemas.
Fields | import SchemaSchema.Top;
readonly error?: Schema.Top | undefinederror?: import SchemaSchema.Top;
},
): type AnyMethod = Method<
Schema.Top | Schema.Struct.Fields | undefined,
Schema.Top,
Schema.Top,
boolean,
MethodAnnotations,
never
>
Any
Method
, erased — the element type of a
Spec
.
AnyMethod {
return const makeMethod: <
P extends
| Schema.Struct.Fields
| Schema.Top
| undefined,
Su extends Schema.Top,
E extends Schema.Top,
Str extends boolean,
Ann extends MethodAnnotations = MethodAnnotations,
Client = Derive
>(
kind: MethodKind,
payload: P,
success: Su,
error: E,
stream: Str,
annotations: Ann
) => Method<P, Su, E, Str, Ann, Client>
The single
Method
constructor —
effect
,
effectFn
,
constant
,
value
, and
stream
all go through it.
makeMethod(
"query",
options: | {
readonly payload?:
| Schema.Struct.Fields
| Schema.Top
readonly error?: Schema.Top
}
| undefined
payload?: | Schema.Top
| Schema.Struct.Fields
| undefined
success: Schema.Top(parameter) success: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, any>) => Schema.Top;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Top;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Top;
rebuild: (ast: AST) => Schema.Top;
make: (input: unknown, options?: Schema.MakeOptions) => unknown;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<unknown>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<unknown, Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
options: | {
readonly payload?:
| Schema.Struct.Fields
| Schema.Top
readonly error?: Schema.Top
}
| undefined
error?: Schema.Top | undefinederror ?? import SchemaSchema.const Never: Schema.Neverconst Never: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<never, readonly []>) => Schema.Never;
annotateKey: (annotations: Schema.Annotations.Key<never>) => Schema.Never;
check: (checks_0: Check<never>, ...checks: Array<Check<never>>) => Schema.Never;
rebuild: (ast: Never) => Schema.Never;
make: (input: never, options?: Schema.MakeOptions) => never;
makeOption: (input: never, options?: Schema.MakeOptions) => Option.Option<never>;
makeEffect: (input: never, options?: Schema.MakeOptions) => Effect.Effect<never, Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Type-level representation of
Never
.
Schema for the never type. Always fails validation — no value satisfies it.
Never,
true,
{},
);
}