CustomQueueHyperlink.CustomQueueHyperlinkConfigWithItemSchematypesrc/internal/customQueueHyperlink.ts:169CustomQueueHyperlinkConfigWithItemSchema<T, E, R>export type type CustomQueueHyperlinkConfigWithItemSchema<
T,
E,
R
> = Omit<
QueueHyperlinkConfigBase<T>,
"levelCount"
> &
CustomQueueLevelConfig & {
readonly itemSchema: Schema.Codec<
T,
unknown,
never,
never
>
readonly effect: (
item: T,
ctx: EffectContext<T, QueueEnqueueErrors, R>
) => Effect.Effect<void, E, R>
readonly onFailure?: QueueOnFailure<T, E, R>
readonly refill?: CustomQueueRefill<
T,
E,
QueueEnqueueErrors,
R
>
readonly store?: QueueStoreWriter<T, E, void>
}
function (type parameter) T in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>T, function (type parameter) E in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>E, function (type parameter) R in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>R> = type Omit<T, K extends keyof any> = {
[P in Exclude<keyof T, K>]: T[P]
}
Construct a type with the properties of T except for those in type K.
Omit<
import QueueHyperlinkConfigBaseQueueHyperlinkConfigBase<function (type parameter) T in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>T>,
"levelCount"
> &
CustomQueueLevelConfig & {
readonly itemSchema: Schema.Codec<T, unknown, never, never>(property) itemSchema: {
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
Rebuild: Codec<T, E, RD, RE>;
Type: T;
Iso: Iso;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<T, any>) => Schema.Codec<T, unknown, never, never>;
annotateKey: (annotations: Schema.Annotations.Key<T>) => Schema.Codec<T, unknown, never, never>;
check: (checks_0: Check<T>, ...checks: Array<Check<T>>) => Schema.Codec<T, unknown, never, never>;
rebuild: (ast: AST) => Schema.Codec<T, unknown, never, never>;
make: (input: unknown, options?: Schema.MakeOptions) => T;
makeOption: (input: unknown, options?: Schema.MakeOptions) => Option<T>;
makeEffect: (input: unknown, options?: Schema.MakeOptions) => Effect.Effect<T, 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.interface Codec<out T, out E = T, out RD = never, out RE = never>Namespace of type-level helpers for
Codec
.
A schema that tracks the decoded type T, the encoded type E, and the
Effect services required during decoding (RD) and encoding (RE).
Details
Use Codec<T, E, RD, RE> when you need to preserve full type information
about a schema — both what it decodes to and what it serializes from/to.
Most concrete schemas produced by this module implement Codec.
For APIs that only need one direction, prefer the narrower views:
Decoder
<T, RD> — decode-only
Encoder
<E, RE> — encode-only
Schema
<T> — type-only (no encoded representation)
Example (Accepting a codec that decodes to number from string)
import { Schema } from "effect"
declare function serialize<T>(codec: Schema.Codec<T, string>): string
serialize(Schema.NumberFromString) // ok — decodes number, encoded as string
Codec<function (type parameter) T in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>T, unknown, never, never>;
readonly effect: (
item: T,
ctx: EffectContext<T, QueueEnqueueErrors, R>
) => Effect.Effect<void, E, R>
item: Titem: function (type parameter) T in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>T,
ctx: EffectContext<T, QueueEnqueueErrors, R>ctx: import EffectContextEffectContext<function (type parameter) T in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>T, import QueueEnqueueErrorsQueueEnqueueErrors, function (type parameter) R in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>R>,
) => import EffectEffect.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<void, function (type parameter) E in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>E, function (type parameter) R in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>R>;
readonly onFailure?: anyonFailure?: import QueueOnFailureQueueOnFailure<function (type parameter) T in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>T, function (type parameter) E in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>E, function (type parameter) R in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>R>;
readonly refill?: CustomQueueRefill<
T,
E,
QueueEnqueueErrors,
R
>
interface CustomQueueRefill<T, E, EEnqueue, R>CustomQueueRefill<function (type parameter) T in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>T, function (type parameter) E in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>E, import QueueEnqueueErrorsQueueEnqueueErrors, function (type parameter) R in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>R>;
/** Internal store recorder — wired by {@link CustomQueueHyperlink.layer}. @internal */
readonly store?: anyInternal store recorder — wired by
CustomQueueHyperlink.layer
.
store?: import QueueStoreWriterQueueStoreWriter<function (type parameter) T in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>T, function (type parameter) E in type CustomQueueHyperlinkConfigWithItemSchema<T, E, R>E, void>;
};