Schema.Union<
readonly [
Schema.Struct<{ readonly _tag: Schema.tag<"isInt"> }>,
Schema.Struct<{
readonly _tag: Schema.tag<"isMultipleOf">
readonly divisor: Schema.Finite
}>,
Schema.Struct<{ readonly _tag: Schema.tag<"isFinite"> }>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThan">
readonly exclusiveMinimum: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanOrEqualTo">
readonly minimum: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLessThan">
readonly exclusiveMaximum: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanOrEqualTo">
readonly maximum: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isBetween">
readonly minimum: Schema.Finite
readonly maximum: Schema.Finite
readonly exclusiveMinimum: Schema.optional<Schema.Boolean>
readonly exclusiveMaximum: Schema.optional<Schema.Boolean>
}>
]
>Schema for NumberMeta.
schemasNumberMeta
Source effect/SchemaRepresentation.ts:109210 lines
export const const $NumberMeta: Schema.Union<
readonly [
Schema.Struct<{
readonly _tag: Schema.tag<"isInt">
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isMultipleOf">
readonly divisor: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isFinite">
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThan">
readonly exclusiveMinimum: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanOrEqualTo">
readonly minimum: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLessThan">
readonly exclusiveMaximum: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanOrEqualTo">
readonly maximum: Schema.Finite
}>,
Schema.Struct<{
readonly _tag: Schema.tag<"isBetween">
readonly minimum: Schema.Finite
readonly maximum: Schema.Finite
readonly exclusiveMinimum: Schema.optional<Schema.Boolean>
readonly exclusiveMaximum: Schema.optional<Schema.Boolean>
}>
]
>
const $NumberMeta: {
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<'isInt'> }>, Schema.Struct<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schema.Finite }>, Schema.Struct<{ readonly _tag: Schema.tag<'isFinite'> }>, Schema.…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'>; }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schema.Finite; }, 'Type'> | Sch…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'> }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schema.Finite }, 'Type'> | Schema.S…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'> }, 'Type'> | Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schema.Finite }, 'Type'> | Schema.Struct.Read…;
rebuild: (ast: SchemaAST.Union<SchemaAST.Objects>) => Schema.Union<readonly [Schema.Struct<{ readonly _tag: Schema.tag<'isInt'> }>, Schema.Struct<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schema.Finite }>, Schema.Struct<{ reado…;
make: (input: { readonly _tag?: 'isInt' | undefined } | { readonly divisor: number; readonly _tag?: 'isMultipleOf' | undefined } | { readonly _tag?: 'isFinite' | undefined } | { readonly exclusiveMinimum: number; readonly _tag?: 'isGreaterThan' …;
makeOption: (input: { readonly _tag?: 'isInt' | undefined } | { readonly divisor: number; readonly _tag?: 'isMultipleOf' | undefined } | { readonly _tag?: 'isFinite' | undefined } | { readonly exclusiveMinimum: number; readonly _tag?: 'isGreaterThan' …;
makeEffect: (input: { readonly _tag?: 'isInt' | undefined } | { readonly divisor: number; readonly _tag?: 'isMultipleOf' | undefined } | { readonly _tag?: 'isFinite' | undefined } | { readonly exclusiveMinimum: number; readonly _tag?: 'isGreaterThan' …;
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
NumberMeta
.
$NumberMeta = import SchemaSchema.Union([
const $IsInt: Schema.Struct<{
readonly _tag: Schema.tag<"isInt">
}>
const $IsInt: {
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<'isInt'> }) => 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<'isInt'>; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isInt'>; }>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'> }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isInt'> }>;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'> }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isInt'> }, 'Type'>>>) => Schema.Struct<{ reado…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isInt'> }>;
make: (input: { readonly _tag?: 'isInt' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isInt'> }, 'Type'>;
makeOption: (input: { readonly _tag?: 'isInt' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isInt'> }, 'Type'>>;
makeEffect: (input: { readonly _tag?: 'isInt' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isInt'> }, '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 $IsMultipleOf: Schema.Struct<{
readonly _tag: Schema.tag<"isMultipleOf">
readonly divisor: Schema.Finite
}>
const $IsMultipleOf: {
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<'isMultipleOf'>; readonly divisor: Schema.Finite }) => 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<'isMultipleOf'>; readonly divisor: Schema.Finite; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isMultipleOf'>; readon…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schema.Finite }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schem…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schema.Finite }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isMult…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isMultipleOf'>; readonly divisor: Schema.Finite }>;
make: (input: { readonly divisor: number; readonly _tag?: 'isMultipleOf' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isMultipleOf'>; readonly divisor: Finite }, 'Type'>;
makeOption: (input: { readonly divisor: number; readonly _tag?: 'isMultipleOf' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isMultipleOf'>; readonly divisor: Finite }, 'Type'>>;
makeEffect: (input: { readonly divisor: number; readonly _tag?: 'isMultipleOf' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isMultipleOf'>; readonly divisor: Finite }, '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 $IsFinite: Schema.Struct<{
readonly _tag: Schema.tag<"isFinite">
}>
const $IsFinite: {
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<'isFinite'> }) => 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<'isFinite'>; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isFinite'>; }>;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isFinite'> }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isFinite'> }>;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isFinite'> }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isFinite'> }, 'Type'>>>) => Schema.Struct<{…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isFinite'> }>;
make: (input: { readonly _tag?: 'isFinite' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isFinite'> }, 'Type'>;
makeOption: (input: { readonly _tag?: 'isFinite' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isFinite'> }, 'Type'>>;
makeEffect: (input: { readonly _tag?: 'isFinite' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isFinite'> }, '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 $IsGreaterThan: Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThan">
readonly exclusiveMinimum: Schema.Finite
}>
const $IsGreaterThan: {
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<'isGreaterThan'>; readonly exclusiveMinimum: Schema.Finite }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Read…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThan'>; readonly exclusiveMinimum: Schema.Finite; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterTha…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThan'>; readonly exclusiveMinimum: Schema.Finite }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThan'>; readonly exc…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThan'>; readonly exclusiveMinimum: Schema.Finite }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.t…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThan'>; readonly exclusiveMinimum: Schema.Finite }>;
make: (input: { readonly exclusiveMinimum: number; readonly _tag?: 'isGreaterThan' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThan'>; readonly exclusiveMinimum: Finite }, 'Type'>;
makeOption: (input: { readonly exclusiveMinimum: number; readonly _tag?: 'isGreaterThan' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThan'>; readonly exclusiveMinimum: Finite }, 'Type'>>;
makeEffect: (input: { readonly exclusiveMinimum: number; readonly _tag?: 'isGreaterThan' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThan'>; readonly exclusiveMinimum: Finite }, 'Type'>, Sc…;
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 $IsGreaterThanOrEqualTo: Schema.Struct<{
readonly _tag: Schema.tag<"isGreaterThanOrEqualTo">
readonly minimum: Schema.Finite
}>
const $IsGreaterThanOrEqualTo: {
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<'isGreaterThanOrEqualTo'>; readonly minimum: Schema.Finite }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Read…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualTo'>; readonly minimum: Schema.Finite; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterTha…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualTo'>; readonly minimum: Schema.Finite }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualTo'>; rea…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualTo'>; readonly minimum: Schema.Finite }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.t…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isGreaterThanOrEqualTo'>; readonly minimum: Schema.Finite }>;
make: (input: { readonly minimum: number; readonly _tag?: 'isGreaterThanOrEqualTo' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanOrEqualTo'>; readonly minimum: Finite }, 'Type'>;
makeOption: (input: { readonly minimum: number; readonly _tag?: 'isGreaterThanOrEqualTo' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanOrEqualTo'>; readonly minimum: Finite }, 'Type'>>;
makeEffect: (input: { readonly minimum: number; readonly _tag?: 'isGreaterThanOrEqualTo' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isGreaterThanOrEqualTo'>; readonly minimum: Finite }, 'Type'>, Sc…;
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 $IsLessThan: Schema.Struct<{
readonly _tag: Schema.tag<"isLessThan">
readonly exclusiveMaximum: Schema.Finite
}>
const $IsLessThan: {
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<'isLessThan'>; readonly exclusiveMaximum: Schema.Finite }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonl…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThan'>; readonly exclusiveMaximum: Schema.Finite; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThan'>; r…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThan'>; readonly exclusiveMaximum: Schema.Finite }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThan'>; readonly exclusive…;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThan'>; readonly exclusiveMaximum: Schema.Finite }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThan'>; readonly exclusiveMaximum: Schema.Finite }>;
make: (input: { readonly exclusiveMaximum: number; readonly _tag?: 'isLessThan' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isLessThan'>; readonly exclusiveMaximum: Finite }, 'Type'>;
makeOption: (input: { readonly exclusiveMaximum: number; readonly _tag?: 'isLessThan' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isLessThan'>; readonly exclusiveMaximum: Finite }, 'Type'>>;
makeEffect: (input: { readonly exclusiveMaximum: number; readonly _tag?: 'isLessThan' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isLessThan'>; readonly exclusiveMaximum: Finite }, 'Type'>, SchemaEr…;
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 $IsLessThanOrEqualTo: Schema.Struct<{
readonly _tag: Schema.tag<"isLessThanOrEqualTo">
readonly maximum: Schema.Finite
}>
const $IsLessThanOrEqualTo: {
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<'isLessThanOrEqualTo'>; readonly maximum: Schema.Finite }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonl…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanOrEqualTo'>; readonly maximum: Schema.Finite; }, 'Type'>, readonly []>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanOrEqu…;
annotateKey: (annotations: Schema.Annotations.Key<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanOrEqualTo'>; readonly maximum: Schema.Finite }, 'Type'>>) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanOrEqualTo'>; readonly …;
check: (checks_0: SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<'isLessThanOrEqualTo'>; readonly maximum: Schema.Finite }, 'Type'>>, ...checks: Array<SchemaAST.Check<Schema.Struct.ReadonlySide<{ readonly _tag: Schema.tag<…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isLessThanOrEqualTo'>; readonly maximum: Schema.Finite }>;
make: (input: { readonly maximum: number; readonly _tag?: 'isLessThanOrEqualTo' | undefined }, options?: MakeOptions) => Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanOrEqualTo'>; readonly maximum: Finite }, 'Type'>;
makeOption: (input: { readonly maximum: number; readonly _tag?: 'isLessThanOrEqualTo' | undefined }, options?: MakeOptions) => Option_.Option<Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanOrEqualTo'>; readonly maximum: Finite }, 'Type'>>;
makeEffect: (input: { readonly maximum: number; readonly _tag?: 'isLessThanOrEqualTo' | undefined }, options?: MakeOptions) => Effect.Effect<Struct.ReadonlySide<{ readonly _tag: tag<'isLessThanOrEqualTo'>; readonly maximum: Finite }, 'Type'>, SchemaEr…;
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 $IsBetween: Schema.Struct<{
readonly _tag: Schema.tag<"isBetween">
readonly minimum: Schema.Finite
readonly maximum: Schema.Finite
readonly exclusiveMinimum: Schema.optional<Schema.Boolean>
readonly exclusiveMaximum: Schema.optional<Schema.Boolean>
}>
const $IsBetween: {
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<'isBetween'>; readonly minimum: Schema.Finite; readonly maximum: Schema.Finite; readonly exclusiveMinimum: Schema.optional<Schema.Boolean>; readonly exclusiveMaximum: Schema.optional<Schema.Boolean>…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<{ readonly _tag: 'isBetween'; readonly minimum: number; readonly maximum: number; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined; }, readonly []>) =>…;
annotateKey: (annotations: Schema.Annotations.Key<{ readonly _tag: 'isBetween'; readonly minimum: number; readonly maximum: number; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }>) => Schema.Struct<{ …;
check: (checks_0: SchemaAST.Check<{ readonly _tag: 'isBetween'; readonly minimum: number; readonly maximum: number; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }>, ...checks: Array<SchemaAST.Ch…;
rebuild: (ast: SchemaAST.Objects) => Schema.Struct<{ readonly _tag: Schema.tag<'isBetween'>; readonly minimum: Schema.Finite; readonly maximum: Schema.Finite; readonly exclusiveMinimum: Schema.optional<Schema.Boolean>; readonly exclusiveMaximum: Sc…;
make: (input: { readonly minimum: number; readonly maximum: number; readonly _tag?: 'isBetween' | undefined; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }, options?: MakeOptions) => { readonly…;
makeOption: (input: { readonly minimum: number; readonly maximum: number; readonly _tag?: 'isBetween' | undefined; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }, options?: MakeOptions) => Option_.Op…;
makeEffect: (input: { readonly minimum: number; readonly maximum: number; readonly _tag?: 'isBetween' | undefined; readonly exclusiveMinimum?: boolean | undefined; readonly exclusiveMaximum?: boolean | undefined }, options?: MakeOptions) => Effect.Eff…;
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: "NumberMeta" })Referenced by 1 symbols