Schema.$Record<
Schema.String,
Schema.Codec<JsonValue, JsonValue, never, never>
>Option attributes — a readonly record of JsonValue, matching the engine's
{ readonly [key: string]: JsonValue } on QueueReleaseOptions / QueueRouteOptions.
wire schemasJsonValue
Source src/WorkPool.ts:2861 lines
export const const queueJsonAttributes: Schema.$Record<
Schema.String,
Schema.Codec<JsonValue, JsonValue, never, never>
>
const queueJsonAttributes: {
Type: Record.Type<Key, Value>;
Encoded: Record.Encoded<Key, Value>;
DecodingServices: Record.DecodingServices<Key, Value>;
EncodingServices: Record.EncodingServices<Key, Value>;
Iso: Record.Iso<Key, Value>;
key: Key;
value: Value;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly [x: string]: JsonValue; }, readonly []>) => Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly [x: string]: JsonValue }>) => Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
check: (checks_0: Check<{ readonly [x: string]: JsonValue }>, ...checks: Array<Check<{ readonly [x: string]: JsonValue }>>) => Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
rebuild: (ast: Objects) => Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
make: (input: { readonly [x: string]: unknown }, options?: MakeOptions) => { readonly [x: string]: JsonValue };
makeOption: (input: { readonly [x: string]: unknown }, options?: MakeOptions) => Option_.Option<{ readonly [x: string]: JsonValue }>;
makeEffect: (input: { readonly [x: string]: unknown }, options?: MakeOptions) => Effect.Effect<{ readonly [x: string]: JsonValue }, 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; <…;
}
Option attributes — a readonly record of
JsonValue
, matching the engine's
{ readonly [key: string]: JsonValue } on QueueReleaseOptions / QueueRouteOptions.
queueJsonAttributes = import SchemaSchema.function Record<
Key extends Record.Key,
Value extends Constraint
>(
key: Key,
value: Value,
options?: {
readonly keyValueCombiner: {
readonly decode?:
| Combiner.Combiner<
readonly [Key["Type"], Value["Type"]]
>
| undefined
readonly encode?:
| Combiner.Combiner<
readonly [
Key["Encoded"],
Value["Encoded"]
]
>
| undefined
}
}
): $Record<Key, Value>
Defines a record schema whose dynamic properties are selected by a key schema
and decoded with a value schema.
Details
For dynamic keys, the key schema selects matching own properties and the
value schema decodes or encodes only those selected properties. Checks on
string, number, symbol, and template literal key schemas narrow which
properties are selected.
For transformed key schemas, property selection is based on encoded property
names before the selected key is decoded.
Example (Defining a string-keyed record of numbers)
import { Schema } from "effect"
const schema = Schema.Record(Schema.String, Schema.Number)
// { readonly [x: string]: number }
type R = typeof schema.Type
const result = Schema.decodeUnknownSync(schema)({ a: 1, b: 2 })
console.log(result)
// { a: 1, b: 2 }
Record(import SchemaSchema.const String: Stringconst String: {
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<string, readonly []>) => Schema.String;
annotateKey: (annotations: Schema.Annotations.Key<string>) => Schema.String;
check: (checks_0: Check<string>, ...checks: Array<Check<string>>) => Schema.String;
rebuild: (ast: String) => Schema.String;
make: (input: string, options?: MakeOptions) => string;
makeOption: (input: string, options?: MakeOptions) => Option_.Option<string>;
makeEffect: (input: string, options?: MakeOptions) => Effect.Effect<string, 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
String
.
Schema for string values. Validates that the input is typeof "string".
String, const jsonValue: Schema.Codec<JsonValue>const jsonValue: {
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
Rebuild: Codec<T, E, RD, RE>;
Type: T;
Iso: Iso;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<JsonValue, any>) => Schema.Codec<JsonValue, JsonValue, never, never>;
annotateKey: (annotations: Schema.Annotations.Key<JsonValue>) => Schema.Codec<JsonValue, JsonValue, never, never>;
check: (checks_0: Check<JsonValue>, ...checks: Array<Check<JsonValue>>) => Schema.Codec<JsonValue, JsonValue, never, never>;
rebuild: (ast: AST) => Schema.Codec<JsonValue, JsonValue, never, never>;
make: (input: unknown, options?: MakeOptions) => JsonValue;
makeOption: (input: unknown, options?: MakeOptions) => Option_.Option<JsonValue>;
makeEffect: (input: unknown, options?: MakeOptions) => Effect.Effect<JsonValue, 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; <…;
}
Recursive structural JSON value schema — decodes to
JsonValue
. Used for the option
attributes, which the engine persists as JSON. Schema.suspend breaks the self-reference.
jsonValue);
Referenced by 2 symbols