$RepresentationType-level helper for the recursive $Representation codec.
schemas$Representation
Source effect/SchemaRepresentation.ts:153133 lines
export interface interface $RepresentationType-level helper for the recursive
$Representation
codec.
Schema for the full
Representation
union. It recursively validates
and encodes any representation node.
$Representation extends import SchemaSchema.Codec<type Representation =
| Declaration
| Reference
| Suspend
| Null
| Undefined
| Void
| Never
| Unknown
| Any
| String
| Number
| Boolean
| BigInt
| Symbol
| Literal
| UniqueSymbol
| ObjectKeyword
| Enum
| TemplateLiteral
| Arrays
| Objects
| Union
The core tagged union of all supported schema shapes.
Details
Each variant has a _tag discriminator. Switch on _tag to handle each
shape. Most variants carry optional annotations and some carry checks
for validation constraints.
Representation> {}
/**
* Schema for the full {@link Representation} union. It recursively validates
* and encodes any representation node.
*
* @category schemas
* @since 4.0.0
*/
export const const $Representation: $Representationconst $Representation: {
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
Rebuild: Codec<T, E, RD, RE>;
Type: T;
Iso: Iso;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Representation, any>) => Schema.Codec<Representation, Representation, never, never>;
annotateKey: (annotations: Schema.Annotations.Key<Representation>) => Schema.Codec<Representation, Representation, never, never>;
check: (checks_0: SchemaAST.Check<Representation>, ...checks: Array<SchemaAST.Check<Representation>>) => Schema.Codec<Representation, Representation, never, never>;
rebuild: (ast: SchemaAST.AST) => Schema.Codec<Representation, Representation, never, never>;
make: (input: unknown, options?: MakeOptions) => SchemaRepresentation.Representation;
makeOption: (input: unknown, options?: MakeOptions) => Option_.Option<SchemaRepresentation.Representation>;
makeEffect: (input: unknown, options?: MakeOptions) => Effect.Effect<SchemaRepresentation.Representation, 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 helper for the recursive
$Representation
codec.
Schema for the full
Representation
union. It recursively validates
and encodes any representation node.
$Representation: interface $RepresentationType-level helper for the recursive
$Representation
codec.
Schema for the full
Representation
union. It recursively validates
and encodes any representation node.
$Representation = import SchemaSchema.Union([
const $Null: Schema.Struct<{
readonly _tag: Schema.tag<"Null">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $Null: {
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<'Null'>; 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: 'Null'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Null'>; readonly annotations: Schema.opt…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Null'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'Null'>; readonly annotations: Schema.optional<Schema.decod…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Null'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Null'; readonly annotations?: { readonly [x: string]: unknown }…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Null'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, P…;
make: (input: { readonly _tag?: 'Null' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Null'; readonly annotations?: { readonly [x: string]: unknown } | undefined };
makeOption: (input: { readonly _tag?: 'Null' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Null'; readonly annotations?: { readonly [x: string]: unknown …;
makeEffect: (input: { readonly _tag?: 'Null' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Null'; readonly annotations?: { readonly [x: string]: unknown }…;
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
Null
representation node.
$Null,
const $Undefined: Schema.Struct<{
readonly _tag: Schema.tag<"Undefined">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $Undefined: {
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<'Undefined'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, nev…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly _tag: 'Undefined'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Undefined'>; readonly annotations: …;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Undefined'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'Undefined'>; readonly annotations: Schema.optional<Sc…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Undefined'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Undefined'; readonly annotations?: { readonly [x: string]:…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Undefined'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTr…;
make: (input: { readonly _tag?: 'Undefined' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Undefined'; readonly annotations?: { readonly [x: string]: unknown } | u…;
makeOption: (input: { readonly _tag?: 'Undefined' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Undefined'; readonly annotations?: { readonly [x: string]…;
makeEffect: (input: { readonly _tag?: 'Undefined' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Undefined'; readonly annotations?: { readonly [x: string]:…;
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
Undefined
representation node.
$Undefined,
const $Void: Schema.Struct<{
readonly _tag: Schema.tag<"Void">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $Void: {
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<'Void'>; 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: 'Void'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Void'>; readonly annotations: Schema.opt…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Void'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'Void'>; readonly annotations: Schema.optional<Schema.decod…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Void'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Void'; readonly annotations?: { readonly [x: string]: unknown }…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Void'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, P…;
make: (input: { readonly _tag?: 'Void' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Void'; readonly annotations?: { readonly [x: string]: unknown } | undefined };
makeOption: (input: { readonly _tag?: 'Void' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Void'; readonly annotations?: { readonly [x: string]: unknown …;
makeEffect: (input: { readonly _tag?: 'Void' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Void'; readonly annotations?: { readonly [x: string]: unknown }…;
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
Void
representation node.
$Void,
const $Never: Schema.Struct<{
readonly _tag: Schema.tag<"Never">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $Never: {
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<'Never'>; 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: 'Never'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Never'>; readonly annotations: Schema.o…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Never'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'Never'>; readonly annotations: Schema.optional<Schema.dec…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Never'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Never'; readonly annotations?: { readonly [x: string]: unknown…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Never'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, …;
make: (input: { readonly _tag?: 'Never' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Never'; readonly annotations?: { readonly [x: string]: unknown } | undefined…;
makeOption: (input: { readonly _tag?: 'Never' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Never'; readonly annotations?: { readonly [x: string]: unknow…;
makeEffect: (input: { readonly _tag?: 'Never' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Never'; readonly annotations?: { readonly [x: string]: unknown…;
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
Never
representation node.
$Never,
const $Unknown: Schema.Struct<{
readonly _tag: Schema.tag<"Unknown">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $Unknown: {
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<'Unknown'>; 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: 'Unknown'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Unknown'>; readonly annotations: Sche…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Unknown'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'Unknown'>; readonly annotations: Schema.optional<Schema…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Unknown'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Unknown'; readonly annotations?: { readonly [x: string]: unk…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Unknown'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree…;
make: (input: { readonly _tag?: 'Unknown' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Unknown'; readonly annotations?: { readonly [x: string]: unknown } | undef…;
makeOption: (input: { readonly _tag?: 'Unknown' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Unknown'; readonly annotations?: { readonly [x: string]: un…;
makeEffect: (input: { readonly _tag?: 'Unknown' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Unknown'; readonly annotations?: { readonly [x: string]: unk…;
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
Unknown
representation node.
$Unknown,
const $Any: Schema.Struct<{
readonly _tag: Schema.tag<"Any">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $Any: {
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<'Any'>; 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: 'Any'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Any'>; readonly annotations: Schema.optio…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Any'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'Any'>; readonly annotations: Schema.optional<Schema.decodeT…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Any'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Any'; readonly annotations?: { readonly [x: string]: unknown } |…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Any'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, Pr…;
make: (input: { readonly _tag?: 'Any' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Any'; readonly annotations?: { readonly [x: string]: unknown } | undefined };
makeOption: (input: { readonly _tag?: 'Any' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Any'; readonly annotations?: { readonly [x: string]: unknown } …;
makeEffect: (input: { readonly _tag?: 'Any' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Any'; readonly annotations?: { readonly [x: string]: unknown } |…;
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
Any
representation node.
$Any,
const $String: anyconst $String: {
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<'String'>; 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: 'String'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp; }, 'Type'> | Schema.Struct.Re…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'String'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.Readon…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'String'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.ReadonlySide<{ r…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'String'>; 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 _tag?: 'String' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined; readonly contentMediaType?: string | undefined; readonly contentSchema?: unknown…;
makeOption: (input: { readonly checks: ReadonlyArray<unknown>; readonly _tag?: 'String' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined; readonly contentMediaType?: string | undefined; readonly contentSchema?: unknown…;
makeEffect: (input: { readonly checks: ReadonlyArray<unknown>; readonly _tag?: 'String' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined; readonly contentMediaType?: string | undefined; readonly contentSchema?: unknown…;
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
String
representation node.
$String,
const $Number: anyconst $Number: {
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<'Number'>; 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: 'Number'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'>; }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'i…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Number'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'> }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMul…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Number'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'> }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMultipleOf'>;…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Number'>; 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 _tag?: 'Number' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Number'; readonly checks: Readonly…;
makeOption: (input: { readonly checks: ReadonlyArray<unknown>; readonly _tag?: 'Number' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Number'; readonly c…;
makeEffect: (input: { readonly checks: ReadonlyArray<unknown>; readonly _tag?: 'Number' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Number'; readonly ch…;
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
Number
representation node.
$Number,
const $Boolean: Schema.Struct<{
readonly _tag: Schema.tag<"Boolean">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $Boolean: {
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<'Boolean'>; 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: 'Boolean'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Boolean'>; readonly annotations: Sche…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Boolean'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'Boolean'>; readonly annotations: Schema.optional<Schema…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Boolean'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Boolean'; readonly annotations?: { readonly [x: string]: unk…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Boolean'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree…;
make: (input: { readonly _tag?: 'Boolean' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Boolean'; readonly annotations?: { readonly [x: string]: unknown } | undef…;
makeOption: (input: { readonly _tag?: 'Boolean' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Boolean'; readonly annotations?: { readonly [x: string]: un…;
makeEffect: (input: { readonly _tag?: 'Boolean' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Boolean'; readonly annotations?: { readonly [x: string]: unk…;
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
Boolean
representation node.
$Boolean,
const $BigInt: Schema.Struct<{
readonly _tag: Schema.tag<"BigInt">
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 checks: Schema.$Array<
Schema.Codec<
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isGreaterThanBigInt">
readonly exclusiveMinimum: Schema.BigInt
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isGreaterThanOrEqualToBigInt">
readonly minimum: Schema.BigInt
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLessThanBigInt">
readonly exclusiveMaximum: Schema.BigInt
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLessThanOrEqualToBigInt">
readonly maximum: Schema.BigInt
},
"Type"
>
| {
readonly _tag: "isBetweenBigInt"
readonly minimum: bigint
readonly maximum: bigint
readonly exclusiveMinimum?:
| boolean
| undefined
readonly exclusiveMaximum?:
| boolean
| undefined
}
>,
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isGreaterThanBigInt">
readonly exclusiveMinimum: Schema.BigInt
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isGreaterThanOrEqualToBigInt">
readonly minimum: Schema.BigInt
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLessThanBigInt">
readonly exclusiveMaximum: Schema.BigInt
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLessThanOrEqualToBigInt">
readonly maximum: Schema.BigInt
},
"Type"
>
| {
readonly _tag: "isBetweenBigInt"
readonly minimum: bigint
readonly maximum: bigint
readonly exclusiveMinimum?:
| boolean
| undefined
readonly exclusiveMaximum?:
| boolean
| undefined
}
>,
never,
never
>
>
}>
const $BigInt: {
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<'BigInt'>; 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: 'BigInt'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanBigInt'>; readonly exclusiveMinimum: Schema.BigInt; }, 'Type'> | S…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'BigInt'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanBigInt'>; readonly exclusiveMinimum: Schema.BigInt }, 'Type'> | Schem…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'BigInt'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanBigInt'>; readonly exclusiveMinimum: Schema.BigInt }, 'Type'> | Schema.Struct.R…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'BigInt'>; 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 _tag?: 'BigInt' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'BigInt'; readonly checks: Readonly…;
makeOption: (input: { readonly checks: ReadonlyArray<unknown>; readonly _tag?: 'BigInt' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'BigInt'; readonly c…;
makeEffect: (input: { readonly checks: ReadonlyArray<unknown>; readonly _tag?: 'BigInt' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'BigInt'; readonly ch…;
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
BigInt
representation node.
When to use
Use to encode, decode, or validate serialized BigInt representation nodes,
not application bigint values.
Details
Accepts representation nodes with _tag: "BigInt", optional annotations,
and bigint-specific validation metadata in checks.
$BigInt,
const $Symbol: Schema.Struct<{
readonly _tag: Schema.tag<"Symbol">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $Symbol: {
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<'Symbol'>; 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: 'Symbol'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Symbol'>; readonly annotations: Schema…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Symbol'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'Symbol'>; readonly annotations: Schema.optional<Schema.d…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Symbol'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Symbol'; readonly annotations?: { readonly [x: string]: unkno…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Symbol'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree,…;
make: (input: { readonly _tag?: 'Symbol' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Symbol'; readonly annotations?: { readonly [x: string]: unknown } | undefin…;
makeOption: (input: { readonly _tag?: 'Symbol' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Symbol'; readonly annotations?: { readonly [x: string]: unkn…;
makeEffect: (input: { readonly _tag?: 'Symbol' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Symbol'; readonly annotations?: { readonly [x: string]: unkno…;
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
Symbol
representation node.
$Symbol,
const $Literal: Schema.Struct<{
readonly _tag: Schema.tag<"Literal">
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 literal: Schema.Union<
readonly [
Schema.String,
Schema.Finite,
Schema.Boolean,
Schema.BigInt
]
>
}>
const $Literal: {
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<'Literal'>; 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: 'Literal'; readonly literal: string | number | bigint | boolean; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Literal'; readonly literal: string | number | bigint | boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'L…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Literal'; readonly literal: string | number | bigint | boolean; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Litera…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Literal'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree…;
make: (input: { readonly literal: string | number | bigint | boolean; readonly _tag?: 'Literal' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Literal'; readonly l…;
makeOption: (input: { readonly literal: string | number | bigint | boolean; readonly _tag?: 'Literal' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'Liter…;
makeEffect: (input: { readonly literal: string | number | bigint | boolean; readonly _tag?: 'Literal' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'Litera…;
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
Literal
representation node.
$Literal,
const $UniqueSymbol: Schema.Struct<{
readonly _tag: Schema.tag<"UniqueSymbol">
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 symbol: Schema.Symbol
}>
const $UniqueSymbol: {
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<'UniqueSymbol'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, …;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly symbol: symbol; readonly _tag: 'UniqueSymbol'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'UniqueS…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly symbol: symbol; readonly _tag: 'UniqueSymbol'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'UniqueSymbol'>; readonly …;
check: (checks_0: SchemaAST.Check<{ readonly symbol: symbol; readonly _tag: 'UniqueSymbol'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly symbol: symbol; readonly _tag: 'Uniqu…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'UniqueSymbol'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<Primitiv…;
make: (input: { readonly symbol: symbol; readonly _tag?: 'UniqueSymbol' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly symbol: symbol; readonly _tag: 'UniqueSymbol'; read…;
makeOption: (input: { readonly symbol: symbol; readonly _tag?: 'UniqueSymbol' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly symbol: symbol; readonly _tag: 'Uniq…;
makeEffect: (input: { readonly symbol: symbol; readonly _tag?: 'UniqueSymbol' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly symbol: symbol; readonly _tag: 'Uniqu…;
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
UniqueSymbol
representation node.
$UniqueSymbol,
const $ObjectKeyword: Schema.Struct<{
readonly _tag: Schema.tag<"ObjectKeyword">
readonly annotations: Schema.optional<
Schema.decodeTo<
Schema.$Record<
Schema.String,
Schema.Unknown
>,
Schema.$Record<
Schema.String,
Schema.Codec<
PrimitiveTree,
PrimitiveTree,
never,
never
>
>,
never,
never
>
>
}>
const $ObjectKeyword: {
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<'ObjectKeyword'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never,…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly _tag: 'ObjectKeyword'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'ObjectKeyword'>; readonly annot…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'ObjectKeyword'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'ObjectKeyword'>; readonly annotations: Schema.opt…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'ObjectKeyword'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'ObjectKeyword'; readonly annotations?: { readonly [x: …;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'ObjectKeyword'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<Primiti…;
make: (input: { readonly _tag?: 'ObjectKeyword' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'ObjectKeyword'; readonly annotations?: { readonly [x: string]: unkno…;
makeOption: (input: { readonly _tag?: 'ObjectKeyword' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'ObjectKeyword'; readonly annotations?: { readonly [x:…;
makeEffect: (input: { readonly _tag?: 'ObjectKeyword' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'ObjectKeyword'; readonly annotations?: { readonly [x: …;
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
ObjectKeyword
representation node.
$ObjectKeyword,
const $Enum: Schema.Struct<{
readonly _tag: Schema.tag<"Enum">
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 enums: Schema.$Array<
Schema.Tuple<
readonly [
Schema.String,
Schema.Union<
readonly [Schema.String, Schema.Number]
>
]
>
>
}>
const $Enum: {
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<'Enum'>; 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: 'Enum'; readonly enums: ReadonlyArray<readonly [string, string | number]>; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ …;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Enum'; readonly enums: ReadonlyArray<readonly [string, string | number]>; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Sch…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Enum'; readonly enums: ReadonlyArray<readonly [string, string | number]>; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _ta…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Enum'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, P…;
make: (input: { readonly enums: ReadonlyArray<readonly [string, string | number]>; readonly _tag?: 'Enum' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Enum'; rea…;
makeOption: (input: { readonly enums: ReadonlyArray<readonly [string, string | number]>; readonly _tag?: 'Enum' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _t…;
makeEffect: (input: { readonly enums: ReadonlyArray<readonly [string, string | number]>; readonly _tag?: 'Enum' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _ta…;
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
Enum
representation node.
$Enum,
const $TemplateLiteral: Schema.Struct<{
readonly _tag: Schema.tag<"TemplateLiteral">
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 parts: Schema.$Array<
Schema.suspend<$Representation>
>
}>
const $TemplateLiteral: {
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<'TemplateLiteral'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, neve…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly _tag: 'TemplateLiteral'; readonly parts: ReadonlyArray<Representation>; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ readonly …;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'TemplateLiteral'; readonly parts: ReadonlyArray<Representation>; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ readonly _tag: Schema.tag<'…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'TemplateLiteral'; readonly parts: ReadonlyArray<Representation>; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check<{ readonly _tag: 'Templ…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'TemplateLiteral'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<Primi…;
make: (input: { readonly parts: ReadonlyArray<unknown>; readonly _tag?: 'TemplateLiteral' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'TemplateLiteral'; readonly…;
makeOption: (input: { readonly parts: ReadonlyArray<unknown>; readonly _tag?: 'TemplateLiteral' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ readonly _tag: 'TemplateLit…;
makeEffect: (input: { readonly parts: ReadonlyArray<unknown>; readonly _tag?: 'TemplateLiteral' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ readonly _tag: 'TemplateLite…;
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
TemplateLiteral
representation node.
$TemplateLiteral,
const $Arrays: Schema.Struct<{
readonly _tag: Schema.tag<"Arrays">
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 elements: Schema.$Array<
Schema.Struct<{
readonly isOptional: Schema.Boolean
readonly type: Schema.suspend<$Representation>
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 rest: Schema.$Array<
Schema.suspend<$Representation>
>
readonly checks: Schema.$Array<
Schema.Codec<
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMinLength">
readonly minLength: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMaxLength">
readonly maxLength: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isUnique">
},
"Type"
>
>,
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMinLength">
readonly minLength: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isMaxLength">
readonly maxLength: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isUnique">
},
"Type"
>
>,
never,
never
>
>
}>
const $Arrays: {
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<'Arrays'>; 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: 'Arrays'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema.Int; }, 'Type'> | Schema.Struct.Reado…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Arrays'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema.Int }, 'Type'> | Schema.Struct.ReadonlyS…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Arrays'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMinLength'>; readonly minLength: Schema.Int }, 'Type'> | Schema.Struct.ReadonlySide<{ read…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Arrays'>; 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 elements: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly annotations?: { readonly [x: string]: unknown } | undefined }>; readonly rest: ReadonlyArr…;
makeOption: (input: { readonly checks: ReadonlyArray<unknown>; readonly elements: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly annotations?: { readonly [x: string]: unknown } | undefined }>; readonly rest: ReadonlyArr…;
makeEffect: (input: { readonly checks: ReadonlyArray<unknown>; readonly elements: ReadonlyArray<{ readonly isOptional: boolean; readonly type: unknown; readonly annotations?: { readonly [x: string]: unknown } | undefined }>; readonly rest: ReadonlyArr…;
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
Arrays
representation node.
$Arrays,
const $Objects: anyconst $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,
const $Union: Schema.Struct<{
readonly _tag: Schema.tag<"Union">
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 types: Schema.$Array<
Schema.suspend<$Representation>
>
readonly mode: Schema.Literals<
readonly ["anyOf", "oneOf"]
>
}>
const $Union: {
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<'Union'>; 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: 'Union'; readonly types: ReadonlyArray<Representation>; readonly mode: 'anyOf' | 'oneOf'; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => S…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Union'; readonly types: ReadonlyArray<Representation>; readonly mode: 'anyOf' | 'oneOf'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>) => Schema.Struct<{ rea…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Union'; readonly types: ReadonlyArray<Representation>; readonly mode: 'anyOf' | 'oneOf'; readonly annotations?: { readonly [x: string]: unknown } | undefined }>, ...checks: Array<SchemaAST.Check…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Union'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, …;
make: (input: { readonly types: ReadonlyArray<unknown>; readonly mode: 'anyOf' | 'oneOf'; readonly _tag?: 'Union' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => { readonly _tag: 'Un…;
makeOption: (input: { readonly types: ReadonlyArray<unknown>; readonly mode: 'anyOf' | 'oneOf'; readonly _tag?: 'Union' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Option_.Option<{ rea…;
makeEffect: (input: { readonly types: ReadonlyArray<unknown>; readonly mode: 'anyOf' | 'oneOf'; readonly _tag?: 'Union' | undefined; readonly annotations?: { readonly [x: string]: unknown } | undefined }, options?: MakeOptions) => Effect.Effect<{ read…;
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
Union
representation node.
$Union,
const $Reference: Schema.Struct<{
readonly _tag: Schema.tag<"Reference">
readonly $ref: Schema.String
}>
const $Reference: {
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<'Reference'>; readonly $ref: Schema.String }) => 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.ReadonlySide<{ readonly _tag: Schema.tag<'Reference'>; readonly $ref: Schema.String; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'Reference'>; readonly $ref: …;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Reference'>; readonly $ref: Schema.String }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'Reference'>; readonly $ref: Schema.String }>;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Reference'>; readonly $ref: Schema.String }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'Reference'>;…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Reference'>; readonly $ref: Schema.String }>;
make: (input: { readonly $ref: string; readonly _tag?: 'Reference' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'Reference'>; readonly $ref: String }, 'Type'>;
makeOption: (input: { readonly $ref: string; readonly _tag?: 'Reference' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'Reference'>; readonly $ref: String }, 'Type'>>;
makeEffect: (input: { readonly $ref: string; readonly _tag?: 'Reference' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'Reference'>; readonly $ref: String }, 'Type'>, 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 the
Reference
representation node.
$Reference,
const $Declaration: anyconst $Declaration: {
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<'Declaration'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, n…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly typeParameters: ReadonlyArray<Representation>; readonly _tag: 'Declaration'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'>; }, …;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly typeParameters: ReadonlyArray<Representation>; readonly _tag: 'Declaration'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'> }, 'Typ…;
check: (checks_0: SchemaAST.Check<{ readonly typeParameters: ReadonlyArray<Representation>; readonly _tag: 'Declaration'; readonly checks: ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'> }, 'Type'> | Sche…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Declaration'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<Primitive…;
make: (input: { readonly typeParameters: ReadonlyArray<unknown>; readonly checks: ReadonlyArray<unknown>; readonly encodedSchema: unknown; readonly _tag?: 'Declaration' | undefined; readonly annotations?: { readonly [x: string]: unknown } | unde…;
makeOption: (input: { readonly typeParameters: ReadonlyArray<unknown>; readonly checks: ReadonlyArray<unknown>; readonly encodedSchema: unknown; readonly _tag?: 'Declaration' | undefined; readonly annotations?: { readonly [x: string]: unknown } | unde…;
makeEffect: (input: { readonly typeParameters: ReadonlyArray<unknown>; readonly checks: ReadonlyArray<unknown>; readonly encodedSchema: unknown; readonly _tag?: 'Declaration' | undefined; readonly annotations?: { readonly [x: string]: unknown } | unde…;
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
Declaration
representation node.
$Declaration,
const $Suspend: anyconst $Suspend: {
Type: Struct.Type<Fields>;
Encoded: Struct.Encoded<Fields>;
DecodingServices: Struct.DecodingServices<Fields>;
EncodingServices: Struct.EncodingServices<Fields>;
Iso: Struct.Iso<Fields>;
fields: Fields;
mapFields: <To>(f: (fields: { readonly _tag: Schema.tag<'Suspend'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree, PrimitiveTree, never, n…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly _tag: 'Suspend'; readonly checks: readonly []; readonly thunk: Representation; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, readonly []>) => Schema.Struct<{ re…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'Suspend'; readonly checks: readonly []; readonly thunk: Representation; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }>) => Schema.Struct<{ readonly _tag: Sch…;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'Suspend'; readonly checks: readonly []; readonly thunk: Representation; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }>, ...checks: Array<SchemaAST.Check<{ readonly _ta…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'Suspend'>; readonly annotations: Schema.optional<Schema.decodeTo<Schema.$Record<Schema.String, Schema.Unknown>, Schema.$Record<Schema.String, Schema.Codec<PrimitiveTree…;
make: (input: { readonly checks: readonly []; readonly thunk: unknown; readonly _tag?: 'Suspend' | undefined; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, options?: Schema.MakeOptions) => { readonly _tag: 'Suspend'; …;
makeOption: (input: { readonly checks: readonly []; readonly thunk: unknown; readonly _tag?: 'Suspend' | undefined; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, options?: Schema.MakeOptions) => Option.Option<{ readonly _ta…;
makeEffect: (input: { readonly checks: readonly []; readonly thunk: unknown; readonly _tag?: 'Suspend' | undefined; readonly annotations?: { readonly [x: string]: unknown; } | undefined; }, options?: Schema.MakeOptions) => Effect<{ readonly _tag: 'Sus…;
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
Suspend
representation node.
$Suspend
]).annotate({ identifier: stringidentifier: "Schema" })Referenced by 2 symbols