Schema.Struct<{
readonly _tag: Schema.tag<"Objects">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<Schema.String, Schema.Unknown>,
Schema.$Record<
Schema.String,
Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>
>,
never,
never
>
>
readonly propertySignatures: Schema.$Array<
Schema.Struct<{
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<Schema.String, Schema.Unknown>,
Schema.$Record<
Schema.String,
Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>
>,
never,
never
>
>
readonly name: Schema.Union<
readonly [Schema.Finite, Schema.Symbol, Schema.String]
>
readonly type: Schema.suspend<$Representation>
readonly isOptional: Schema.Boolean
readonly isMutable: Schema.Boolean
}>
>
readonly indexSignatures: Schema.$Array<
Schema.Struct<{
readonly parameter: Schema.suspend<$Representation>
readonly type: Schema.suspend<$Representation>
}>
>
readonly checks: Schema.$Array<
Schema.Codec<
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMinProperties">
readonly minProperties: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMaxProperties">
readonly maxProperties: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isPropertiesLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isPropertyNames">
readonly propertyNames: Schema.suspend<$Representation>
},
"Type"
>
>,
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMinProperties">
readonly minProperties: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMaxProperties">
readonly maxProperties: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isPropertiesLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isPropertyNames">
readonly propertyNames: Schema.suspend<$Representation>
},
"Type"
>
>,
never,
never
>
>
}>Schema for the Objects representation node.
schemasObjects
Source effect/SchemaRepresentation.ts:13807 lines
export const const $Objects: Schema.Struct<{
readonly _tag: Schema.tag<"Objects">;
readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
readonly propertySignatures: Schema.$Array<Schema.Struct<{
readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
readonly name: Schema.Union<...>;
readonly type: Schema.suspend<...>;
readonly isOptional: Schema.Boolean;
readonly isMutable: Schema.Boolean;
}>>;
readonly indexSignatures: Schema.$Array<...>;
readonly checks: Schema.$Array<...>;
}>
const $Objects: {
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 _tag: Schema.tag<'Objects'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly _tag: 'Objects'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int; }, 'Type'> | Schema.Str…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Objects'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }, 'Type'> | Schema.Struct.…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Objects'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }, 'Type'> | Schema.Struct.ReadonlySi…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Objects'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree…;
make: (input: { readonly checks: ReadonlyArray<unknown>; readonly propertySignatures: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotation…;
makeOption: (input: { readonly checks: ReadonlyArray<unknown>; readonly propertySignatures: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotation…;
makeEffect: (input: { readonly checks: ReadonlyArray<unknown>; readonly propertySignatures: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotation…;
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; <…;
}
Schema for the
Objects
representation node.
$Objects = import SchemaSchema.function Struct<
Fields extends Struct.Fields
>(fields: Fields): 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 }
Struct({
_tag: Schema.tag<"Objects">(property) _tag: {
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<'Objects', readonly []>) => Schema.withConstructorDefault<Schema.Literal<'Objects'>>;
annotateKey: (annotations: Schema.Annotations.Key<'Objects'>) => Schema.withConstructorDefault<Schema.Literal<'Objects'>>;
check: (checks_0: SchemaAST.Check<'Objects'>, ...checks: Array<SchemaAST.Check<'Objects'>>) => Schema.withConstructorDefault<Schema.Literal<'Objects'>>;
rebuild: (ast: SchemaAST.Literal) => Schema.withConstructorDefault<Schema.Literal<'Objects'>>;
make: (input: 'Objects', options?: MakeOptions) => 'Objects';
makeOption: (input: 'Objects', options?: MakeOptions) => Option_.Option<'Objects'>;
makeEffect: (input: 'Objects', options?: MakeOptions) => Effect.Effect<'Objects', 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.function tag<
Tag extends SchemaAST.LiteralValue
>(literal: Tag): tag<Tag>
Combines a
Literal
schema with
withConstructorDefault
, making it ideal
for discriminator fields in tagged unions. When constructing via make, the
_tag field can be omitted and will be filled automatically.
Example (Defining a discriminated union tag)
import { Schema } from "effect"
const A = Schema.Struct({ _tag: Schema.tag("A"), value: Schema.Number })
// _tag is optional in make, auto-filled to "A"
const a = A.make({ value: 42 })
// a: { _tag: "A", value: 42 }
tag("Objects"),
annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<Schema.String, Schema.Unknown>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
(property) annotations: {
Rebuild: optional<S>;
Type: S["Type"];
Encoded: S["Encoded"];
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: S["Iso"];
schema: S;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly [x: string]: unknown; } | undefined, readonly []>) => Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTre…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly [x: string]: unknown } | undefined>) => Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree,…;
check: (checks_0: SchemaAST.Check<{ readonly [x: string]: unknown } | undefined>, ...checks: Array<SchemaAST.Check<{ readonly [x: string]: unknown } | undefined>>) => Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, …;
rebuild: (ast: SchemaAST.Union<SchemaAST.Undefined | SchemaAST.Objects>) => Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, neve…;
make: (input: { readonly [x: string]: unknown } | undefined, options?: MakeOptions) => { readonly [x: string]: unknown } | undefined;
makeOption: (input: { readonly [x: string]: unknown } | undefined, options?: MakeOptions) => Option_.Option<{ readonly [x: string]: unknown } | undefined>;
makeEffect: (input: { readonly [x: string]: unknown } | undefined, options?: MakeOptions) => Effect.Effect<{ readonly [x: string]: unknown } | undefined, 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 optional: optionalLambda
<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>(self: Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>) => Schema.optional<...>
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 $Annotations: Schema.decodeTo<
Schema.$Record<Schema.String, Schema.Unknown>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
const $Annotations: {
Type: To["Type"];
Encoded: From["Encoded"];
DecodingServices: To["DecodingServices"] | From["DecodingServices"] | RD;
EncodingServices: To["EncodingServices"] | From["EncodingServices"] | RE;
Iso: To["Iso"];
from: From;
to: To;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly [x: string]: unknown; }, readonly []>) => Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, nev…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly [x: string]: unknown }>) => Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, neve…;
check: (checks_0: SchemaAST.Check<{ readonly [x: string]: unknown }>, ...checks: Array<SchemaAST.Check<{ readonly [x: string]: unknown }>>) => Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Cod…;
rebuild: (ast: SchemaAST.Objects) => Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>;
make: (input: { readonly [x: string]: unknown }, options?: MakeOptions) => { readonly [x: string]: unknown };
makeOption: (input: { readonly [x: string]: unknown }, options?: MakeOptions) => Option_.Option<{ readonly [x: string]: unknown }>;
makeEffect: (input: { readonly [x: string]: unknown }, options?: MakeOptions) => Effect.Effect<{ readonly [x: string]: unknown }, 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; <…;
}
Schema for serializing public Schema.Annotations.Annotations values. It
filters out internal annotation keys and non-primitive values during
encoding.
When to use
Use to serialize schema annotations in representation schemas while retaining
only primitive-tree metadata.
Details
Decoding is passthrough. Encoding removes internal annotation keys and values
that are not accepted by $PrimitiveTree.
$Annotations),
propertySignatures: Schema.$Array<
Schema.Struct<{
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
readonly name: Schema.Union<
readonly [
Schema.Finite,
Schema.Symbol,
Schema.String
]
>
readonly type: Schema.suspend<$Representation>
readonly isOptional: Schema.Boolean
readonly isMutable: Schema.Boolean
}>
>
(property) propertySignatures: {
Type: ReadonlyArray<S["Type"]>;
Encoded: ReadonlyArray<S["Encoded"]>;
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: ReadonlyArray<S["Iso"]>;
value: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<ReadonlyArray<{ readonly isOptional: boolean; readonly type: Representation; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unkno…;
annotateKey: (annotations: Schema.Annotations.Key<ReadonlyArray<{ readonly isOptional: boolean; readonly type: Representation; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown …;
check: (checks_0: SchemaAST.Check<ReadonlyArray<{ readonly isOptional: boolean; readonly type: Representation; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefi…;
rebuild: (ast: SchemaAST.Arrays) => Schema.$Array<Schema.Struct<{ readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, n…;
make: (input: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, options?: MakeOpti…;
makeOption: (input: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, options?: MakeOpti…;
makeEffect: (input: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, options?: MakeOpti…;
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<{
readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>;
readonly name: Schema.Union<readonly [Schema.Finite, Schema.Symbol, Schema.String]>;
readonly type: Schema.suspend<$Representation>;
readonly isOptional: Schema.Boolean;
readonly isMutable: Schema.Boolean;
}>>(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 $PropertySignature: Schema.Struct<{
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
readonly name: Schema.Union<
readonly [
Schema.Finite,
Schema.Symbol,
Schema.String
]
>
readonly type: Schema.suspend<$Representation>
readonly isOptional: Schema.Boolean
readonly isMutable: Schema.Boolean
}>
const $PropertySignature: {
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 annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>; readonly name: Sch…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly isOptional: boolean; readonly type: Representation; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown; } | undefi…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly isOptional: boolean; readonly type: Representation; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined …;
check: (checks_0: SchemaAST.Check<{ readonly isOptional: boolean; readonly type: Representation; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...che…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, never>>, never…;
make: (input: { readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { reado…;
makeOption: (input: { readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_…;
makeEffect: (input: { readonly isOptional: boolean; readonly type: unknown; readonly name: string | number | symbol; readonly isMutable: boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.…;
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; <…;
}
Schema for the
PropertySignature
type.
$PropertySignature),
indexSignatures: Schema.$Array<
Schema.Struct<{
readonly parameter: Schema.suspend<$Representation>
readonly type: Schema.suspend<$Representation>
}>
>
(property) indexSignatures: {
Type: ReadonlyArray<S["Type"]>;
Encoded: ReadonlyArray<S["Encoded"]>;
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: ReadonlyArray<S["Iso"]>;
value: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<ReadonlyArray<Schema.Struct.ReadonlySide<{ readonly parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation>; }, 'Type'>>, readonly []>) => Schema.$Array<Schema.Stru…;
annotateKey: (annotations: Schema.Annotations.Key<ReadonlyArray<Schema.Struct.ReadonlySide<{ readonly parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation> }, 'Type'>>>) => Schema.$Array<Schema.Struct<{ readonly par…;
check: (checks_0: SchemaAST.Check<ReadonlyArray<Schema.Struct.ReadonlySide<{ readonly parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation> }, 'Type'>>>, ...checks: Array<SchemaAST.Check<ReadonlyArray<Schema.S…;
rebuild: (ast: SchemaAST.Arrays) => Schema.$Array<Schema.Struct<{ readonly parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation> }>>;
make: (input: ReadonlyArray<Struct.ReadonlyMakeIn<{ readonly parameter: suspend<SchemaRepresentation.$Representation>; readonly type: suspend<SchemaRepresentation.$Representation> }>>, options?: MakeOptions) => ReadonlyArray<Struct.ReadonlySide<…;
makeOption: (input: ReadonlyArray<Struct.ReadonlyMakeIn<{ readonly parameter: suspend<SchemaRepresentation.$Representation>; readonly type: suspend<SchemaRepresentation.$Representation> }>>, options?: MakeOptions) => Option_.Option<ReadonlyArray<Struc…;
makeEffect: (input: ReadonlyArray<Struct.ReadonlyMakeIn<{ readonly parameter: suspend<SchemaRepresentation.$Representation>; readonly type: suspend<SchemaRepresentation.$Representation> }>>, options?: MakeOptions) => Effect.Effect<ReadonlyArray<Struct…;
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<{
readonly parameter: Schema.suspend<$Representation>;
readonly type: Schema.suspend<$Representation>;
}>>(self: Schema.Struct<{
readonly parameter: Schema.suspend<$Representation>;
readonly type: Schema.suspend<$Representation>;
}>): Schema.$Array<Schema.Struct<{
readonly parameter: Schema.suspend<$Representation>;
readonly type: Schema.suspend<$Representation>;
}>>
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 $IndexSignature: Schema.Struct<{
readonly parameter: Schema.suspend<$Representation>
readonly type: Schema.suspend<$Representation>
}>
const $IndexSignature: {
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 parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation> }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Read…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation>; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly parameter: Sche…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation> }, 'Type'>>) => Schema.Struct<{ readonly parameter: Schema.suspend<$Repre…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation> }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly parameter: Schema.suspend<$Representation>; readonly type: Schema.suspend<$Representation> }>;
make: (input: Struct.ReadonlyMakeIn<{ readonly parameter: suspend<SchemaRepresentation.$Representation>; readonly type: suspend<SchemaRepresentation.$Representation> }>, options?: MakeOptions) => Struct.ReadonlySide<{ readonly parameter: suspend…;
makeOption: (input: Struct.ReadonlyMakeIn<{ readonly parameter: suspend<SchemaRepresentation.$Representation>; readonly type: suspend<SchemaRepresentation.$Representation> }>, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly par…;
makeEffect: (input: Struct.ReadonlyMakeIn<{ readonly parameter: suspend<SchemaRepresentation.$Representation>; readonly type: suspend<SchemaRepresentation.$Representation> }>, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly para…;
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; <…;
}
Schema for the
IndexSignature
type.
$IndexSignature),
checks: Schema.$Array<
Schema.Codec<
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMinProperties">
readonly minProperties: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMaxProperties">
readonly maxProperties: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isPropertiesLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isPropertyNames">
readonly propertyNames: Schema.suspend<$Representation>
},
"Type"
>
>,
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMinProperties">
readonly minProperties: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMaxProperties">
readonly maxProperties: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isPropertiesLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isPropertyNames">
readonly propertyNames: Schema.suspend<$Representation>
},
"Type"
>
>,
never,
never
>
>
(property) checks: {
Type: ReadonlyArray<S["Type"]>;
Encoded: ReadonlyArray<S["Encoded"]>;
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: ReadonlyArray<S["Iso"]>;
value: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int; }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<…;
annotateKey: (annotations: Schema.Annotations.Key<ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isM…;
check: (checks_0: SchemaAST.Check<ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMaxProperti…;
rebuild: (ast: SchemaAST.Arrays) => Schema.$Array<Schema.Codec<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'…;
make: (input: ReadonlyArray<unknown>, options?: MakeOptions) => ReadonlyArray<SchemaRepresentation.Check<Struct.ReadonlySide<{ readonly _tag: tag<'isMinProperties'>; readonly minProperties: Int }, 'Type'> | Struct.ReadonlySide<{ readonly _tag: t…;
makeOption: (input: ReadonlyArray<unknown>, options?: MakeOptions) => Option_.Option<ReadonlyArray<SchemaRepresentation.Check<Struct.ReadonlySide<{ readonly _tag: tag<'isMinProperties'>; readonly minProperties: Int }, 'Type'> | Struct.ReadonlySide<{ r…;
makeEffect: (input: ReadonlyArray<unknown>, options?: MakeOptions) => Effect.Effect<ReadonlyArray<SchemaRepresentation.Check<Struct.ReadonlySide<{ readonly _tag: tag<'isMinProperties'>; readonly minProperties: Int }, 'Type'> | Struct.ReadonlySide<{ re…;
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.Codec<Check<Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlySide<{
readonly _tag: Schema.tag<"isMinProperties">;
readonly minProperties: Schema.Int;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isMaxProperties">;
readonly maxProperties: Schema.Int;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isPropertiesLengthBetween">;
readonly minimum: Schema.Int;
readonly maximum: Schema.Int;
}, "Type"> | Schema.Struct.ReadonlySide<...>>, Check<...>, never, never>>(self: Schema.Codec<...>): 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(function makeCheck<T>(
meta: Schema.Codec<T>,
identifier: string
): Schema.Codec<Check<T>, Check<T>, never, never>
const $ObjectsMeta: Schema.Union<
readonly [
Schema.Struct<{
readonly _tag: Schema.tag<"isMinProperties">
readonly minProperties: Schema.Int
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isMaxProperties">
readonly maxProperties: Schema.Int
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isPropertiesLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isPropertyNames">
readonly propertyNames: Schema.suspend<$Representation>
}>
]
>
const $ObjectsMeta: {
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<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }>, Schema.Struct<{ readonly _tag: Schema.tag<'isMaxProperties'>; readonly maxProperties: Schema.Int }>, Schema.Struct…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int; }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMaxProperties'>; …;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMaxProperties'>; read…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMaxProperties'>; readonly maxPr…;
rebuild: (ast: SchemaAST.Union<SchemaAST.Objects>) => Schema.Union<readonly [Schema.Struct<{ readonly _tag: Schema.tag<'isMinProperties'>; readonly minProperties: Schema.Int }>, Schema.Struct<{ readonly _tag: Schema.tag<'isMaxProperties'>; readonly…;
make: (input: { readonly minProperties: number; readonly _tag?: 'isMinProperties' | undefined } | { readonly maxProperties: number; readonly _tag?: 'isMaxProperties' | undefined } | { readonly minimum: number; readonly maximum: number; readonly …;
makeOption: (input: { readonly minProperties: number; readonly _tag?: 'isMinProperties' | undefined } | { readonly maxProperties: number; readonly _tag?: 'isMaxProperties' | undefined } | { readonly minimum: number; readonly maximum: number; readonly …;
makeEffect: (input: { readonly minProperties: number; readonly _tag?: 'isMinProperties' | undefined } | { readonly maxProperties: number; readonly _tag?: 'isMaxProperties' | undefined } | { readonly minimum: number; readonly maximum: number; readonly …;
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; <…;
}
Schema for
ObjectsMeta
.
$ObjectsMeta, "Objects"))
}).Bottom<unknown, unknown, unknown, unknown, Objects, Struct<{ readonly _tag: tag<"Objects">; readonly annotations: optional<decodeTo<$Record<String, Unknown>, $Record<String, Codec<PrimitiveTree, PrimitiveTree, never, never>>, never, never>>; readonly propertySignatures: $Array<...>; readonly indexSignatures: $Array<...>; readonly checks: $Array<...>; }>, ... 8 more ..., "required">.annotate(annotations: Schema.Annotations.Bottom<{
readonly _tag: "Objects";
readonly checks: readonly Check<Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlySide<{
readonly _tag: Schema.tag<"isMinProperties">;
readonly minProperties: Schema.Int;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isMaxProperties">;
readonly maxProperties: Schema.Int;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isPropertiesLengthBetween">;
readonly minimum: Schema.Int;
readonly maximum: Schema.Int;
}, "Type"> | Schema.Struct.ReadonlySide<...>>[];
readonly propertySignatures: readonly {
...;
}[];
readonly indexSignatures: readonly Schema.Struct.ReadonlySide<...>[];
readonly annotations?: {
...;
} | undefined;
}, readonly []>): Schema.Struct<...>
Annotations.Bottom<T, TypeParameters extends ReadonlyArray<Constraint>>.identifier?: string | undefinedStable identifier for this schema node.
Details
Identifiers are used by schema tooling, including JSON Schema
generation, to name references. The default formatter also uses
identifier as the expected label for type-level failures, such as
Expected UserId, got null.
identifier does not name a failed filter or refinement. If the base
type matches and a filter fails, put expected or message on the
filter/refinement instead.
identifier: "Objects" })Referenced by 1 symbols