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: 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 = import SchemaSchema.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.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.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(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(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(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"))
}).annotate({ identifier: stringidentifier: "Objects" })Referenced by 1 symbols