<Client = Derive>(): <P extends Schema.Top>(
payload: RequiredPayloadSchema<P>
) => Method<
P,
typeof Schema.Void,
typeof Schema.Never,
false,
MethodAnnotations,
Client
>Two-stage effectFn that lets you override the client-facing type with an unconstrained Client:
unsafeEffectFn<Client>()(payload). The wire/impl still come from the schema; only what yield* Tag
reads is replaced by Client. Unsafe: unlike the narrowing effectFn<Client>() form, Client is
not checked against the schema — you assert it matches. Reach for it only when the derivation can't be
expressed (e.g. a generic library like the queue, whose correct overloads are unprovable under <F>).
add: Hyperlink.unsafeEffectFn<{
(item: Hyperlink.Decoded<typeof itemSchema>): Effect.Effect<void>
(items: readonly Hyperlink.Decoded<typeof itemSchema>[]): Effect.Effect<void>
}>()(itemOrItems)export function function unsafeEffectFn<
Client = Derive
>(): <P extends Schema.Top>(
payload: RequiredPayloadSchema<P>
) => Method<
P,
typeof Schema.Void,
typeof Schema.Never,
false,
MethodAnnotations,
Client
>
Two-stage effectFn that lets you override the client-facing type with an unconstrained Client:
unsafeEffectFn<Client>()(payload). The wire/impl still come from the schema; only what yield* Tag
reads is replaced by Client. Unsafe: unlike the narrowing effectFn<Client>() form, Client is
not checked against the schema — you assert it matches. Reach for it only when the derivation can't be
expressed (e.g. a generic library like the queue, whose correct overloads are unprovable under <F>).
add: Hyperlink.unsafeEffectFn<{
(item: Hyperlink.Decoded<typeof itemSchema>): Effect.Effect<void>
(items: readonly Hyperlink.Decoded<typeof itemSchema>[]): Effect.Effect<void>
}>()(itemOrItems)
unsafeEffectFn<function (type parameter) Client in unsafeEffectFn<Client = Derive>(): <P extends Schema.Top>(payload: RequiredPayloadSchema<P>) => Method<P, typeof Schema.Void, typeof Schema.Never, false, MethodAnnotations, Client>Client = Derive>() {
return <function (type parameter) P in <P extends Schema.Top>(payload: RequiredPayloadSchema<P>): Method<P, typeof Schema.Void, typeof Schema.Never, false, MethodAnnotations, Client>P extends import SchemaSchema.Top>(
payload: RequiredPayloadSchema<P>payload: type RequiredPayloadSchema<
P extends Schema.Top
> = [P] extends [Schema.Void] ? never : P
Non-void schema payload for
effectFn
.
RequiredPayloadSchema<function (type parameter) P in <P extends Schema.Top>(payload: RequiredPayloadSchema<P>): Method<P, typeof Schema.Void, typeof Schema.Never, false, MethodAnnotations, Client>P>,
): 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 <P extends Schema.Top>(payload: RequiredPayloadSchema<P>): Method<P, typeof Schema.Void, typeof Schema.Never, false, MethodAnnotations, Client>P, typeof import SchemaSchema.const Void: Schema.Voidconst Void: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<void, readonly []>) => Schema.Void;
annotateKey: (annotations: Schema.Annotations.Key<void>) => Schema.Void;
check: (checks_0: Check<void>, ...checks: Array<Check<void>>) => Schema.Void;
rebuild: (ast: Void) => Schema.Void;
make: (input: void, options?: Schema.MakeOptions) => void;
makeOption: (input: void, options?: Schema.MakeOptions) => Option.Option<void>;
makeEffect: (input: void, options?: Schema.MakeOptions) => Effect.Effect<void, 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
Void
.
Schema for a TypeScript void return value.
When to use
Use when you need to model the return value of a function, RPC, or endpoint
whose result is intentionally ignored.
Details
Runtime parsing accepts any present value and discards it, producing
undefined. The public decoded and encoded TypeScript representation remains
void, so typed construction, decoding, and encoding APIs are still modeled
as void.
Void, typeof 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, false, MethodAnnotations, function (type parameter) Client in unsafeEffectFn<Client = Derive>(): <P extends Schema.Top>(payload: RequiredPayloadSchema<P>) => Method<P, typeof Schema.Void, typeof Schema.Never, false, MethodAnnotations, Client>Client> =>
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<function (type parameter) P in <P extends Schema.Top>(payload: RequiredPayloadSchema<P>): Method<P, typeof Schema.Void, typeof Schema.Never, false, MethodAnnotations, Client>P, typeof import SchemaSchema.const Void: Schema.Voidconst Void: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<void, readonly []>) => Schema.Void;
annotateKey: (annotations: Schema.Annotations.Key<void>) => Schema.Void;
check: (checks_0: Check<void>, ...checks: Array<Check<void>>) => Schema.Void;
rebuild: (ast: Void) => Schema.Void;
make: (input: void, options?: Schema.MakeOptions) => void;
makeOption: (input: void, options?: Schema.MakeOptions) => Option.Option<void>;
makeEffect: (input: void, options?: Schema.MakeOptions) => Effect.Effect<void, 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
Void
.
Schema for a TypeScript void return value.
When to use
Use when you need to model the return value of a function, RPC, or endpoint
whose result is intentionally ignored.
Details
Runtime parsing accepts any present value and discards it, producing
undefined. The public decoded and encoded TypeScript representation remains
void, so typed construction, decoding, and encoding APIs are still modeled
as void.
Void, typeof 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, false, MethodAnnotations, function (type parameter) Client in unsafeEffectFn<Client = Derive>(): <P extends Schema.Top>(payload: RequiredPayloadSchema<P>) => Method<P, typeof Schema.Void, typeof Schema.Never, false, MethodAnnotations, Client>Client>(
"mutate",
payload: RequiredPayloadSchema<P>payload,
import SchemaSchema.const Void: Schema.Voidconst Void: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<void, readonly []>) => Schema.Void;
annotateKey: (annotations: Schema.Annotations.Key<void>) => Schema.Void;
check: (checks_0: Check<void>, ...checks: Array<Check<void>>) => Schema.Void;
rebuild: (ast: Void) => Schema.Void;
make: (input: void, options?: Schema.MakeOptions) => void;
makeOption: (input: void, options?: Schema.MakeOptions) => Option.Option<void>;
makeEffect: (input: void, options?: Schema.MakeOptions) => Effect.Effect<void, 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
Void
.
Schema for a TypeScript void return value.
When to use
Use when you need to model the return value of a function, RPC, or endpoint
whose result is intentionally ignored.
Details
Runtime parsing accepts any present value and discards it, producing
undefined. The public decoded and encoded TypeScript representation remains
void, so typed construction, decoding, and encoding APIs are still modeled
as void.
Void,
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,
false,
{},
);
}