<F extends Schema.Struct.Fields>(
itemSchema: Schema.Struct<F>,
levelConfig: CustomQueueLevelConfig,
wire?: { readonly success?: Schema.Top; readonly error?: Schema.Top }
): {
add: Hyperlink.Method<
Schema.Tuple<
readonly [
Schema.Union<
readonly [Schema.Struct<F>, Schema.$Array<Schema.Struct<F>>]
>,
Schema.optional<Schema.Schema<string | number>>
]
>,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { readonly callStyle: "pair" } & {
description: string
},
Hyperlink.Derive
>
enqueue: Hyperlink.Method<
Schema.$Array<
Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
release: Hyperlink.Method<
{
readonly options: Schema.optionalKey<
Schema.Struct<{
readonly scope: Schema.optionalKey<
Schema.Literal<"pendingOnly">
>
readonly releaseId: Schema.optionalKey<Schema.String>
readonly attributes: Schema.optionalKey<
Schema.$Record<
Schema.String,
Schema.Codec<JsonValue, JsonValue, never, never>
>
>
}>
>
},
Schema.$Array<
Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>,
Schema.Never,
false,
Hyperlink.MethodAnnotations & {
description: string
destructive: true
},
Hyperlink.Derive
>
releaseEncoded: Hyperlink.Method<
{
readonly options: Schema.optionalKey<
Schema.Struct<{
readonly scope: Schema.optionalKey<
Schema.Literal<"pendingOnly">
>
readonly releaseId: Schema.optionalKey<Schema.String>
readonly attributes: Schema.optionalKey<
Schema.$Record<
Schema.String,
Schema.Codec<JsonValue, JsonValue, never, never>
>
>
}>
>
},
Schema.$Array<
Schema.Struct<{
readonly payload: Schema.Codec<JsonValue, JsonValue, never, never>
readonly item: Schema.Struct<{
readonly id: Schema.String
readonly version: Schema.String
readonly encoding: Schema.Literal<"json">
readonly jsonSchema: Schema.Unknown
}>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>,
Schema.Union<
readonly [
typeof QueueMissingItemSchemaError,
typeof QueueItemEncodingError
]
>,
false,
Hyperlink.MethodAnnotations & {
description: string
destructive: true
},
Hyperlink.Derive
>
deadLetter: Hyperlink.Method<
{
readonly selector: Schema.Struct<{
readonly entryId: Schema.optionalKey<Schema.String>
readonly key: Schema.optional<Schema.String>
readonly item: Schema.optionalKey<Schema.Struct<F>>
}>
readonly options: Schema.Struct<{
readonly reason: Schema.String
readonly attributes: Schema.optionalKey<
Schema.$Record<
Schema.String,
Schema.Codec<JsonValue, JsonValue, never, never>
>
>
}>
},
Schema.$Array<
Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>,
Schema.Never,
false,
Hyperlink.MethodAnnotations & {
description: string
destructive: true
},
Hyperlink.Derive
>
drop: Hyperlink.Method<
{
readonly selector: Schema.Struct<{
readonly entryId: Schema.optionalKey<Schema.String>
readonly key: Schema.optional<Schema.String>
readonly item: Schema.optionalKey<Schema.Struct<F>>
}>
readonly options: Schema.Struct<{
readonly reason: Schema.String
readonly attributes: Schema.optionalKey<
Schema.$Record<
Schema.String,
Schema.Codec<JsonValue, JsonValue, never, never>
>
>
}>
},
Schema.$Array<
Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>,
Schema.Never,
false,
Hyperlink.MethodAnnotations & {
description: string
destructive: true
},
Hyperlink.Derive
>
events: Hyperlink.Method<
undefined,
Schema.Union<
readonly [
Schema.TaggedStruct<"Start", { readonly key: Schema.String }>,
Schema.TaggedStruct<
"Enqueued",
{
readonly entries: Schema.$Array<
Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly batchId: Schema.optionalKey<Schema.String>
}
>,
Schema.TaggedStruct<
"Started",
{
readonly entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
}
>,
Schema.TaggedStruct<
"Completed",
{
readonly entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
readonly success: Schema.Union<
readonly [Schema.Top | Schema.Void]
>
readonly elapsed: Schema.Duration
}
>,
Schema.TaggedStruct<
"Failed",
{
readonly entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
readonly cause: Schema.Cause<
Schema.Top | Schema.Unknown,
Schema.Unknown
>
readonly elapsed: Schema.Duration
}
>,
Schema.TaggedStruct<
"RetryScheduled",
{
readonly entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
readonly cause: Schema.Cause<
Schema.Top | Schema.Unknown,
Schema.Unknown
>
readonly nextAttempt: Schema.Number
}
>,
Schema.TaggedStruct<
"RetryExhausted",
{
readonly entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
readonly cause: Schema.Cause<
Schema.Top | Schema.Unknown,
Schema.Unknown
>
}
>,
Schema.TaggedStruct<
"Drained",
{
readonly key: Schema.String
readonly completed: Schema.Number
}
>,
Schema.TaggedStruct<
"Cleared",
{ readonly key: Schema.String; readonly count: Schema.Number }
>,
Schema.TaggedStruct<
"ShutdownRequested",
{
readonly key: Schema.String
readonly mode: Schema.Literals<
readonly ["drain", "finishActive"]
>
readonly pending: Schema.Number
}
>,
Schema.TaggedStruct<
"ShutdownComplete",
{
readonly key: Schema.String
readonly completed: Schema.Number
}
>,
Schema.TaggedStruct<
"Released",
{
readonly key: Schema.String
readonly releaseId: Schema.String
readonly entries: Schema.$Array<
Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>
}
>,
Schema.TaggedStruct<
"DeadLettered",
{
readonly key: Schema.String
readonly entries: Schema.$Array<
Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>
readonly reason: Schema.String
}
>,
Schema.TaggedStruct<
"Dropped",
{
readonly key: Schema.String
readonly entries: Schema.$Array<
Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
>
readonly reason: Schema.String
}
>,
Schema.TaggedStruct<
"RateLimitExceeded",
{
readonly key: Schema.String
readonly entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: Schema.Literals<
readonly ["high", "normal", "low"]
>
readonly attempts: Schema.Number
readonly timestamps: Schema.Struct<{
readonly enqueuedAt: Schema.DateTimeUtc
readonly startedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly completedAt: Schema.optionalKey<Schema.DateTimeUtc>
readonly interruptedAt: Schema.optionalKey<Schema.DateTimeUtc>
}>
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<
Schema.$Record<Schema.String, Schema.Unknown>
>
}>
readonly limitKey: Schema.String
readonly algorithm: Schema.Literals<
readonly ["fixed-window", "token-bucket"]
>
readonly outcome: Schema.Literals<
readonly ["delayed", "rejected"]
>
}
>
]
>,
Schema.Never,
true,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
status: Hyperlink.Marked<
Hyperlink.Method<
undefined,
Schema.Struct<{
readonly sizes: Schema.$Record<Schema.String, Schema.Number>
readonly paused: Schema.Boolean
readonly inFlight: Schema.Number
readonly completed: Schema.Number
readonly phase: Schema.Literals<
readonly ["running", "draining", "off"]
>
}>,
Schema.Never,
true,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>,
{ readonly _tag: "ref" }
>
size: Hyperlink.Marked<
Hyperlink.Method<
undefined,
Schema.Number,
Schema.Never,
true,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>,
{ readonly _tag: "ref" }
>
isEmpty: Hyperlink.Marked<
Hyperlink.Method<
undefined,
Schema.Boolean,
Schema.Never,
true,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>,
{ readonly _tag: "ref" }
>
levelSizes: Hyperlink.Method<
undefined,
Schema.$Array<Schema.Number>,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
start: Hyperlink.Method<
undefined,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
pause: Hyperlink.Method<
undefined,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
resume: Hyperlink.Method<
undefined,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
shutdown: Hyperlink.Method<
undefined,
Schema.Void,
Schema.Never,
false,
Hyperlink.MethodAnnotations & {
description: string
destructive: true
},
Hyperlink.Derive
>
clear: Hyperlink.Method<
undefined,
Schema.Number,
Schema.Never,
false,
Hyperlink.MethodAnnotations & {
description: string
destructive: true
},
Hyperlink.Derive
>
metrics: {
stream: Hyperlink.Method<
undefined,
Schema.Struct<{
readonly windowStart: Schema.DateTimeUtc
readonly windowEnd: Schema.DateTimeUtc
readonly windowMillis: Schema.Number
readonly enqueued: Schema.Number
readonly started: Schema.Number
readonly completed: Schema.Number
readonly failed: Schema.Number
readonly retried: Schema.Number
readonly deadLettered: Schema.Number
readonly dropped: Schema.Number
readonly rateLimitExceeded: Schema.Number
readonly inFlight: Schema.Number
readonly throughputPerSec: Schema.Number
readonly avgWaitMillis: Schema.Struct<{
readonly high: Schema.optionalKey<Schema.Number>
readonly normal: Schema.optionalKey<Schema.Number>
readonly low: Schema.optionalKey<Schema.Number>
}>
readonly avgExecutionMillis: Schema.optionalKey<Schema.Number>
readonly avgTotalMillis: Schema.optionalKey<Schema.Number>
}>,
Schema.Never,
true,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
query: Hyperlink.Method<
{
limit: Schema.optionalKey<Schema.Number>
since: Schema.optionalKey<Schema.DateTimeUtc>
until: Schema.optionalKey<Schema.DateTimeUtc>
},
Schema.$Array<
Schema.Struct<{
readonly windowStart: Schema.DateTimeUtc
readonly windowEnd: Schema.DateTimeUtc
readonly windowMillis: Schema.Number
readonly enqueued: Schema.Number
readonly started: Schema.Number
readonly completed: Schema.Number
readonly failed: Schema.Number
readonly retried: Schema.Number
readonly deadLettered: Schema.Number
readonly dropped: Schema.Number
readonly rateLimitExceeded: Schema.Number
readonly inFlight: Schema.Number
readonly throughputPerSec: Schema.Number
readonly avgWaitMillis: Schema.Struct<{
readonly high: Schema.optionalKey<Schema.Number>
readonly normal: Schema.optionalKey<Schema.Number>
readonly low: Schema.optionalKey<Schema.Number>
}>
readonly avgExecutionMillis: Schema.optionalKey<Schema.Number>
readonly avgTotalMillis: Schema.optionalKey<Schema.Number>
}>
>,
Schema.Never,
false,
Hyperlink.MethodAnnotations & { description: string },
Hyperlink.Derive
>
}
}Build a custom-queue instance spec: shared customQueueControlSpec plus
per-instance data-plane procedures typed by itemSchema.
wire schemascustomQueueControlSpec
Source src/CustomQueueHyperlink.ts:21864 lines
export const const customQueueSpec: <
F extends Schema.Struct.Fields
>(
itemSchema: Schema.Struct<F>,
levelConfig: CustomQueueLevelConfig,
wire?: {
readonly success?: Schema.Top
readonly error?: Schema.Top
}
) => {
add: any
enqueue: any
release: any
releaseEncoded: any
deadLetter: any
drop: any
events: any
status: any
size: any
isEmpty: any
levelSizes: any
start: any
pause: any
resume: any
shutdown: any
clear: any
metrics: {
stream: any
query: any
}
}
Build a custom-queue instance spec: shared
customQueueControlSpec
plus
per-instance data-plane procedures typed by itemSchema.
customQueueSpec = <function (type parameter) F in <F extends Schema.Struct.Fields>(itemSchema: Schema.Struct<F>, levelConfig: CustomQueueLevelConfig, wire?: {
readonly success?: Schema.Top;
readonly error?: Schema.Top;
}): {
...;
}
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>(
itemSchema: Schema.Struct<F>(parameter) itemSchema: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: F) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>, readonly []>) => Schema.Struct<F>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>) => Schema.Struct<F>;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>, ...checks: Array<Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>…;
rebuild: (ast: Objects) => Schema.Struct<F>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMut…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Option.Option<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Effect.Effect<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
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.interface Struct<Fields extends Schema.Struct.Fields>Defines a struct schema from a map of field schemas.
Details
Each field value is a schema. Use
optionalKey
or
optional
to
mark fields as optional, and
mutableKey
to mark them as mutable.
The resulting schema's Type is a readonly object type with the fields'
decoded types. The Encoded form mirrors the field schemas' encoded types.
Example (Defining a basic struct)
import { Schema } from "effect"
const Person = Schema.Struct({
name: Schema.String,
age: Schema.Number,
email: Schema.optionalKey(Schema.String)
})
// { readonly name: string; readonly age: number; readonly email?: string }
type Person = typeof Person.Type
const alice = Schema.decodeUnknownSync(Person)({ name: "Alice", age: 30 })
console.log(alice)
// { name: 'Alice', age: 30 }
Namespace for struct field type utilities.
Details
These types compute the decoded Type, encoded Encoded, and constructor
input MakeIn of a
Struct
from its field map, handling optional,
mutable, and other field modifiers automatically.
Struct.Fields — constraint for the field map objectStruct.Type<F> — decoded type of the structStruct.Encoded<F> — encoded type of the structStruct.MakeIn<F> — constructor input (optional/defaulted fields may be omitted)Struct.DecodingServices<F> / Struct.EncodingServices<F> — required services
Type-level representation returned by
Struct
.
Struct<function (type parameter) F in <F extends Schema.Struct.Fields>(itemSchema: Schema.Struct<F>, levelConfig: CustomQueueLevelConfig, wire?: {
readonly success?: Schema.Top;
readonly error?: Schema.Top;
}): {
...;
}
levelConfig: CustomQueueLevelConfiglevelConfig: import CustomQueueLevelConfigCustomQueueLevelConfig,
wire: | {
readonly success?: Schema.Top
readonly error?: Schema.Top
}
| undefined
success?: Schema.Top | undefinedsuccess?: import SchemaSchema.Top; readonly error?: Schema.Top | undefinederror?: import SchemaSchema.Top },
) => {
const const itemOrItems: Schema.Union<
readonly [
Schema.Struct<F>,
Schema.$Array<Schema.Struct<F>>
]
>
const itemOrItems: {
Type: { [K in keyof Members]: Members[K]["Type"]; }[number];
Encoded: { [K in keyof Members]: Members[K]["Encoded"]; }[number];
DecodingServices: { [K in keyof Members]: Members[K]["DecodingServices"]; }[number];
EncodingServices: { [K in keyof Members]: Members[K]["EncodingServices"]; }[number];
Iso: { [K in keyof Members]: Members[K]["Iso"]; }[number];
members: Members;
mapMembers: (f: (members: readonly [Schema.Struct<F>, Schema.$Array<Schema.Struct<F>>]) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Union<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | ReadonlyArray<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeM…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | ReadonlyArray<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMuta…;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | ReadonlyArray<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>>, ...ch…;
rebuild: (ast: Union<Arrays | Objects>) => Schema.Union<readonly [Schema.Struct<F>, Schema.$Array<Schema.Struct<F>>]>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | ReadonlyArray<Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKe…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | ReadonlyArray<Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKe…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | ReadonlyArray<Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKe…;
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.function Union<readonly [Schema.Struct<F>, Schema.$Array<Schema.Struct<F>>]>(members: readonly [Schema.Struct<F>, Schema.$Array<Schema.Struct<F>>], options?: {
mode?: "anyOf" | "oneOf";
}): Schema.Union<readonly [Schema.Struct<F>, Schema.$Array<Schema.Struct<F>>]>
Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Union([itemSchema: Schema.Struct<F>(parameter) itemSchema: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: F) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>, readonly []>) => Schema.Struct<F>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>) => Schema.Struct<F>;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>, ...checks: Array<Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>…;
rebuild: (ast: Objects) => Schema.Struct<F>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMut…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Option.Option<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Effect.Effect<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
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.Array<Schema.Struct<F>>(self: Schema.Struct<F>): Schema.$Array<Schema.Struct<F>>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(itemSchema: Schema.Struct<F>(parameter) itemSchema: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: F) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>, readonly []>) => Schema.Struct<F>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>) => Schema.Struct<F>;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>, ...checks: Array<Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>…;
rebuild: (ast: Objects) => Schema.Struct<F>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMut…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Option.Option<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Effect.Effect<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
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 level: Schema.Schema<
string | number
>
const level: {
Type: T;
Rebuild: Schema<T>;
Iso: Iso;
ast: Ast;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<string | number, any>) => Schema.Schema<string | number>;
annotateKey: (annotations: Schema.Annotations.Key<string | number>) => Schema.Schema<string | number>;
check: (checks_0: Check<string | number>, ...checks: Array<Check<string | number>>) => Schema.Schema<string | number>;
rebuild: (ast: AST) => Schema.Schema<string | number>;
make: (input: unknown, options?: Schema.MakeOptions) => string | number;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<string | number>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<string | number, 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; <…;
}
const customQueueLevel: (
namedLevels?: Readonly<Record<string, number>>
) => Schema.Schema<number | string>
Level argument on the wire — numeric lane index or a name from the tag's
namedLevels registry (when declared at tag construction).
customQueueLevel(levelConfig: CustomQueueLevelConfiglevelConfig.namedLevels);
const const entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: any
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: any
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<any>
}>
const entry: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Schema.Number; readon…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ [x: string]: any; }, readonly []>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonl…;
annotateKey: (annotations: Schema.Annotations.Key<{ [x: string]: any }>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.o…;
check: (checks_0: Check<{ [x: string]: any }>, ...checks: Array<Check<{ [x: string]: any }>>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: an…;
rebuild: (ast: Objects) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Sc…;
make: (input: { [x: string]: any }, options?: Schema.MakeOptions) => { [x: string]: any };
makeOption: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Option.Option<{ [x: string]: any }>;
makeEffect: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Effect.Effect<{ [x: string]: any }, 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; <…;
}
const customQueueEntry: <Schema.Struct<F>>(itemSchema: Schema.Struct<F>) => Schema.Struct<{
readonly item: Schema.Struct<F>;
readonly entryId: Schema.String;
readonly key: Schema.optional<Schema.String>;
readonly priority: any;
readonly level: Schema.optional<Schema.Number>;
readonly attempts: Schema.Number;
readonly timestamps: any;
readonly batchId: Schema.optional<Schema.String>;
readonly releaseId: Schema.optional<Schema.String>;
readonly sourceHyperlinkId: Schema.optional<Schema.String>;
readonly attributes: Schema.optional<...>;
}>
Custom queue entry on the wire — like
queueEntry
plus optional numeric level.
customQueueEntry(itemSchema: Schema.Struct<F>(parameter) itemSchema: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: F) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>, readonly []>) => Schema.Struct<F>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>) => Schema.Struct<F>;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>, ...checks: Array<Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>…;
rebuild: (ast: Objects) => Schema.Struct<F>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMut…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Option.Option<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Effect.Effect<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
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 eventSchema: anyeventSchema = import buildQueueEventbuildQueueEvent(
itemSchema: Schema.Struct<F>(parameter) itemSchema: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: F) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>, readonly []>) => Schema.Struct<F>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>) => Schema.Struct<F>;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>, ...checks: Array<Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>…;
rebuild: (ast: Objects) => Schema.Struct<F>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMut…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Option.Option<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Effect.Effect<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
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; <…;
}
wire: | {
readonly success?: Schema.Top
readonly error?: Schema.Top
}
| undefined
success?: Schema.Top | undefinedsuccess ?? 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,
wire: | {
readonly success?: Schema.Top
readonly error?: Schema.Top
}
| undefined
error?: Schema.Top | undefinederror ?? import SchemaSchema.const Unknown: Schema.Unknownconst Unknown: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<unknown, readonly []>) => Schema.Unknown;
annotateKey: (annotations: Schema.Annotations.Key<unknown>) => Schema.Unknown;
check: (checks_0: Check<unknown>, ...checks: Array<Check<unknown>>) => Schema.Unknown;
rebuild: (ast: Unknown) => Schema.Unknown;
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; <…;
}
Type-level representation of
Unknown
.
Schema for the unknown type. Accepts any value without validation.
When to use
Use as a top schema when you need to accept any input while preserving
TypeScript's unknown safety at use sites.
Unknown,
);
return {
...const customQueueControlSpec: {
status: any
size: any
isEmpty: any
levelSizes: any
start: any
pause: any
resume: any
shutdown: any
clear: any
metrics: {
stream: any
query: any
}
}
Shared control + observation contract for every custom-queue instance.
customQueueControlSpec,
add: anyadd: import HyperlinkHyperlink.mutatePair(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, const itemOrItems: Schema.Union<
readonly [
Schema.Struct<F>,
Schema.$Array<Schema.Struct<F>>
]
>
const itemOrItems: {
Type: { [K in keyof Members]: Members[K]["Type"]; }[number];
Encoded: { [K in keyof Members]: Members[K]["Encoded"]; }[number];
DecodingServices: { [K in keyof Members]: Members[K]["DecodingServices"]; }[number];
EncodingServices: { [K in keyof Members]: Members[K]["EncodingServices"]; }[number];
Iso: { [K in keyof Members]: Members[K]["Iso"]; }[number];
members: Members;
mapMembers: (f: (members: readonly [Schema.Struct<F>, Schema.$Array<Schema.Struct<F>>]) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Union<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | ReadonlyArray<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeM…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | ReadonlyArray<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMuta…;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | ReadonlyArray<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>>, ...ch…;
rebuild: (ast: Union<Arrays | Objects>) => Schema.Union<readonly [Schema.Struct<F>, Schema.$Array<Schema.Struct<F>>]>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | ReadonlyArray<Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKe…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | ReadonlyArray<Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKe…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | ReadonlyArray<Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKe…;
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.const optional: optionalLambda
<Schema.Schema<string | number>>(self: Schema.Schema<string | number>) => Schema.optional<Schema.Schema<string | number>>
Type-level representation returned by
optional
.
Marks a struct field as optional, allowing the key to be absent or
undefined.
Details
The resulting property may be absent or explicitly set to undefined.
Equivalent to optionalKey(UndefinedOr(S)).
Use
optionalKey
instead if you want exact optional semantics (absent
only, not undefined).
Example (Defining an optional field accepting undefined)
import { Schema } from "effect"
const schema = Schema.Struct({
name: Schema.String,
age: Schema.optional(Schema.Number)
})
// { readonly name: string; readonly age?: number | undefined }
type Person = typeof schema.Type
optional(const level: Schema.Schema<
string | number
>
const level: {
Type: T;
Rebuild: Schema<T>;
Iso: Iso;
ast: Ast;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<string | number, any>) => Schema.Schema<string | number>;
annotateKey: (annotations: Schema.Annotations.Key<string | number>) => Schema.Schema<string | number>;
check: (checks_0: Check<string | number>, ...checks: Array<Check<string | number>>) => Schema.Schema<string | number>;
rebuild: (ast: AST) => Schema.Schema<string | number>;
make: (input: unknown, options?: Schema.MakeOptions) => string | number;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option.Option<string | number>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<string | number, 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; <…;
}
description: stringdescription:
"Enqueue an item (or batch) at an optional lane — numeric index or configured name.",
}),
enqueue: anyenqueue: import HyperlinkHyperlink.effectFn(import SchemaSchema.Array<Schema.Struct<{
readonly item: Schema.Struct<F>;
readonly entryId: Schema.String;
readonly key: Schema.optional<Schema.String>;
readonly priority: any;
readonly level: Schema.optional<Schema.Number>;
readonly attempts: Schema.Number;
readonly timestamps: any;
readonly batchId: Schema.optional<Schema.String>;
readonly releaseId: Schema.optional<Schema.String>;
readonly sourceHyperlinkId: Schema.optional<Schema.String>;
readonly attributes: Schema.optional<any>;
}>>(self: Schema.Struct<...>): Schema.$Array<...>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(const entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: any
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: any
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<any>
}>
const entry: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Schema.Number; readon…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ [x: string]: any; }, readonly []>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonl…;
annotateKey: (annotations: Schema.Annotations.Key<{ [x: string]: any }>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.o…;
check: (checks_0: Check<{ [x: string]: any }>, ...checks: Array<Check<{ [x: string]: any }>>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: an…;
rebuild: (ast: Objects) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Sc…;
make: (input: { [x: string]: any }, options?: Schema.MakeOptions) => { [x: string]: any };
makeOption: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Option.Option<{ [x: string]: any }>;
makeEffect: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Effect.Effect<{ [x: string]: any }, 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; <…;
}
description: stringdescription:
"Re-inject existing entries — each re-enters at its own level with attempts preserved.",
}),
release: anyrelease: import HyperlinkHyperlink.effectFn(
{ options: Schema.optionalKey<any>(property) options: {
Type: S["Type"];
Encoded: S["Encoded"];
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: S["Iso"];
schema: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<any, any>) => Schema.optionalKey<any>;
annotateKey: (annotations: Schema.Annotations.Key<any>) => Schema.optionalKey<any>;
check: (checks_0: Check<any>, ...checks: Array<Check<any>>) => Schema.optionalKey<any>;
rebuild: (ast: any) => Schema.optionalKey<any>;
make: (input: any, options?: Schema.MakeOptions) => any;
makeOption: (input: any, options?: Schema.MakeOptions) => Option.Option<any>;
makeEffect: (input: any, options?: Schema.MakeOptions) => Effect.Effect<any, 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.const optionalKey: optionalKeyLambda
;<any>(self: any) => Schema.optionalKey<any>
Type-level representation returned by
optionalKey
.
Creates an exact optional key schema for struct fields. Unlike optional,
this creates exact optional properties (not | undefined) that can be
completely omitted from the object.
Example (Creating a struct with optional key)
import { Schema } from "effect"
const schema = Schema.Struct({
name: Schema.String,
age: Schema.optionalKey(Schema.Number)
})
// Type: { readonly name: string; readonly age?: number }
type Person = typeof schema["Type"]
optionalKey(import queueReleaseOptionsqueueReleaseOptions) },
import SchemaSchema.Array<Schema.Struct<{
readonly item: Schema.Struct<F>;
readonly entryId: Schema.String;
readonly key: Schema.optional<Schema.String>;
readonly priority: any;
readonly level: Schema.optional<Schema.Number>;
readonly attempts: Schema.Number;
readonly timestamps: any;
readonly batchId: Schema.optional<Schema.String>;
readonly releaseId: Schema.optional<Schema.String>;
readonly sourceHyperlinkId: Schema.optional<Schema.String>;
readonly attributes: Schema.optional<any>;
}>>(self: Schema.Struct<...>): Schema.$Array<...>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(const entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: any
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: any
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<any>
}>
const entry: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Schema.Number; readon…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ [x: string]: any; }, readonly []>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonl…;
annotateKey: (annotations: Schema.Annotations.Key<{ [x: string]: any }>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.o…;
check: (checks_0: Check<{ [x: string]: any }>, ...checks: Array<Check<{ [x: string]: any }>>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: an…;
rebuild: (ast: Objects) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Sc…;
make: (input: { [x: string]: any }, options?: Schema.MakeOptions) => { [x: string]: any };
makeOption: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Option.Option<{ [x: string]: any }>;
makeEffect: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Effect.Effect<{ [x: string]: any }, 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; <…;
}
description: stringdescription:
"Export pending entries for handoff and remove them from this queue.",
destructive: booleandestructive: true,
}),
releaseEncoded: anyreleaseEncoded: import HyperlinkHyperlink.effectFn(
{ options: Schema.optionalKey<any>(property) options: {
Type: S["Type"];
Encoded: S["Encoded"];
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: S["Iso"];
schema: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<any, any>) => Schema.optionalKey<any>;
annotateKey: (annotations: Schema.Annotations.Key<any>) => Schema.optionalKey<any>;
check: (checks_0: Check<any>, ...checks: Array<Check<any>>) => Schema.optionalKey<any>;
rebuild: (ast: any) => Schema.optionalKey<any>;
make: (input: any, options?: Schema.MakeOptions) => any;
makeOption: (input: any, options?: Schema.MakeOptions) => Option.Option<any>;
makeEffect: (input: any, options?: Schema.MakeOptions) => Effect.Effect<any, 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.const optionalKey: optionalKeyLambda
;<any>(self: any) => Schema.optionalKey<any>
Type-level representation returned by
optionalKey
.
Creates an exact optional key schema for struct fields. Unlike optional,
this creates exact optional properties (not | undefined) that can be
completely omitted from the object.
Example (Creating a struct with optional key)
import { Schema } from "effect"
const schema = Schema.Struct({
name: Schema.String,
age: Schema.optionalKey(Schema.Number)
})
// Type: { readonly name: string; readonly age?: number }
type Person = typeof schema["Type"]
optionalKey(import queueReleaseOptionsqueueReleaseOptions) },
import SchemaSchema.Array<any>(self: any): Schema.$Array<any>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(import queueEncodedEntryqueueEncodedEntry),
import queueReleaseEncodingErrorqueueReleaseEncodingError,
).annotate({
description: stringdescription: "Export pending entries in encoded/wire form for remote handoff.",
destructive: booleandestructive: true,
}),
deadLetter: anydeadLetter: import HyperlinkHyperlink.effectFn(
{
selector: Schema.Struct<{
readonly entryId: Schema.optionalKey<Schema.String>
readonly key: Schema.optional<Schema.String>
readonly item: Schema.optionalKey<
Schema.Struct<F>
>
}>
(property) selector: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly entryId: Schema.optionalKey<Schema.String>; readonly key: Schema.optional<Schema.String>; readonly item: Schema.optionalKey<Schema.Struct<F>> }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly key?: string | undefined; readonly item?: Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | undefined; readonly entryId?: string | undefi…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly key?: string | undefined; readonly item?: Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | undefined; readonly entryId?: string | undefined…;
check: (checks_0: Check<{ readonly key?: string | undefined; readonly item?: Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | undefined; readonly entryId?: string | undefined }>, ...checks: Arra…;
rebuild: (ast: Objects) => Schema.Struct<{ readonly entryId: Schema.optionalKey<Schema.String>; readonly key: Schema.optional<Schema.String>; readonly item: Schema.optionalKey<Schema.Struct<F>> }>;
make: (input: { readonly key?: string | undefined; readonly item?: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | undefined; readonly entryId?: string | undefined }, options?: Sch…;
makeOption: (input: { readonly key?: string | undefined; readonly item?: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | undefined; readonly entryId?: string | undefined }, options?: Sch…;
makeEffect: (input: { readonly key?: string | undefined; readonly item?: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | undefined; readonly entryId?: string | undefined }, options?: Sch…;
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 customQueueEntrySelector: <Schema.Struct<F>>(itemSchema: Schema.Struct<F>) => Schema.Struct<{
readonly entryId: Schema.optionalKey<Schema.String>;
readonly key: Schema.optional<Schema.String>;
readonly item: Schema.optionalKey<Schema.Struct<F>>;
}>
Selector for custom-queue routing verbs.
customQueueEntrySelector(itemSchema: Schema.Struct<F>(parameter) itemSchema: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: F) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>, readonly []>) => Schema.Struct<F>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>) => Schema.Struct<F>;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>, ...checks: Array<Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>…;
rebuild: (ast: Objects) => Schema.Struct<F>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMut…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Option.Option<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Effect.Effect<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
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: anyoptions: import queueRouteOptionsqueueRouteOptions,
},
import SchemaSchema.Array<Schema.Struct<{
readonly item: Schema.Struct<F>;
readonly entryId: Schema.String;
readonly key: Schema.optional<Schema.String>;
readonly priority: any;
readonly level: Schema.optional<Schema.Number>;
readonly attempts: Schema.Number;
readonly timestamps: any;
readonly batchId: Schema.optional<Schema.String>;
readonly releaseId: Schema.optional<Schema.String>;
readonly sourceHyperlinkId: Schema.optional<Schema.String>;
readonly attributes: Schema.optional<any>;
}>>(self: Schema.Struct<...>): Schema.$Array<...>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(const entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: any
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: any
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<any>
}>
const entry: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Schema.Number; readon…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ [x: string]: any; }, readonly []>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonl…;
annotateKey: (annotations: Schema.Annotations.Key<{ [x: string]: any }>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.o…;
check: (checks_0: Check<{ [x: string]: any }>, ...checks: Array<Check<{ [x: string]: any }>>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: an…;
rebuild: (ast: Objects) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Sc…;
make: (input: { [x: string]: any }, options?: Schema.MakeOptions) => { [x: string]: any };
makeOption: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Option.Option<{ [x: string]: any }>;
makeEffect: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Effect.Effect<{ [x: string]: any }, 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; <…;
}
description: stringdescription: "Remove pending entries matching the selector and route to dead letter.",
destructive: booleandestructive: true,
}),
drop: anydrop: import HyperlinkHyperlink.effectFn(
{
selector: Schema.Struct<{
readonly entryId: Schema.optionalKey<Schema.String>
readonly key: Schema.optional<Schema.String>
readonly item: Schema.optionalKey<
Schema.Struct<F>
>
}>
(property) selector: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly entryId: Schema.optionalKey<Schema.String>; readonly key: Schema.optional<Schema.String>; readonly item: Schema.optionalKey<Schema.Struct<F>> }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly key?: string | undefined; readonly item?: Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | undefined; readonly entryId?: string | undefi…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly key?: string | undefined; readonly item?: Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | undefined; readonly entryId?: string | undefined…;
check: (checks_0: Check<{ readonly key?: string | undefined; readonly item?: Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>> | undefined; readonly entryId?: string | undefined }>, ...checks: Arra…;
rebuild: (ast: Objects) => Schema.Struct<{ readonly entryId: Schema.optionalKey<Schema.String>; readonly key: Schema.optional<Schema.String>; readonly item: Schema.optionalKey<Schema.Struct<F>> }>;
make: (input: { readonly key?: string | undefined; readonly item?: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | undefined; readonly entryId?: string | undefined }, options?: Sch…;
makeOption: (input: { readonly key?: string | undefined; readonly item?: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | undefined; readonly entryId?: string | undefined }, options?: Sch…;
makeEffect: (input: { readonly key?: string | undefined; readonly item?: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>> | undefined; readonly entryId?: string | undefined }, options?: Sch…;
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 customQueueEntrySelector: <Schema.Struct<F>>(itemSchema: Schema.Struct<F>) => Schema.Struct<{
readonly entryId: Schema.optionalKey<Schema.String>;
readonly key: Schema.optional<Schema.String>;
readonly item: Schema.optionalKey<Schema.Struct<F>>;
}>
Selector for custom-queue routing verbs.
customQueueEntrySelector(itemSchema: Schema.Struct<F>(parameter) itemSchema: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: F) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>, readonly []>) => Schema.Struct<F>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>) => Schema.Struct<F>;
check: (checks_0: Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>>, ...checks: Array<Check<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMutableKeys<F>>…;
rebuild: (ast: Objects) => Schema.Struct<F>;
make: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.Struct.TypeMut…;
makeOption: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Option.Option<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
makeEffect: (input: Schema.Struct.MakeInView<F, Schema.Struct.TypeOptionalKeys<F> | Schema.Struct.TypeConstructorDefaultedKeys<F>>, options?: Schema.MakeOptions) => Effect.Effect<Schema.Struct.View<F, 'Type', Schema.Struct.TypeOptionalKeys<F>, Schema.…;
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: anyoptions: import queueRouteOptionsqueueRouteOptions,
},
import SchemaSchema.Array<Schema.Struct<{
readonly item: Schema.Struct<F>;
readonly entryId: Schema.String;
readonly key: Schema.optional<Schema.String>;
readonly priority: any;
readonly level: Schema.optional<Schema.Number>;
readonly attempts: Schema.Number;
readonly timestamps: any;
readonly batchId: Schema.optional<Schema.String>;
readonly releaseId: Schema.optional<Schema.String>;
readonly sourceHyperlinkId: Schema.optional<Schema.String>;
readonly attributes: Schema.optional<any>;
}>>(self: Schema.Struct<...>): Schema.$Array<...>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(const entry: Schema.Struct<{
readonly item: Schema.Struct<F>
readonly entryId: Schema.String
readonly key: Schema.optional<Schema.String>
readonly priority: any
readonly level: Schema.optional<Schema.Number>
readonly attempts: Schema.Number
readonly timestamps: any
readonly batchId: Schema.optional<Schema.String>
readonly releaseId: Schema.optional<Schema.String>
readonly sourceHyperlinkId: Schema.optional<Schema.String>
readonly attributes: Schema.optional<any>
}>
const entry: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: (f: (fields: { readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Schema.Number; readon…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ [x: string]: any; }, readonly []>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonl…;
annotateKey: (annotations: Schema.Annotations.Key<{ [x: string]: any }>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.o…;
check: (checks_0: Check<{ [x: string]: any }>, ...checks: Array<Check<{ [x: string]: any }>>) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: an…;
rebuild: (ast: Objects) => Schema.Struct<{ readonly item: Schema.Struct<F>; readonly entryId: Schema.String; readonly key: Schema.optional<Schema.String>; readonly priority: any; readonly level: Schema.optional<Schema.Number>; readonly attempts: Sc…;
make: (input: { [x: string]: any }, options?: Schema.MakeOptions) => { [x: string]: any };
makeOption: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Option.Option<{ [x: string]: any }>;
makeEffect: (input: { [x: string]: any }, options?: Schema.MakeOptions) => Effect.Effect<{ [x: string]: any }, 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; <…;
}
description: stringdescription: "Remove pending entries matching the selector without preserving them.",
destructive: booleandestructive: true,
}),
events: anyevents: import HyperlinkHyperlink.stream(const eventSchema: anyeventSchema).annotate({
description: stringdescription: "Discrete entry / worker / queue lifecycle events.",
}),
};
};
Referenced by 2 symbols