@ix-xs/node-comfort 1.1.31 → 2.0.0

package/types/src/Schema.d.ts

@@ -0,0 +1,940 @@
+declare namespace _exports {
+    export { Infer, Shape, Simplify, ObjectOutput, SafeParseResult, Message, RefineOptions, ParseContext, Step, 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 { 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.
+ */
+type SafeParseResult<T> = {
+    success: true;
+    data: T;
+    error?: undefined;
+} | {
+    success: false;
+    data?: undefined;
+    error: ValidationError;
+};
+/**
+ * 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 or a refinement.
+ */
+type Step = {
+    kind: "check";
+    test: (value: any) => boolean;
+    code: string;
+    message: Message;
+    details?: Record<string, unknown>;
+} | {
+    kind: "transform";
+    fn: (value: any) => any;
+} | {
+    kind: "refine";
+    test: (value: any) => boolean;
+    options: RefineOptions;
+};
+/**
+ * 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 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. Transformations don't run.
+     *
+     * @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>;
+    /**
+     * 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]
+     * @returns {this}
+     * @protected
+     */
+    protected _rule(test: (v: string) => boolean, code: string, message: Message, details?: 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 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]
+     * @returns {this}
+     * @protected
+     */
+    protected _rule(test: (v: number) => boolean, code: string, message: Message, details?: 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;
+}
+/**
+ * A boolean schema.
+ *
+ * @extends {Schema<boolean>}
+ */
+declare class BooleanSchema extends Schema<boolean> {
+    constructor();
+    /** @protected */
+    protected _coerce: boolean;
+}
+/**
+ * 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;
+}
+/**
+ * A bigint schema.
+ *
+ * @extends {Schema<bigint>}
+ */
+declare class BigIntSchema extends Schema<bigint> {
+    constructor();
+    /** @protected */
+    protected _coerce: boolean;
+}
+/**
+ * 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[];
+    /** 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
+     * @returns {this}
+     * @protected
+     */
+    protected _rule(test: (v: T[]) => boolean, code: string, message: Message): 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;
+    /** 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>; }>;
+}
+/**
+ * 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 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>;
+}
+/**
+ * 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