Schema.Union<
readonly [
Schema.Struct<{ readonly _tag: Schema.tag<"isDateValid"> }>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanDate">
readonly exclusiveMinimum: Schema.Date
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanOrEqualToDate">
readonly minimum: Schema.Date
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanDate">
readonly exclusiveMaximum: Schema.Date
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanOrEqualToDate">
readonly maximum: Schema.Date
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isBetweenDate">
readonly minimum: Schema.Date
readonly maximum: Schema.Date
readonly exclusiveMinimum: Schema.optional<Schema.Boolean>
readonly exclusiveMaximum: Schema.optional<Schema.Boolean>
}>
]
>Schema for DateMeta.
schemasDateMeta
Source effect/SchemaRepresentation.ts:14508 lines
export const const $DateMeta: Schema.Union<
readonly [
Schema.Struct<{
readonly _tag: Schema.tag<"isDateValid">
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanDate">
readonly exclusiveMinimum: Schema.Date
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanOrEqualToDate">
readonly minimum: Schema.Date
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanDate">
readonly exclusiveMaximum: Schema.Date
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanOrEqualToDate">
readonly maximum: Schema.Date
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isBetweenDate">
readonly minimum: Schema.Date
readonly maximum: Schema.Date
readonly exclusiveMinimum: Schema.optional<Schema.Boolean>
readonly exclusiveMaximum: Schema.optional<Schema.Boolean>
}>
]
>
const $DateMeta: {
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<'isDateValid'> }>, Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date }>, Schema.Struct<{ readonly _tag: Schema.tag<'isGr…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'>; }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'> }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date }, …;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'> }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date }, 'Type'> | …;
rebuild: (ast: SchemaAST.Union<SchemaAST.Objects>) => Schema.Union<readonly [Schema.Struct<{ readonly _tag: Schema.tag<'isDateValid'> }>, Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date }>, Sch…;
make: (input: { readonly _tag?: 'isDateValid' | undefined } | { readonly exclusiveMinimum: globalThis.Date; readonly _tag?: 'isGreaterThanDate' | undefined } | { readonly minimum: globalThis.Date; readonly _tag?: 'isGreaterThanOrEqualToDate' | u…;
makeOption: (input: { readonly _tag?: 'isDateValid' | undefined } | { readonly exclusiveMinimum: globalThis.Date; readonly _tag?: 'isGreaterThanDate' | undefined } | { readonly minimum: globalThis.Date; readonly _tag?: 'isGreaterThanOrEqualToDate' | u…;
makeEffect: (input: { readonly _tag?: 'isDateValid' | undefined } | { readonly exclusiveMinimum: globalThis.Date; readonly _tag?: 'isGreaterThanDate' | undefined } | { readonly minimum: globalThis.Date; readonly _tag?: 'isGreaterThanOrEqualToDate' | u…;
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
DateMeta
.
$DateMeta = import SchemaSchema.function Union<
Members extends ReadonlyArray<Constraint>
>(
members: Members,
options?: { mode?: "anyOf" | "oneOf" }
): Union<Members>
Creates a union schema from an array of member schemas. Members are tested in
order; the first match is returned.
Details
Optionally, specify mode:
"anyOf" (default) — matches if any member matches."oneOf" — matches if exactly one member matches.
Example (Defining a string or number union)
import { Schema } from "effect"
const schema = Schema.Union([Schema.String, Schema.Number])
Schema.decodeUnknownSync(schema)("hello") // "hello"
Schema.decodeUnknownSync(schema)(42) // 42
Union([
const $IsDateValid: Schema.Struct<{
readonly _tag: Schema.tag<"isDateValid">
}>
const $IsDateValid: {
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<'isDateValid'> }) => 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<'isDateValid'>; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isDateValid'>; }>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'> }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isDateValid'> }>;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'> }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isDateValid'> }, 'Type'>>>) => Schema.St…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isDateValid'> }>;
make: (input: { readonly _tag?: 'isDateValid' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isDateValid'> }, 'Type'>;
makeOption: (input: { readonly _tag?: 'isDateValid' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isDateValid'> }, 'Type'>>;
makeEffect: (input: { readonly _tag?: 'isDateValid' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isDateValid'> }, '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; <…;
}
const $IsGreaterThanDate: Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanDate">
readonly exclusiveMinimum: Schema.Date
}>
const $IsGreaterThanDate: {
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<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Re…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterT…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readon…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Schema.Date }>;
make: (input: { readonly exclusiveMinimum: globalThis.Date; readonly _tag?: 'isGreaterThanDate' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Date }, 'Type'>;
makeOption: (input: { readonly exclusiveMinimum: globalThis.Date; readonly _tag?: 'isGreaterThanDate' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Dat…;
makeEffect: (input: { readonly exclusiveMinimum: globalThis.Date; readonly _tag?: 'isGreaterThanDate' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanDate'>; readonly exclusiveMinimum: Date…;
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; <…;
}
const $IsGreaterThanOrEqualToDate: Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanOrEqualToDate">
readonly minimum: Schema.Date
}>
const $IsGreaterThanOrEqualToDate: {
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<'isGreaterThanOrEqualToDate'>; readonly minimum: Schema.Date }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Re…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualToDate'>; readonly minimum: Schema.Date; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterT…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualToDate'>; readonly minimum: Schema.Date }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualToDate'…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualToDate'>; readonly minimum: Schema.Date }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualToDate'>; readonly minimum: Schema.Date }>;
make: (input: { readonly minimum: globalThis.Date; readonly _tag?: 'isGreaterThanOrEqualToDate' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanOrEqualToDate'>; readonly minimum: Date }, 'Type'>;
makeOption: (input: { readonly minimum: globalThis.Date; readonly _tag?: 'isGreaterThanOrEqualToDate' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanOrEqualToDate'>; readonly minimum: Dat…;
makeEffect: (input: { readonly minimum: globalThis.Date; readonly _tag?: 'isGreaterThanOrEqualToDate' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanOrEqualToDate'>; readonly minimum: Date…;
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; <…;
}
const $IsLessThanDate: Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanDate">
readonly exclusiveMaximum: Schema.Date
}>
const $IsLessThanDate: {
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<'isLessThanDate'>; readonly exclusiveMaximum: Schema.Date }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Reado…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanDate'>; readonly exclusiveMaximum: Schema.Date; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanDat…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanDate'>; readonly exclusiveMaximum: Schema.Date }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanDate'>; readonly exc…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanDate'>; readonly exclusiveMaximum: Schema.Date }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.ta…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanDate'>; readonly exclusiveMaximum: Schema.Date }>;
make: (input: { readonly exclusiveMaximum: globalThis.Date; readonly _tag?: 'isLessThanDate' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanDate'>; readonly exclusiveMaximum: Date }, 'Type'>;
makeOption: (input: { readonly exclusiveMaximum: globalThis.Date; readonly _tag?: 'isLessThanDate' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanDate'>; readonly exclusiveMaximum: Date }, '…;
makeEffect: (input: { readonly exclusiveMaximum: globalThis.Date; readonly _tag?: 'isLessThanDate' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanDate'>; readonly exclusiveMaximum: Date }, 'T…;
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; <…;
}
const $IsLessThanOrEqualToDate: Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanOrEqualToDate">
readonly maximum: Schema.Date
}>
const $IsLessThanOrEqualToDate: {
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<'isLessThanOrEqualToDate'>; readonly maximum: Schema.Date }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Reado…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanOrEqualToDate'>; readonly maximum: Schema.Date; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanOrE…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanOrEqualToDate'>; readonly maximum: Schema.Date }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanOrEqualToDate'>; rea…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanOrEqualToDate'>; readonly maximum: Schema.Date }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.ta…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanOrEqualToDate'>; readonly maximum: Schema.Date }>;
make: (input: { readonly maximum: globalThis.Date; readonly _tag?: 'isLessThanOrEqualToDate' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanOrEqualToDate'>; readonly maximum: Date }, 'Type'>;
makeOption: (input: { readonly maximum: globalThis.Date; readonly _tag?: 'isLessThanOrEqualToDate' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanOrEqualToDate'>; readonly maximum: Date }, '…;
makeEffect: (input: { readonly maximum: globalThis.Date; readonly _tag?: 'isLessThanOrEqualToDate' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanOrEqualToDate'>; readonly maximum: Date }, 'T…;
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; <…;
}
const $IsBetweenDate: Schema.Struct<{
readonly _tag: Schema.tag<"isBetweenDate">
readonly minimum: Schema.Date
readonly maximum: Schema.Date
readonly exclusiveMinimum: Schema.optional<Schema.Boolean>
readonly exclusiveMaximum: Schema.optional<Schema.Boolean>
}>
const $IsBetweenDate: {
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<'isBetweenDate'>; readonly minimum: Schema.Date; readonly maximum: Schema.Date; readonly exclusiveMinimum: Schema.optional<Schema.Boolean>; readonly exclusiveMaximum: Schema.optional<Schema.Boolean>…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly _tag: 'isBetweenDate'; readonly minimum: Date; readonly maximum: Date; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined; }, readonly []>) =>…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'isBetweenDate'; readonly minimum: Date; readonly maximum: Date; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }>) => Schema.Struct<{ …;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'isBetweenDate'; readonly minimum: Date; readonly maximum: Date; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }>, ...checks: Array<SchemaAST.Ch…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isBetweenDate'>; readonly minimum: Schema.Date; readonly maximum: Schema.Date; readonly exclusiveMinimum: Schema.optional<Schema.Boolean>; readonly exclusiveMaximum: Sc…;
make: (input: { readonly minimum: globalThis.Date; readonly maximum: globalThis.Date; readonly _tag?: 'isBetweenDate' | undefined; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }, options?: Make…;
makeOption: (input: { readonly minimum: globalThis.Date; readonly maximum: globalThis.Date; readonly _tag?: 'isBetweenDate' | undefined; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }, options?: Make…;
makeEffect: (input: { readonly minimum: globalThis.Date; readonly maximum: globalThis.Date; readonly _tag?: 'isBetweenDate' | undefined; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }, options?: Make…;
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; <…;
}
Bottom<unknown, unknown, unknown, unknown, Union<...>, Union<...>, ... 8 more ..., "required">.annotate(annotations: Schema.Annotations.Bottom<Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlySide<{
readonly _tag: Schema.tag<"isDateValid">;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isGreaterThanDate">;
readonly exclusiveMinimum: Schema.Date;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isGreaterThanOrEqualToDate">;
readonly minimum: Schema.Date;
}, "Type"> | Schema.Struct.ReadonlySide<{
readonly _tag: Schema.tag<"isLessThanDate">;
readonly exclusiveMaximum: Schema.Date;
}, "Type"> | Schema.Struct.ReadonlySide<...> | {
...;
}, readonly []>): Schema.Union<...>
Annotations.Bottom<T, TypeParameters extends ReadonlyArray<Constraint>>.identifier?: string | undefinedStable identifier for this schema node.
Details
Identifiers are used by schema tooling, including JSON Schema
generation, to name references. The default formatter also uses
identifier as the expected label for type-level failures, such as
Expected UserId, got null.
identifier does not name a failed filter or refinement. If the base
type matches and a filter fails, put expected or message on the
filter/refinement instead.
identifier: "DateMeta" })Referenced by 1 symbols