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, PrimitiveTree, never, never>
>,
never,
never
>
>
readonly checks: Schema.$Array<
Schema.Codec<
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isStringFinite">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isStringBigInt">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isStringSymbol">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isTrimmed">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isUUID">
readonly regExp: Schema.RegExp
readonly version: Schema.UndefinedOr<
Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>
>
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isGUID">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isULID">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isBase64">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isBase64Url">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isStartsWith">
readonly startsWith: Schema.String
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isEndsWith">
readonly endsWith: Schema.String
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isIncludes">
readonly includes: Schema.String
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isUppercased">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLowercased">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isCapitalized">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isUncapitalized">
readonly regExp: Schema.RegExp
},
"Type"
>
| 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<"isPattern">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
},
"Type"
>
>,
Check<
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isStringFinite">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isStringBigInt">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isStringSymbol">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isTrimmed">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isUUID">
readonly regExp: Schema.RegExp
readonly version: Schema.UndefinedOr<
Schema.Literals<readonly [1, 2, 3, 4, 5, 6, 7, 8]>
>
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isGUID">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isULID">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isBase64">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isBase64Url">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isStartsWith">
readonly startsWith: Schema.String
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isEndsWith">
readonly endsWith: Schema.String
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isIncludes">
readonly includes: Schema.String
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isUppercased">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLowercased">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isCapitalized">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isUncapitalized">
readonly regExp: Schema.RegExp
},
"Type"
>
| 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<"isPattern">
readonly regExp: Schema.RegExp
},
"Type"
>
| Schema.Struct.ReadonlySide<
{
readonly _tag: Schema.tag<"isLengthBetween">
readonly minimum: Schema.Int
readonly maximum: Schema.Int
},
"Type"
>
>,
never,
never
>
>
readonly contentMediaType: Schema.optional<Schema.String>
readonly contentSchema: Schema.optional<Schema.suspend<$Representation>>
}>Schema for the String representation node.
schemasString
Source effect/SchemaRepresentation.ts:10377 lines
export const 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 = import SchemaSchema.Struct({
_tag: Schema.tag<"String">(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<'String', readonly []>) => Schema.withConstructorDefault<Schema.Literal<'String'>>;
annotateKey: (annotations: Schema.Annotations.Key<'String'>) => Schema.withConstructorDefault<Schema.Literal<'String'>>;
check: (checks_0: SchemaAST.Check<'String'>, ...checks: Array<SchemaAST.Check<'String'>>) => Schema.withConstructorDefault<Schema.Literal<'String'>>;
rebuild: (ast: SchemaAST.Literal) => Schema.withConstructorDefault<Schema.Literal<'String'>>;
make: (input: 'String', options?: MakeOptions) => 'String';
makeOption: (input: 'String', options?: MakeOptions) => Option_.Option<'String'>;
makeEffect: (input: 'String', options?: MakeOptions) => Effect.Effect<'String', SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
import SchemaSchema.tag("String"),
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),
checks: any(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<'isStringFinite'>; readonly regExp: Schema.RegExp; }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isSt…;
annotateKey: (annotations: Schema.Annotations.Key<ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isString…;
check: (checks_0: SchemaAST.Check<ReadonlyArray<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; …;
rebuild: (ast: SchemaAST.Arrays) => Schema.$Array<Schema.Codec<Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStr…;
make: (input: ReadonlyArray<unknown>, options?: MakeOptions) => ReadonlyArray<SchemaRepresentation.Check<Struct.ReadonlySide<{ readonly _tag: tag<'isStringFinite'>; readonly regExp: RegExp }, 'Type'> | Struct.ReadonlySide<{ readonly _tag: tag<'i…;
makeOption: (input: ReadonlyArray<unknown>, options?: MakeOptions) => Option_.Option<ReadonlyArray<SchemaRepresentation.Check<Struct.ReadonlySide<{ readonly _tag: tag<'isStringFinite'>; readonly regExp: RegExp }, 'Type'> | Struct.ReadonlySide<{ readon…;
makeEffect: (input: ReadonlyArray<unknown>, options?: MakeOptions) => Effect.Effect<ReadonlyArray<SchemaRepresentation.Check<Struct.ReadonlySide<{ readonly _tag: tag<'isStringFinite'>; readonly regExp: RegExp }, 'Type'> | Struct.ReadonlySide<{ readonl…;
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 $StringMeta: anyconst $StringMeta: {
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<'isStringFinite'>; readonly regExp: Schema.RegExp }>, Schema.Struct<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Schema.RegExp }>, Schema.Struct<{ readonl…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp; }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readon…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly r…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regExp: Sch…;
rebuild: (ast: SchemaAST.Union<SchemaAST.Objects>) => Schema.Union<readonly [Schema.Struct<{ readonly _tag: Schema.tag<'isStringFinite'>; readonly regExp: Schema.RegExp }>, Schema.Struct<{ readonly _tag: Schema.tag<'isStringBigInt'>; readonly regEx…;
make: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'is…;
makeOption: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'is…;
makeEffect: (input: { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringFinite' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'isStringBigInt' | undefined } | { readonly regExp: globalThis.RegExp; readonly _tag?: 'is…;
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
StringMeta
.
$StringMeta, "String")),
contentMediaType: Schema.optional<Schema.String>(property) contentMediaType: {
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<string | undefined, readonly []>) => Schema.optional<Schema.String>;
annotateKey: (annotations: Schema.Annotations.Key<string | undefined>) => Schema.optional<Schema.String>;
check: (checks_0: SchemaAST.Check<string | undefined>, ...checks: Array<SchemaAST.Check<string | undefined>>) => Schema.optional<Schema.String>;
rebuild: (ast: SchemaAST.Union<SchemaAST.Undefined | SchemaAST.String>) => Schema.optional<Schema.String>;
make: (input: string | undefined, options?: MakeOptions) => string | undefined;
makeOption: (input: string | undefined, options?: MakeOptions) => Option_.Option<string | undefined>;
makeEffect: (input: string | undefined, options?: MakeOptions) => Effect.Effect<string | 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(import SchemaSchema.String),
contentSchema: Schema.optional<
Schema.suspend<$Representation>
>
(property) contentSchema: {
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<Representation | undefined, readonly []>) => Schema.optional<Schema.suspend<$Representation>>;
annotateKey: (annotations: Schema.Annotations.Key<Representation | undefined>) => Schema.optional<Schema.suspend<$Representation>>;
check: (checks_0: SchemaAST.Check<Representation | undefined>, ...checks: Array<SchemaAST.Check<Representation | undefined>>) => Schema.optional<Schema.suspend<$Representation>>;
rebuild: (ast: SchemaAST.Union<SchemaAST.Undefined | SchemaAST.Suspend>) => Schema.optional<Schema.suspend<$Representation>>;
make: (input: unknown, options?: MakeOptions) => SchemaRepresentation.Representation | undefined;
makeOption: (input: unknown, options?: MakeOptions) => Option_.Option<SchemaRepresentation.Representation | undefined>;
makeEffect: (input: unknown, options?: MakeOptions) => Effect.Effect<SchemaRepresentation.Representation | 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 Representation$ref: Schema.suspend<$Representation>const Representation$ref: {
Type: S["Type"];
Encoded: S["Encoded"];
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: S["Iso"];
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Representation, any>) => Schema.suspend<$Representation>;
annotateKey: (annotations: Schema.Annotations.Key<Representation>) => Schema.suspend<$Representation>;
check: (checks_0: SchemaAST.Check<Representation>, ...checks: Array<SchemaAST.Check<Representation>>) => Schema.suspend<$Representation>;
rebuild: (ast: SchemaAST.Suspend) => Schema.suspend<$Representation>;
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; <…;
}
identifier: stringidentifier: "String" })Referenced by 1 symbols