<Self>(): <const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>) => Hyperlink.HyperlinkTag<Self, RunInstanceSpec<I, A, E>, RunHyperlink<PrettifyPayload<I['Type']>, Schema.Schema<out T>.Type<A>, Schema.Schema.Type<E>, never>> & { readonly run: RunHyperlinkStaticRun<I, A, E, Self>; } & { defaultSpec: { error: E; payload: I; success: A; effect: RunHyperlinkServiceEffect<I, A, E, R>; concurrency?: number; name: Name; }; configure: (patch: ConfigPatch<RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => Layer.Layer<never, never, never>; wrapGate: (fn: (previous: RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>['effect']) => RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>['effect']) => Layer.Layer<never, never, never>; layer: Layer.Layer<Store.Storage | Self | Hyperlink.Local<Self>, never, R>; }Class factory: tag + wire schemas + baked-in .layer + .configure.
constructors
Source src/RunHyperlink.ts:92859 lines
export const const Service: <Self>() => <
Name extends string,
I extends Schema.Top = Schema.Void,
A extends Schema.Top = Schema.Void,
E extends Schema.Top = Schema.Never,
R = never
>(
name: Name,
config: RunHyperlinkServiceConfig<I, A, E, R>
) => any
Class factory: tag + wire schemas + baked-in .layer + .configure.
Service = <function (type parameter) Self in <Self>(): <const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>) => anySelf>() => {
function function (local function) build<Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anybuild<
const function (type parameter) Name in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyName extends string,
function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyI extends import SchemaSchema.Top = 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<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,
function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyA extends import SchemaSchema.Top = 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<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,
function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyE extends import SchemaSchema.Top = 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<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,
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyR = never,
>(
name: const Name extends stringname: function (type parameter) Name in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyName,
config: RunHyperlinkServiceConfig<I, A, E, R>(parameter) config: {
effect: RunHyperlinkServiceEffect<I, A, E, R>;
concurrency: number;
payload: I;
success: A;
error: E;
}
interface RunHyperlinkServiceConfig<I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>Full
Service
config — wire schemas and the gated effect in one object.
RunHyperlinkServiceConfig<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyI, function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyA, function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyE, function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyR>,
) {
const const wire: {
readonly payload: I
readonly success: A
readonly error: E
}
const resolveRunWireSchemas: <
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top
>(
config: RunHyperlinkWireSchemas<I, A, E>
) => {
readonly payload: I
readonly success: A
readonly error: E
}
Resolved wire schemas with RPC defaults applied.
resolveRunWireSchemas(config: RunHyperlinkServiceConfig<I, A, E, R>(parameter) config: {
effect: RunHyperlinkServiceEffect<I, A, E, R>;
concurrency: number;
payload: I;
success: A;
error: E;
}
const tag: anytag = const runTag: <Self>() => {
(key: string): RunTagWithStaticRun<
Self,
typeof Schema.Void,
typeof Schema.Void,
typeof Schema.Never
>
<
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top = Schema.Never
>(
key: string,
config: RunHyperlinkTagSchemas<I, A, E>
): RunTagWithStaticRun<Self, I, A, E>
<I extends Schema.Top, A extends Schema.Top>(
key: string,
payload: I,
success: A,
options?: { readonly description?: string }
): RunTagWithStaticRun<
Self,
I,
A,
typeof Schema.Never
>
<
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top
>(
key: string,
payload: I,
success: A,
error: E,
options?: { readonly description?: string }
): RunTagWithStaticRun<Self, I, A, E>
}
Define a run (concurrency-gated effect) as a named service
Tag
:
class Backup extends RunHyperlink.Tag<Backup>()("@app/Backup", { payload: ArgsSchema }) {}. The
class is the Tag — yield* Backup resolves the
RunHyperlink
handle (its .run applies
the bounded-concurrency gate inline), while
layer
provides it and
serve
exposes it
over RPC. payload is the argument schema; optional success / error declare the result and
failure wire schemas.
runTag<function (type parameter) Self in <Self>(): <const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>) => anySelf>()(name: const Name extends stringname, config: RunHyperlinkServiceConfig<I, A, E, R>(parameter) config: {
effect: RunHyperlinkServiceEffect<I, A, E, R>;
concurrency: number;
payload: I;
success: A;
error: E;
}
const error: E extends Schema.Top = Schema.Nevererror = const wire: {
readonly payload: I
readonly success: A
readonly error: E
}
error: E extends Schema.Top = Schema.Nevererror;
const const defaultSpec: {
error: E
payload: I
success: A
effect: RunHyperlinkServiceEffect<I, A, E, R>
concurrency?: number
name: Name
}
name: const Name extends stringname, ...config: RunHyperlinkServiceConfig<I, A, E, R>(parameter) config: {
effect: RunHyperlinkServiceEffect<I, A, E, R>;
concurrency: number;
payload: I;
success: A;
error: E;
}
const wire: {
readonly payload: I
readonly success: A
readonly error: E
}
error: E extends Schema.Top = Schema.Nevererror };
const const layerConfig: RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
const layerConfig: {
name: string;
effect: RunHyperlinkLayerEffect<I, A, E, R>;
concurrency: number;
}
interface RunHyperlinkLayerConfig<I, A, E, R>Layer / serve config — the tag carries wire schemas; this supplies the gated effect.
RunHyperlinkLayerConfig<
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyI>,
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyA>,
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyE>,
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyR
> = {
RunHyperlinkLayerConfig<Schema<out T>.Type<I>, Schema.Type<A>, Schema.Type<E>, R>.effect: RunHyperlinkServiceEffect<I, A, E, R>Unit gates may pass a bare effect; parameterized gates use (input) => Effect.
effect: config: RunHyperlinkServiceConfig<I, A, E, R>(parameter) config: {
effect: RunHyperlinkServiceEffect<I, A, E, R>;
concurrency: number;
payload: I;
success: A;
error: E;
}
RunHyperlinkServiceConfig<I, A, E, R>.effect: RunHyperlinkServiceEffect<I, A, E, R>Unit gates may pass a bare effect; parameterized gates use (input) => Effect.
effect,
RunHyperlinkLayerConfig<Schema<out T>.Type<I>, Schema.Type<A>, Schema.Type<E>, R>.concurrency?: number | undefinedMax concurrent executions through this gate.
concurrency: config: RunHyperlinkServiceConfig<I, A, E, R>(parameter) config: {
effect: RunHyperlinkServiceEffect<I, A, E, R>;
concurrency: number;
payload: I;
success: A;
error: E;
}
RunHyperlinkServiceConfig<I, A, E, R>.concurrency?: number | undefinedMax concurrent executions through this gate.
concurrency,
RunHyperlinkLayerConfig<Schema<out T>.Type<I>, Schema.Type<A>, Schema.Type<E>, R>.name?: string | undefinedOverride telemetry / status resourceId; defaults to the tag key.
name,
};
return var Object: ObjectConstructorProvides functionality common to all JavaScript objects.
Object.ObjectConstructor.assign<any, {
defaultSpec: {
error: E;
payload: I;
success: A;
effect: RunHyperlinkServiceEffect<I, A, E, R>;
concurrency?: number;
name: Name;
};
configure: (patch: ConfigPatch<RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => any;
wrapGate: (fn: (previous: RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => any;
layer: Layer.Layer<...>;
}>(target: any, source: {
defaultSpec: {
error: E;
payload: I;
success: A;
effect: RunHyperlinkServiceEffect<I, A, E, R>;
concurrency?: number;
name: Name;
};
configure: (patch: ConfigPatch<RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>>) => any;
wrapGate: (fn: (previous: RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => RunHyperlinkLayerConfig<Schema.Schema.Type<I>, Schema.Schema.Type<A>, Schema.Schema.Type<E>, R>["effect"]) => any;
layer: Layer.Layer<...>;
}): any (+3 overloads)
Copy the values of all of the enumerable own properties from one or more source objects to a
target object. Returns the target object.
assign(const tag: anytag, {
defaultSpec: {
error: E
payload: I
success: A
effect: RunHyperlinkServiceEffect<I, A, E, R>
concurrency?: number
name: Name
}
configure: (
patch: ConfigPatch<
RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
>
) => any
patch: ConfigPatch<
RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
>
import ConfigPatchConfigPatch<
interface RunHyperlinkLayerConfig<I, A, E, R>Layer / serve config — the tag carries wire schemas; this supplies the gated effect.
RunHyperlinkLayerConfig<
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyI>,
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyA>,
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyE>,
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyR
>
>,
) => import configureLayerconfigureLayer(name: const Name extends stringname, patch: ConfigPatch<
RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
>
wrapGate: (
fn: (
previous: RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => any
fn: (
previous: RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
previous: RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
interface RunHyperlinkLayerConfig<I, A, E, R>Layer / serve config — the tag carries wire schemas; this supplies the gated effect.
RunHyperlinkLayerConfig<
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyI>,
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyA>,
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyE>,
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyR
>["effect"],
) => interface RunHyperlinkLayerConfig<I, A, E, R>Layer / serve config — the tag carries wire schemas; this supplies the gated effect.
RunHyperlinkLayerConfig<
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) I in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyI>,
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) A in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyA>,
import SchemaSchema.Schema.type Schema<out T>.Type<S> = S extends {
readonly Type: infer T;
} ? T : never
Extracts the decoded Type from a schema.
Example (Extracting the decoded type)
import { Schema } from "effect"
const Person = Schema.Struct({ name: Schema.String, age: Schema.Number })
type Person = Schema.Schema.Type<typeof Person>
// { readonly name: string; readonly age: number }
Type<function (type parameter) E in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyE>,
function (type parameter) R in build<const Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anyR
>["effect"],
) => import configureWrapEffectFieldconfigureWrapEffectField(name: const Name extends stringname, fn: (
previous: RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
) => RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>["effect"]
layer: Layer.Layer<any, never, R>(property) layer: {
build: (memoMap: Layer.MemoMap, scope: Scope.Scope) => Effect.Effect<Context.Context<any>, never, R>;
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; <…;
}
const layer: <
Self,
I extends Schema.Top,
A extends Schema.Top,
E extends Schema.Top = Schema.Never,
R = never
>(
tag: HyperlinkTag<
Self,
RunInstanceSpec<I, A, E>,
any
>,
config: RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
) => Layer.Layer<
Self | Local<Self> | Store.Storage,
never,
R
>
Build a Layer from a tag and config — yields an observable toolkit service.
Soft-defaults
Store.Storage
(R fulfilled). Override with your app store:
RunHyperlink.layer(Tag, config).pipe(Layer.provideMerge(AppStore.layer({ filename })))
layerMemory
is an alias for the same soft-default.
layer(const tag: anytag, const layerConfig: RunHyperlinkLayerConfig<
Schema.Schema.Type<I>,
Schema.Schema.Type<A>,
Schema.Schema.Type<E>,
R
>
const layerConfig: {
name: string;
effect: RunHyperlinkLayerEffect<I, A, E, R>;
concurrency: number;
}
function (local function) build<Name extends string, I extends Schema.Top = Schema.Void, A extends Schema.Top = Schema.Void, E extends Schema.Top = Schema.Never, R = never>(name: Name, config: RunHyperlinkServiceConfig<I, A, E, R>): anybuild;
};