@ix-xs/node-comfort 1.2.0 → 2.1.0

package/types/src/Schema.d.ts

@@ -0,0 +1,1189 @@
+declare namespace _exports {
+    export { Infer, Shape, Simplify, ObjectOutput, SafeParseResult, Message, RefineOptions, ParseContext, Step, JSONSchema, _JSONContext, CoerceBuilders };
+}
+declare namespace _exports {
+    export { string };
+    export { number };
+    export { boolean };
+    export { bigint };
+    export { date };
+    export { literal };
+    export { enumeration as enum };
+    export { array };
+    export { object };
+    export { union };
+    export { discriminatedUnion };
+    export { tuple };
+    export { record };
+    export { lazy };
+    export { instanceOf };
+    export { custom };
+    export { any };
+    export { unknown };
+    export { coerce };
+    export { Schema };
+}
+export = _exports;
+/**
+ * The type a schema produces.
+ */
+type Infer<S> = S extends Schema<infer T> ? T : never;
+/**
+ * An object of schemas, as passed to `object()`.
+ */
+type Shape = Record<string, Schema<any>>;
+/**
+ * Flattens a type so editors show it nicely.
+ */
+type Simplify<T> = { [K in keyof T]: T[K]; } & {};
+/**
+ * The type of an object schema. Keys that accept `undefined` become optional.
+ */
+type ObjectOutput<S extends Shape> = Simplify<{ [K in keyof S as undefined extends Infer<S[K]> ? never : K]: Infer<S[K]>; } & { [K in keyof S as undefined extends Infer<S[K]> ? K : never]?: Infer<S[K]>; }>;
+/**
+ * What `safeParse()` returns. On failure, `issues` is the plain list and
+ * `error` the same thing as a `ValidationError`, built when you read it.
+ */
+type SafeParseResult<T> = {
+    success: true;
+    data: T;
+    error?: undefined;
+    issues?: undefined;
+} | {
+    success: false;
+    data?: undefined;
+    error: ValidationError;
+    issues: import("./errors").ValidationIssue[];
+};
+/**
+ * An error message: a string, or a function that gets the invalid value.
+ */
+type Message = string | ((value: any) => string);
+/**
+ * Options for `refine()`.
+ */
+type RefineOptions = {
+    /**
+     * Defaults to `"Invalid value"`.
+     */
+    message?: Message | undefined;
+    /**
+     * Where to report the issue, like `["confirmPassword"]` for a cross-field check.
+     */
+    path?: (string | number)[] | undefined;
+    /**
+     * Defaults to `"custom"`.
+     */
+    code?: string | undefined;
+};
+type ParseContext = {
+    issues: import("./errors").ValidationIssue[];
+    path: Array<string | number>;
+};
+/**
+ * A step in a schema: a check, a transformation, a refinement or a pipe
+ * into another schema.
+ */
+type Step = {
+    kind: "check";
+    test: (value: any) => boolean;
+    code: string;
+    message: Message;
+    details?: Record<string, unknown>;
+    json?: Record<string, unknown>;
+} | {
+    kind: "transform";
+    fn: (value: any) => any;
+} | {
+    kind: "refine";
+    test: (value: any) => boolean;
+    options: RefineOptions;
+} | {
+    kind: "pipe";
+    schema: Schema<any>;
+};
+/**
+ * A JSON Schema, as made by `toJSONSchema()`.
+ */
+type JSONSchema = {
+    [keyword: string]: any;
+};
+type _JSONContext = {
+    defs: Record<string, JSONSchema>;
+    names: Map<Schema<any>, string>;
+};
+/**
+ * The `s.coerce` builders.
+ */
+type CoerceBuilders = {
+    /**
+     * A string schema that turns any value into a string first.
+     */
+    string: () => StringSchema;
+    /**
+     * A number schema that converts strings like `"42"`, booleans and dates first.
+     */
+    number: () => NumberSchema;
+    /**
+     * A boolean schema that understands `"true"`, `"1"`, `"yes"`, `"on"` and their opposites.
+     */
+    boolean: () => BooleanSchema;
+    /**
+     * A date schema that converts ISO strings and timestamps.
+     */
+    date: () => DateSchema;
+    /**
+     * A bigint schema that converts numeric strings and integers.
+     */
+    bigint: () => BigIntSchema;
+};
+/**
+ * A string schema.
+ *
+ * @example
+ * s.string().trim().min(1).max(100);
+ * s.string().email();
+ *
+ * @param {{ message?: Message }} [options] Message when the value isn't a string.
+ * @returns {StringSchema}
+ */
+declare function string(options?: {
+    message?: Message;
+}): StringSchema;
+/**
+ * A number. `NaN` and `Infinity` are refused.
+ *
+ * @example
+ * s.number().int().min(0).max(120);
+ *
+ * @param {{ message?: Message }} [options] Message when the value isn't a number.
+ * @returns {NumberSchema}
+ */
+declare function number(options?: {
+    message?: Message;
+}): NumberSchema;
+/**
+ * A boolean schema.
+ *
+ * @param {{ message?: Message }} [options]
+ * @returns {BooleanSchema}
+ */
+declare function boolean(options?: {
+    message?: Message;
+}): BooleanSchema;
+/**
+ * A bigint schema.
+ *
+ * @param {{ message?: Message }} [options]
+ * @returns {BigIntSchema}
+ */
+declare function bigint(options?: {
+    message?: Message;
+}): BigIntSchema;
+/**
+ * A valid `Date`.
+ *
+ * @example
+ * s.date().min("2024-01-01");
+ *
+ * @param {{ message?: Message }} [options]
+ * @returns {DateSchema}
+ */
+declare function date(options?: {
+    message?: Message;
+}): DateSchema;
+/**
+ * Exactly this value.
+ *
+ * @example
+ * s.object({ type: s.literal("circle"), radius: s.number() });
+ *
+ * @template {string | number | boolean | bigint | null | undefined} L
+ * @param {L} value
+ * @returns {LiteralSchema<L>}
+ */
+declare function literal<L extends string | number | boolean | bigint | null | undefined>(value: L): LiteralSchema<L>;
+/**
+ * One of these values. The type is their union.
+ *
+ * @example
+ * const Role = s.enum(["admin", "editor", "viewer"]); // Schema<"admin" | "editor" | "viewer">
+ * Role.options; // ["admin", "editor", "viewer"]
+ *
+ * @template {string | number} V
+ * @param {readonly V[]} values
+ * @param {{ message?: Message }} [options]
+ * @returns {LiteralSchema<V>}
+ */
+declare function enumeration<V extends string | number>(values: readonly V[], options?: {
+    message?: Message;
+}): LiteralSchema<V>;
+/**
+ * An array whose items all match `item`.
+ *
+ * @example
+ * s.array(s.string()).min(1).max(10).unique();
+ *
+ * @template T
+ * @param {Schema<T>} item
+ * @returns {ArraySchema<T>}
+ */
+declare function array<T>(item: Schema<T>): ArraySchema<T>;
+/**
+ * An object with known keys. Unknown keys are dropped; `.strict()` rejects
+ * them and `.passthrough()` keeps them.
+ *
+ * @example
+ * const Address = s.object({ street: s.string(), zip: s.string().regex(/^\d{5}$/), city: s.string() });
+ *
+ * @template {Shape} S
+ * @param {S} shape
+ * @returns {ObjectSchema<S>}
+ */
+declare function object<S extends Shape>(shape: S): ObjectSchema<S>;
+/**
+ * Matches any of these schemas; the first that fits wins.
+ *
+ * @example
+ * s.union([s.string(), s.number()]); // Schema<string | number>
+ *
+ * @template {ReadonlyArray<Schema<any>>} U
+ * @param {U} options
+ * @returns {UnionSchema<Infer<U[number]>>}
+ */
+declare function union<U extends ReadonlyArray<Schema<any>>>(options: U): UnionSchema<Infer<U[number]>>;
+/**
+ * A union of objects told apart by one key, like the `type` of an event.
+ * Unlike `union()`, it goes straight to the right schema, and a wrong
+ * object gets the errors of the kind it claims to be.
+ *
+ * @example
+ * const Event = s.discriminatedUnion("type", [
+ *   s.object({ type: s.literal("click"), x: s.number(), y: s.number() }),
+ *   s.object({ type: s.literal("key"), key: s.string() }),
+ * ]);
+ * Event.parse({ type: "key", key: "Enter" });
+ *
+ * @template {ReadonlyArray<ObjectSchema<any>>} U
+ * @param {string} key The key every option has, with a different literal in each.
+ * @param {U} options
+ * @returns {DiscriminatedUnionSchema<Infer<U[number]>>}
+ */
+declare function discriminatedUnion<U extends ReadonlyArray<ObjectSchema<any>>>(key: string, options: U): DiscriminatedUnionSchema<Infer<U[number]>>;
+/**
+ * A fixed-length array with one schema per position.
+ *
+ * @example
+ * s.tuple([s.number(), s.number()]); // Schema<[number, number]>
+ *
+ * @template {[Schema<any>, ...Schema<any>[]] | []} T
+ * @param {T} items
+ * @returns {TupleSchema<{ -readonly [K in keyof T]: Infer<T[K]> }>}
+ */
+declare function tuple<T extends [Schema<any>, ...Schema<any>[]] | []>(items: T): TupleSchema<{ -readonly [K in keyof T]: Infer<T[K]>; }>;
+/**
+ * An object with any keys whose values match a schema, like a dictionary.
+ *
+ * @example
+ * s.record(s.number());                                // Record<string, number>
+ * s.record(s.boolean(), s.string().regex(/^[a-z]+$/)); // keys checked too
+ *
+ * @template V
+ * @param {Schema<V>} values
+ * @param {Schema<string>} [keys]
+ * @returns {RecordSchema<V>}
+ */
+declare function record<V>(values: Schema<V>, keys?: Schema<string>): RecordSchema<V>;
+/**
+ * A schema defined later, for recursive data like trees.
+ *
+ * @example
+ * const Category = s.object({
+ *   name: s.string(),
+ *   children: s.lazy(() => s.array(Category)).default([]),
+ * });
+ *
+ * @template T
+ * @param {() => Schema<T>} getter
+ * @returns {LazySchema<T>}
+ */
+declare function lazy<T>(getter: () => Schema<T>): LazySchema<T>;
+/**
+ * An instance of a class.
+ *
+ * @example
+ * s.instanceOf(URL);
+ *
+ * @template {new (...args: any[]) => any} C
+ * @param {C} ctor
+ * @param {Message} [message]
+ * @returns {CustomSchema<InstanceType<C>>}
+ */
+declare function instanceOf<C extends new (...args: any[]) => any>(ctor: C, message?: Message): CustomSchema<InstanceType<C>>;
+/**
+ * A schema from any test, usually a type guard.
+ *
+ * @example
+ * const Color = s.custom(nc.isHexColor, "Expected a hex color");
+ *
+ * @template [T=unknown]
+ * @param {((value: unknown) => value is T) | ((value: unknown) => boolean)} test
+ * @param {Message} [message]
+ * @returns {CustomSchema<T>}
+ */
+declare function custom<T = unknown>(test: ((value: unknown) => value is T) | ((value: unknown) => boolean), message?: Message): CustomSchema<T>;
+/**
+ * Anything, typed as `any`.
+ * @returns {Schema<any>}
+ */
+declare function any(): Schema<any>;
+/**
+ * Anything, typed as `unknown`.
+ * @returns {Schema<unknown>}
+ */
+declare function unknown(): Schema<unknown>;
+/**
+ * The `s.coerce` builders.
+ * @typedef {object} CoerceBuilders
+ * @property {() => StringSchema} string A string schema that turns any value into a string first.
+ * @property {() => NumberSchema} number A number schema that converts strings like `"42"`, booleans and dates first.
+ * @property {() => BooleanSchema} boolean A boolean schema that understands `"true"`, `"1"`, `"yes"`, `"on"` and their opposites.
+ * @property {() => DateSchema} date A date schema that converts ISO strings and timestamps.
+ * @property {() => BigIntSchema} bigint A bigint schema that converts numeric strings and integers.
+ */
+/**
+ * Schemas that convert their input before checking it. Query strings, form
+ * fields and environment variables are always strings, so this is what you
+ * want for them.
+ *
+ * @example
+ * const Query = s.object({
+ *   page: s.coerce.number().int().min(1).default(1),
+ *   active: s.coerce.boolean().default(false),
+ * });
+ * Query.parse({ page: "2", active: "true" }); // { page: 2, active: true }
+ *
+ * @type {CoerceBuilders}
+ */
+declare const coerce: CoerceBuilders;
+/**
+ * The base of every schema.
+ *
+ * @template [T=unknown]
+ */
+declare class Schema<T = unknown> {
+    /** @protected @type {Step[]} */
+    protected _steps: Step[];
+    /** @protected */
+    protected _optional: boolean;
+    /** @protected */
+    protected _nullable: boolean;
+    /** @protected @type {{ value: unknown } | undefined} */
+    protected _default: {
+        value: unknown;
+    } | undefined;
+    /** @protected @type {{ value: unknown } | undefined} */
+    protected _catch: {
+        value: unknown;
+    } | undefined;
+    /** @protected @type {Message | undefined} */
+    protected _typeMessage: Message | undefined;
+    /** @protected @type {string | undefined} */
+    protected _description: string | undefined;
+    /**
+     * Checks the type, and coerces when asked. Subclasses override it.
+     * @param {unknown} value
+     * @param {ParseContext} _ctx
+     * @returns {unknown}
+     * @protected
+     */
+    protected _check(value: unknown, _ctx: ParseContext): unknown;
+    /**
+     * @returns {this}
+     * @protected
+     */
+    protected _clone(): this;
+    /**
+     * @param {Step} step
+     * @returns {this}
+     * @protected
+     */
+    protected _with(step: Step): this;
+    /**
+     * @param {unknown} input
+     * @param {ParseContext} ctx
+     * @returns {unknown} The output, or `INVALID`.
+     * @protected
+     */
+    protected _run(input: unknown, ctx: ParseContext): unknown;
+    /**
+     * Validates a value and returns it, with defaults and transformations
+     * applied. Unknown object keys are dropped.
+     *
+     * @example
+     * const port = s.coerce.number().int().min(1).max(65535).parse(process.env.PORT);
+     *
+     * @param {unknown} value
+     * @returns {T}
+     * @throws {ValidationError} Listing every issue with its path.
+     */
+    parse(value: unknown): T;
+    /**
+     * Validates a value without throwing.
+     *
+     * @example
+     * const result = User.safeParse(req.body);
+     * if (!result.success) return res.status(400).json(result.error.flatten());
+     * saveUser(result.data);
+     *
+     * @param {unknown} value
+     * @returns {SafeParseResult<T>}
+     */
+    safeParse(value: unknown): SafeParseResult<T>;
+    /**
+     * Is the value valid? Works as a type guard, and builds no error.
+     *
+     * @example
+     * if (Email.is(input)) sendMail(input); // input is a string here
+     *
+     * @param {unknown} value
+     * @returns {value is T}
+     */
+    is(value: unknown): value is T;
+    /**
+     * Also accepts `undefined`. In an object, the key becomes optional.
+     *
+     * @example
+     * s.object({ nickname: s.string().optional() }); // { nickname?: string }
+     *
+     * @returns {Schema<T | undefined>}
+     */
+    optional(): Schema<T | undefined>;
+    /**
+     * Also accepts `null`.
+     *
+     * @returns {Schema<T | null>}
+     */
+    nullable(): Schema<T | null>;
+    /**
+     * Also accepts `null` and `undefined`.
+     *
+     * @returns {Schema<T | null | undefined>}
+     */
+    nullish(): Schema<T | null | undefined>;
+    /**
+     * Uses this value when the input is `undefined`. Objects are copied each
+     * time; pass a function to build a fresh value on every parse.
+     *
+     * @example
+     * s.string().default("guest");
+     * s.date().default(() => new Date());
+     *
+     * @param {Exclude<T, undefined> | (() => Exclude<T, undefined>)} value
+     * @returns {Schema<Exclude<T, undefined>>}
+     */
+    default(value: Exclude<T, undefined> | (() => Exclude<T, undefined>)): Schema<Exclude<T, undefined>>;
+    /**
+     * Returns this value instead of failing when the input is invalid.
+     *
+     * @example
+     * s.number().catch(0).parse("not a number"); // 0
+     *
+     * @param {T | ((input: unknown) => T)} value A value, or a function that gets the invalid input.
+     * @returns {Schema<T>}
+     */
+    catch(value: T | ((input: unknown) => T)): Schema<T>;
+    /**
+     * Changes the value once it's valid. Runs after the checks written before it.
+     *
+     * @example
+     * s.string().transform((value) => value.split(",")); // Schema<string[]>
+     *
+     * @template U
+     * @param {(value: T) => U} fn
+     * @returns {Schema<U>}
+     */
+    transform<U>(fn: (value: T) => U): Schema<U>;
+    /**
+     * Adds your own rule.
+     *
+     * @example
+     * s.object({ password: s.string(), confirm: s.string() })
+     *   .refine((v) => v.password === v.confirm, { message: "Passwords don't match", path: ["confirm"] });
+     *
+     * @param {(value: T) => boolean} test Returns `true` when the value is fine.
+     * @param {Message | RefineOptions} [options]
+     * @returns {this}
+     */
+    refine(test: (value: T) => boolean, options?: Message | RefineOptions): this;
+    /**
+     * Accepts values that match this schema or another one.
+     *
+     * @example
+     * s.string().or(s.number()); // Schema<string | number>
+     *
+     * @template U
+     * @param {Schema<U>} other
+     * @returns {Schema<T | U>}
+     */
+    or<U>(other: Schema<U>): Schema<T | U>;
+    /**
+     * An array of this schema.
+     *
+     * @example
+     * s.string().email().array(); // Schema<string[]>
+     *
+     * @returns {ArraySchema<T>}
+     */
+    array(): ArraySchema<T>;
+    /**
+     * Sends the result into another schema. With `transform()` in between,
+     * it validates what a conversion produced.
+     *
+     * @example
+     * const Port = s.string().transform(Number).pipe(s.number().int().min(1).max(65535));
+     * Port.parse("8080"); // 8080
+     * Port.parse("abc");  // ValidationError: Expected number, received NaN
+     *
+     * @template U
+     * @param {Schema<U>} next
+     * @returns {Schema<U>}
+     */
+    pipe<U>(next: Schema<U>): Schema<U>;
+    /**
+     * Describes what this schema accepts as a JSON Schema (draft 2020-12).
+     * Use it for an OpenAPI document, a form generator, or the input of a
+     * tool you give to a language model. Rules that only exist in code,
+     * like `refine()`, `transform()` and what follows a `pipe()`, can't be
+     * expressed and are left out.
+     *
+     * @example
+     * s.object({ name: s.string().min(2), age: s.number().int().optional() }).toJSONSchema();
+     * // {
+     * //   type: "object",
+     * //   properties: { name: { type: "string", minLength: 2 }, age: { type: "integer" } },
+     * //   required: ["name"],
+     * // }
+     *
+     * @returns {JSONSchema}
+     */
+    toJSONSchema(): JSONSchema;
+    /**
+     * The JSON Schema of the type itself. Subclasses override it.
+     * @param {_JSONContext} _ctx
+     * @returns {JSONSchema}
+     * @protected
+     */
+    protected _json(_ctx: _JSONContext): JSONSchema;
+    /**
+     * The JSON Schema with what every schema can carry: rules, `null`,
+     * a description, a default.
+     * @param {_JSONContext} ctx
+     * @returns {JSONSchema}
+     * @protected
+     */
+    protected _toJSON(ctx: _JSONContext): JSONSchema;
+    /**
+     * Attaches a description, available as `.description`. Useful to generate
+     * docs or forms.
+     *
+     * @param {string} text
+     * @returns {this}
+     */
+    describe(text: string): this;
+    /** The text set with `describe()`. */
+    get description(): string | undefined;
+}
+import { ValidationError } from "./errors.js";
+/**
+ * A string schema.
+ *
+ * @extends {Schema<string>}
+ */
+declare class StringSchema extends Schema<string> {
+    constructor();
+    /** @protected */
+    protected _coerce: boolean;
+    /**
+     * @param {(v: string) => boolean} test
+     * @param {string} code
+     * @param {Message} message
+     * @param {Record<string, unknown>} [details]
+     * @param {Record<string, unknown>} [json] What the rule is called in JSON Schema.
+     * @returns {this}
+     * @protected
+     */
+    protected _rule(test: (v: string) => boolean, code: string, message: Message, details?: Record<string, unknown>, json?: Record<string, unknown>): this;
+    /**
+     * At least `length` characters.
+     * @param {number} length
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    min(length: number, message?: Message): this;
+    /**
+     * At most `length` characters.
+     * @param {number} length
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    max(length: number, message?: Message): this;
+    /**
+     * Exactly `length` characters.
+     * @param {number} length
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    length(length: number, message?: Message): this;
+    /**
+     * Not the empty string.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    nonempty(message?: Message): this;
+    /**
+     * A valid email address.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    email(message?: Message): this;
+    /**
+     * An absolute URL.
+     * @param {Message | { message?: Message, protocols?: string[] }} [options] A message, or allowed protocols (http and https by default).
+     * @returns {this}
+     */
+    url(options?: Message | {
+        message?: Message;
+        protocols?: string[];
+    }): this;
+    /**
+     * A UUID.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    uuid(message?: Message): this;
+    /**
+     * An IP address.
+     * @param {4 | 6 | Message} [versionOrMessage] Only IPv4 or IPv6, or a message.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    ip(versionOrMessage?: 4 | 6 | Message, message?: Message): this;
+    /**
+     * An ISO 8601 date or date-time, like `2024-01-31T10:00:00Z`.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    datetime(message?: Message): this;
+    /**
+     * Matches a regular expression.
+     * @param {RegExp} pattern
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    regex(pattern: RegExp, message?: Message): this;
+    /**
+     * Starts with `prefix`.
+     * @param {string} prefix
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    startsWith(prefix: string, message?: Message): this;
+    /**
+     * Ends with `suffix`.
+     * @param {string} suffix
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    endsWith(suffix: string, message?: Message): this;
+    /**
+     * Contains `search`.
+     * @param {string} search
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    includes(search: string, message?: Message): this;
+    /**
+     * Trims whitespace before the checks that follow.
+     * @returns {this}
+     */
+    trim(): this;
+    /**
+     * Lowercases before the checks that follow.
+     * @returns {this}
+     */
+    toLowerCase(): this;
+    /**
+     * Uppercases before the checks that follow.
+     * @returns {this}
+     */
+    toUpperCase(): this;
+    /**
+     * A calendar date like `2024-01-31`, without a time.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    date(message?: Message): this;
+    /**
+     * A URL slug like `my-first-post`: lowercase letters, digits and single dashes.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    slug(message?: Message): this;
+    /**
+     * Hexadecimal digits only.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    hex(message?: Message): this;
+    /**
+     * Base64 data.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    base64(message?: Message): this;
+    /**
+     * A ULID.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    ulid(message?: Message): this;
+    /**
+     * A semantic version like `1.4.0` or `2.0.0-beta.1`.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    semver(message?: Message): this;
+    /**
+     * A host name like `api.example.com`.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    hostname(message?: Message): this;
+    /**
+     * @returns {JSONSchema}
+     * @override
+     * @protected
+     */
+    protected override _json(): JSONSchema;
+}
+/**
+ * A number schema.
+ *
+ * @extends {Schema<number>}
+ */
+declare class NumberSchema extends Schema<number> {
+    constructor();
+    /** @protected */
+    protected _coerce: boolean;
+    /**
+     * @param {(v: number) => boolean} test
+     * @param {string} code
+     * @param {Message} message
+     * @param {Record<string, unknown>} [details]
+     * @param {Record<string, unknown>} [json] What the rule is called in JSON Schema.
+     * @returns {this}
+     * @protected
+     */
+    protected _rule(test: (v: number) => boolean, code: string, message: Message, details?: Record<string, unknown>, json?: Record<string, unknown>): this;
+    /**
+     * At least `value`.
+     * @param {number} value
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    min(value: number, message?: Message): this;
+    /**
+     * At most `value`.
+     * @param {number} value
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    max(value: number, message?: Message): this;
+    /**
+     * An integer.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    int(message?: Message): this;
+    /**
+     * Greater than 0.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    positive(message?: Message): this;
+    /**
+     * 0 or more.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    nonnegative(message?: Message): this;
+    /**
+     * Less than 0.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    negative(message?: Message): this;
+    /**
+     * A multiple of `step`.
+     * @param {number} step
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    multipleOf(step: number, message?: Message): this;
+    /**
+     * Greater than `value`, which itself is refused.
+     * @param {number} value
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    gt(value: number, message?: Message): this;
+    /**
+     * Less than `value`, which itself is refused.
+     * @param {number} value
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    lt(value: number, message?: Message): this;
+    /**
+     * An integer JavaScript can hold exactly: up to 2^53 - 1 either way.
+     * Ids from a database or an API should pass this before any arithmetic.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    safe(message?: Message): this;
+    /**
+     * @returns {JSONSchema}
+     * @override
+     * @protected
+     */
+    protected override _json(): JSONSchema;
+}
+/**
+ * A boolean schema.
+ *
+ * @extends {Schema<boolean>}
+ */
+declare class BooleanSchema extends Schema<boolean> {
+    constructor();
+    /** @protected */
+    protected _coerce: boolean;
+    /**
+     * @returns {JSONSchema}
+     * @override
+     * @protected
+     */
+    protected override _json(): JSONSchema;
+}
+/**
+ * A date schema.
+ *
+ * @extends {Schema<Date>}
+ */
+declare class DateSchema extends Schema<Date> {
+    constructor();
+    /** @protected */
+    protected _coerce: boolean;
+    /**
+     * On or after `date`.
+     * @param {Date | number | string} date
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    min(date: Date | number | string, message?: Message): this;
+    /**
+     * On or before `date`.
+     * @param {Date | number | string} date
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    max(date: Date | number | string, message?: Message): this;
+    /**
+     * @returns {JSONSchema}
+     * @override
+     * @protected
+     */
+    protected override _json(): JSONSchema;
+}
+/**
+ * A bigint schema.
+ *
+ * @extends {Schema<bigint>}
+ */
+declare class BigIntSchema extends Schema<bigint> {
+    constructor();
+    /** @protected */
+    protected _coerce: boolean;
+    /**
+     * @returns {JSONSchema}
+     * @override
+     * @protected
+     */
+    protected override _json(): JSONSchema;
+}
+/**
+ * A schema that accepts a fixed set of values.
+ *
+ * @template T
+ * @extends {Schema<T>}
+ */
+declare class LiteralSchema<T> extends Schema<T> {
+    /** @param {readonly T[]} values */
+    constructor(values: readonly T[]);
+    /** @protected */
+    protected _values: readonly T[];
+    /** @protected @type {Set<unknown>} */
+    protected _set: Set<unknown>;
+    /**
+     * @returns {JSONSchema}
+     * @override
+     * @protected
+     */
+    protected override _json(): JSONSchema;
+    /** The accepted values. */
+    get options(): T[];
+}
+/**
+ * An array schema.
+ *
+ * @template T
+ * @extends {Schema<T[]>}
+ */
+declare class ArraySchema<T> extends Schema<T[]> {
+    /** @param {Schema<T>} item */
+    constructor(item: Schema<T>);
+    /** @protected */
+    protected _item: Schema<T>;
+    /**
+     * @param {(v: T[]) => boolean} test
+     * @param {string} code
+     * @param {Message} message
+     * @param {Record<string, unknown>} [details]
+     * @param {Record<string, unknown>} [json]
+     * @returns {this}
+     * @protected
+     */
+    protected _rule(test: (v: T[]) => boolean, code: string, message: Message, details?: Record<string, unknown>, json?: Record<string, unknown>): this;
+    /**
+     * At least `count` items.
+     * @param {number} count
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    min(count: number, message?: Message): this;
+    /**
+     * At most `count` items.
+     * @param {number} count
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    max(count: number, message?: Message): this;
+    /**
+     * Exactly `count` items.
+     * @param {number} count
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    length(count: number, message?: Message): this;
+    /**
+     * At least one item.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    nonempty(message?: Message): this;
+    /**
+     * No duplicates, compared by value or by a key.
+     * @param {((item: T) => unknown) | Message} [keyOrMessage] A function returning the key, or a message.
+     * @param {Message} [message]
+     * @returns {this}
+     */
+    unique(keyOrMessage?: ((item: T) => unknown) | Message, message?: Message): this;
+    /** The schema of the items. */
+    get element(): Schema<T>;
+}
+/**
+ * An object schema.
+ *
+ * @template {Shape} S
+ * @extends {Schema<ObjectOutput<S>>}
+ */
+declare class ObjectSchema<S extends Shape> extends Schema<{ [K_1 in keyof S as undefined extends Infer<S[K_1]> ? never : K_1]: Infer<S[K_1]>; } & { [K_2 in keyof S as undefined extends Infer<S[K_2]> ? K_2 : never]?: Infer<S[K_2]> | undefined; } extends infer T ? { [K in keyof T]: T[K]; } : never> {
+    /** @param {S} shape */
+    constructor(shape: S);
+    /** @protected @type {"strip" | "strict" | "passthrough"} */
+    protected _unknown: "strip" | "strict" | "passthrough";
+    /** @protected */
+    protected _shape: S;
+    /** @protected @type {string[]} */
+    protected _keys: string[];
+    /** @protected @type {Array<Schema<any>>} */
+    protected _schemas: Array<Schema<any>>;
+    /**
+     * A schema with another shape that keeps how this one treats unknown keys.
+     * @param {Shape} shape
+     * @returns {any}
+     * @protected
+     */
+    protected _reshape(shape: Shape): any;
+    /** The schema of each key. */
+    get shape(): S;
+    /**
+     * Rejects unknown keys instead of dropping them.
+     * @returns {this}
+     */
+    strict(): this;
+    /**
+     * Keeps unknown keys instead of dropping them.
+     * @returns {this}
+     */
+    passthrough(): this;
+    /**
+     * Adds keys, or replaces existing ones.
+     * @template {Shape} M
+     * @param {M} more
+     * @returns {ObjectSchema<Omit<S, keyof M> & M>}
+     */
+    extend<M extends Shape>(more: M): ObjectSchema<Omit<S, keyof M> & M>;
+    /**
+     * Keeps only some keys.
+     * @template {keyof S & string} K
+     * @param {readonly K[]} keys
+     * @returns {ObjectSchema<Pick<S, K>>}
+     */
+    pick<K_3 extends keyof S & string>(keys: readonly K_3[]): ObjectSchema<Pick<S, K_3>>;
+    /**
+     * Drops some keys.
+     * @template {keyof S & string} K
+     * @param {readonly K[]} keys
+     * @returns {ObjectSchema<Omit<S, K>>}
+     */
+    omit<K_3 extends keyof S & string>(keys: readonly K_3[]): ObjectSchema<Omit<S, K_3>>;
+    /**
+     * Makes every key optional, which suits PATCH requests.
+     * @returns {ObjectSchema<{ [K in keyof S]: Schema<Infer<S[K]> | undefined> }>}
+     */
+    partial(): ObjectSchema<{ [K_3 in keyof S]: Schema<Infer<S[K_3]> | undefined>; }>;
+    /**
+     * Makes every key required again: the opposite of `partial()`.
+     * @returns {ObjectSchema<{ [K in keyof S]: Schema<Exclude<Infer<S[K]>, undefined>> }>}
+     */
+    required(): ObjectSchema<{ [K_3 in keyof S]: Schema<Exclude<Infer<S[K_3]>, undefined>>; }>;
+    /**
+     * Combines two object schemas. Keys of the other one win, and so does
+     * its way of treating unknown keys.
+     *
+     * @example
+     * const Timestamps = s.object({ createdAt: s.date(), updatedAt: s.date() });
+     * const Post = s.object({ title: s.string() }).merge(Timestamps);
+     *
+     * @template {Shape} M
+     * @param {ObjectSchema<M>} other
+     * @returns {ObjectSchema<Omit<S, keyof M> & M>}
+     */
+    merge<M extends Shape>(other: ObjectSchema<M>): ObjectSchema<Omit<S, keyof M> & M>;
+    /**
+     * A schema that accepts the name of any key: handy for a `sort` or
+     * `fields` query parameter.
+     *
+     * @example
+     * const SortBy = User.keyof(); // "name" | "email" | "age" | "role"
+     *
+     * @returns {LiteralSchema<keyof S & string>}
+     */
+    keyof(): LiteralSchema<keyof S & string>;
+}
+/**
+ * A schema that accepts any of several schemas.
+ *
+ * @template T
+ * @extends {Schema<T>}
+ */
+declare class UnionSchema<T> extends Schema<T> {
+    /** @param {ReadonlyArray<Schema<any>>} options */
+    constructor(options: ReadonlyArray<Schema<any>>);
+    /** @protected */
+    protected _options: readonly Schema<any>[];
+}
+/**
+ * A union of objects told apart by one key.
+ *
+ * @template T
+ * @extends {Schema<T>}
+ */
+declare class DiscriminatedUnionSchema<T> extends Schema<T> {
+    /**
+     * @param {string} key
+     * @param {ReadonlyArray<ObjectSchema<any>>} options
+     */
+    constructor(key: string, options: ReadonlyArray<ObjectSchema<any>>);
+    /** @protected */
+    protected _key: string;
+    /** @protected */
+    protected _options: readonly ObjectSchema<any>[];
+    /** @protected @type {Map<unknown, Schema<any>>} */
+    protected _byValue: Map<unknown, Schema<any>>;
+}
+/**
+ * A fixed-length array schema.
+ *
+ * @template {any[]} T
+ * @extends {Schema<T>}
+ */
+declare class TupleSchema<T extends any[]> extends Schema<T> {
+    /** @param {ReadonlyArray<Schema<any>>} items */
+    constructor(items: ReadonlyArray<Schema<any>>);
+    /** @protected */
+    protected _items: readonly Schema<any>[];
+}
+/**
+ * A dictionary schema.
+ *
+ * @template V
+ * @extends {Schema<Record<string, V>>}
+ */
+declare class RecordSchema<V> extends Schema<Record<string, V>> {
+    /**
+     * @param {Schema<V>} values
+     * @param {Schema<string> | undefined} keys
+     */
+    constructor(values: Schema<V>, keys: Schema<string> | undefined);
+    /** @protected */
+    protected _values: Schema<V>;
+    /** @protected */
+    protected _keys: Schema<string> | undefined;
+}
+/**
+ * A schema resolved on first use, for recursive data.
+ *
+ * @template T
+ * @extends {Schema<T>}
+ */
+declare class LazySchema<T> extends Schema<T> {
+    /** @param {() => Schema<T>} getter */
+    constructor(getter: () => Schema<T>);
+    /** @protected */
+    protected _getter: () => Schema<T>;
+    /** @protected @type {Schema<T> | undefined} */
+    protected _resolved: Schema<T> | undefined;
+}
+/**
+ * A schema built from a test function.
+ *
+ * @template T
+ * @extends {Schema<T>}
+ */
+declare class CustomSchema<T> extends Schema<T> {
+    /**
+     * @param {(value: unknown) => boolean} test
+     * @param {Message} message
+     * @param {string} expected
+     */
+    constructor(test: (value: unknown) => boolean, message: Message, expected: string);
+    /** @protected */
+    protected _test: (value: unknown) => boolean;
+    /** @protected */
+    protected _message: Message;
+    /** @protected */
+    protected _expected: string;
+}
+//# sourceMappingURL=Schema.d.ts.map