@willaimg/yatsp 4.3.6

package/v4/classic/schemas.d.cts

@@ -0,0 +1,816 @@
+import type { $YatspBigIntFormats } from "../core/checks.cjs";
+import * as core from "../core/index.cjs";
+import { util, type $YatspNumberFormats } from "../core/index.cjs";
+import type { StandardSchemaWithJSONProps } from "../core/standard-schema.cjs";
+import * as parse from "./parse.cjs";
+export type YatspStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;
+export interface YatspType<out Output = unknown, out Input = unknown, out Internals extends core.$YatspTypeInternals<Output, Input> = core.$YatspTypeInternals<Output, Input>> extends core.$YatspType<Output, Input, Internals> {
+    def: Internals["def"];
+    type: Internals["def"]["type"];
+    /** @deprecated Use `.def` instead. */
+    _def: Internals["def"];
+    /** @deprecated Use `z.output<typeof schema>` instead. */
+    _output: Internals["output"];
+    /** @deprecated Use `z.input<typeof schema>` instead. */
+    _input: Internals["input"];
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    /** Converts this schema to a JSON Schema representation. */
+    toJSONSchema(params?: core.ToJSONSchemaParams): core.YatspStandardJSONSchemaPayload<this>;
+    check(...checks: (core.CheckFn<core.output<this>> | core.$YatspCheck<core.output<this>>)[]): this;
+    with(...checks: (core.CheckFn<core.output<this>> | core.$YatspCheck<core.output<this>>)[]): this;
+    clone(def?: Internals["def"], params?: {
+        parent: boolean;
+    }): this;
+    register<R extends core.$YatspRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$replace<R["_meta"], this>?] : [core.$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
+    brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : core.$YatspBranded<this, T, Dir>;
+    parse(data: unknown, params?: core.ParseContext<core.$YatspIssue>): core.output<this>;
+    safeParse(data: unknown, params?: core.ParseContext<core.$YatspIssue>): parse.YatspSafeParseResult<core.output<this>>;
+    parseAsync(data: unknown, params?: core.ParseContext<core.$YatspIssue>): Promise<core.output<this>>;
+    safeParseAsync(data: unknown, params?: core.ParseContext<core.$YatspIssue>): Promise<parse.YatspSafeParseResult<core.output<this>>>;
+    spa: (data: unknown, params?: core.ParseContext<core.$YatspIssue>) => Promise<parse.YatspSafeParseResult<core.output<this>>>;
+    validate(data: unknown, params?: core.ParseContext<core.$YatspIssue>): data is core.input<this>;
+    validateAsync(data: unknown, params?: core.ParseContext<core.$YatspIssue>): Promise<boolean>;
+    encode(data: core.output<this>, params?: core.ParseContext<core.$YatspIssue>): core.input<this>;
+    decode(data: core.input<this>, params?: core.ParseContext<core.$YatspIssue>): core.output<this>;
+    encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$YatspIssue>): Promise<core.input<this>>;
+    decodeAsync(data: core.input<this>, params?: core.ParseContext<core.$YatspIssue>): Promise<core.output<this>>;
+    safeEncode(data: core.output<this>, params?: core.ParseContext<core.$YatspIssue>): parse.YatspSafeParseResult<core.input<this>>;
+    safeDecode(data: core.input<this>, params?: core.ParseContext<core.$YatspIssue>): parse.YatspSafeParseResult<core.output<this>>;
+    safeEncodeAsync(data: core.output<this>, params?: core.ParseContext<core.$YatspIssue>): Promise<parse.YatspSafeParseResult<core.input<this>>>;
+    safeDecodeAsync(data: core.input<this>, params?: core.ParseContext<core.$YatspIssue>): Promise<parse.YatspSafeParseResult<core.output<this>>>;
+    refine<Ch extends (arg: core.output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | core.$YatspCustomParams): Ch extends (arg: any) => arg is infer R ? this & YatspType<R, core.input<this>> : this;
+    superRefine(refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>, params?: core.$YatspSuperRefineParams): this;
+    overwrite(fn: (x: core.output<this>) => core.output<this>): this;
+    optional(): YatspOptional<this>;
+    exactOptional(): YatspExactOptional<this>;
+    nonoptional(params?: string | core.$YatspNonOptionalParams): YatspNonOptional<this>;
+    nullable(): YatspNullable<this>;
+    nullish(): YatspOptional<YatspNullable<this>>;
+    default(def: util.NoUndefined<core.output<this>>): YatspDefault<this>;
+    default(def: () => util.NoUndefined<core.output<this>>): YatspDefault<this>;
+    prefault(def: () => core.input<this>): YatspPrefault<this>;
+    prefault(def: core.input<this>): YatspPrefault<this>;
+    array(): YatspArray<this>;
+    or<T extends core.SomeType>(option: T): YatspUnion<[this, T]>;
+    and<T extends core.SomeType>(incoming: T): YatspIntersection<this, T>;
+    transform<NewOut>(transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>): YatspPipe<this, YatspTransform<Awaited<NewOut>, core.output<this>>>;
+    catch(def: core.output<this>): YatspCatch<this>;
+    catch(def: (ctx: core.$YatspCatchCtx) => core.output<this>): YatspCatch<this>;
+    pipe<T extends core.$YatspType<any, core.output<this>>>(target: T | core.$YatspType<any, core.output<this>>): YatspPipe<this, T>;
+    readonly(): YatspReadonly<this>;
+    /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+    describe(description: string): this;
+    description?: string;
+    /** Returns the metadata associated with this instance in `z.globalRegistry` */
+    meta(): core.$replace<core.GlobalMeta, this> | undefined;
+    /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+    meta(data: core.$replace<core.GlobalMeta, this>): this;
+    /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+     *
+     * ```ts
+     * const schema = z.string().optional();
+     * const isOptional = schema.safeParse(undefined).success; // true
+     * ```
+     */
+    isOptional(): boolean;
+    /**
+     * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+     *
+     * ```ts
+     * const schema = z.string().nullable();
+     * const isNullable = schema.safeParse(null).success; // true
+     * ```
+     */
+    isNullable(): boolean;
+    apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
+}
+export interface _YatspType<out Internals extends core.$YatspTypeInternals = core.$YatspTypeInternals> extends YatspType<any, any, Internals> {
+}
+export declare const YatspType: core.$constructor<YatspType>;
+export interface _YatspString<T extends core.$YatspStringInternals<unknown> = core.$YatspStringInternals<unknown>> extends _YatspType<T> {
+    format: string | null;
+    minLength: number | null;
+    maxLength: number | null;
+    regex(regex: RegExp, params?: string | core.$YatspCheckRegexParams): this;
+    includes(value: string, params?: string | core.$YatspCheckIncludesParams): this;
+    startsWith(value: string, params?: string | core.$YatspCheckStartsWithParams): this;
+    endsWith(value: string, params?: string | core.$YatspCheckEndsWithParams): this;
+    min(minLength: number, params?: string | core.$YatspCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | core.$YatspCheckMaxLengthParams): this;
+    length(len: number, params?: string | core.$YatspCheckLengthEqualsParams): this;
+    nonempty(params?: string | core.$YatspCheckMinLengthParams): this;
+    lowercase(params?: string | core.$YatspCheckLowerCaseParams): this;
+    uppercase(params?: string | core.$YatspCheckUpperCaseParams): this;
+    trim(): this;
+    normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+    toLowerCase(): this;
+    toUpperCase(): this;
+    slugify(): this;
+}
+/** @internal */
+export declare const _YatspString: core.$constructor<_YatspString>;
+export interface YatspString extends _YatspString<core.$YatspStringInternals<string>> {
+    /** @deprecated Use `z.email()` instead. */
+    email(params?: string | core.$YatspCheckEmailParams): this;
+    /** @deprecated Use `z.url()` instead. */
+    url(params?: string | core.$YatspCheckURLParams): this;
+    /** @deprecated Use `z.jwt()` instead. */
+    jwt(params?: string | core.$YatspCheckJWTParams): this;
+    /** @deprecated Use `z.emoji()` instead. */
+    emoji(params?: string | core.$YatspCheckEmojiParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | core.$YatspCheckGUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuid(params?: string | core.$YatspCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv4(params?: string | core.$YatspCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv6(params?: string | core.$YatspCheckUUIDParams): this;
+    /** @deprecated Use `z.uuid()` instead. */
+    uuidv7(params?: string | core.$YatspCheckUUIDParams): this;
+    /** @deprecated Use `z.nanoid()` instead. */
+    nanoid(params?: string | core.$YatspCheckNanoIDParams): this;
+    /** @deprecated Use `z.guid()` instead. */
+    guid(params?: string | core.$YatspCheckGUIDParams): this;
+    /**
+     * @deprecated CUID v1 is deprecated by its authors due to information leakage
+     * (timestamps embedded in the id). Use `z.cuid2()` instead.
+     * See https://github.com/paralleldrive/cuid.
+     */
+    cuid(params?: string | core.$YatspCheckCUIDParams): this;
+    /** @deprecated Use `z.cuid2()` instead. */
+    cuid2(params?: string | core.$YatspCheckCUID2Params): this;
+    /** @deprecated Use `z.ulid()` instead. */
+    ulid(params?: string | core.$YatspCheckULIDParams): this;
+    /** @deprecated Use `z.base64()` instead. */
+    base64(params?: string | core.$YatspCheckBase64Params): this;
+    /** @deprecated Use `z.base64url()` instead. */
+    base64url(params?: string | core.$YatspCheckBase64URLParams): this;
+    /** @deprecated Use `z.xid()` instead. */
+    xid(params?: string | core.$YatspCheckXIDParams): this;
+    /** @deprecated Use `z.ksuid()` instead. */
+    ksuid(params?: string | core.$YatspCheckKSUIDParams): this;
+    /** @deprecated Use `z.ipv4()` instead. */
+    ipv4(params?: string | core.$YatspCheckIPv4Params): this;
+    /** @deprecated Use `z.ipv6()` instead. */
+    ipv6(params?: string | core.$YatspCheckIPv6Params): this;
+    /** @deprecated Use `z.cidrv4()` instead. */
+    cidrv4(params?: string | core.$YatspCheckCIDRv4Params): this;
+    /** @deprecated Use `z.cidrv6()` instead. */
+    cidrv6(params?: string | core.$YatspCheckCIDRv6Params): this;
+    /** @deprecated Use `z.e164()` instead. */
+    e164(params?: string | core.$YatspCheckE164Params): this;
+    /** @deprecated Use `z.iso.datetime()` instead. */
+    datetime(params?: string | core.$YatspCheckISODateTimeParams): this;
+    /** @deprecated Use `z.iso.date()` instead. */
+    date(params?: string | core.$YatspCheckISODateParams): this;
+    /** @deprecated Use `z.iso.time()` instead. */
+    time(params?: string | core.$YatspCheckISOTimeParams): this;
+    /** @deprecated Use `z.iso.duration()` instead. */
+    duration(params?: string | core.$YatspCheckISODurationParams): this;
+}
+export declare const YatspString: core.$constructor<YatspString>;
+export declare function string(params?: string | core.$YatspStringParams): YatspString;
+export declare function string<T extends string>(params?: string | core.$YatspStringParams): core.$YatspType<T, T>;
+export interface YatspStringFormat<Format extends string = string> extends _YatspString<core.$YatspStringFormatInternals<Format>> {
+}
+export declare const YatspStringFormat: core.$constructor<YatspStringFormat>;
+export interface YatspISODateTime extends YatspStringFormat {
+    _yatsp: core.$YatspISODateTimeInternals;
+}
+export declare const YatspISODateTime: core.$constructor<YatspISODateTime>;
+export interface YatspISODate extends YatspStringFormat {
+    _yatsp: core.$YatspISODateInternals;
+}
+export declare const YatspISODate: core.$constructor<YatspISODate>;
+export interface YatspISOTime extends YatspStringFormat {
+    _yatsp: core.$YatspISOTimeInternals;
+}
+export declare const YatspISOTime: core.$constructor<YatspISOTime>;
+export interface YatspISODuration extends YatspStringFormat {
+    _yatsp: core.$YatspISODurationInternals;
+}
+export declare const YatspISODuration: core.$constructor<YatspISODuration>;
+export interface YatspEmail extends YatspStringFormat<"email"> {
+    _yatsp: core.$YatspEmailInternals;
+}
+export declare const YatspEmail: core.$constructor<YatspEmail>;
+export declare function email(params?: string | core.$YatspEmailParams): YatspEmail;
+export interface YatspGUID extends YatspStringFormat<"guid"> {
+    _yatsp: core.$YatspGUIDInternals;
+}
+export declare const YatspGUID: core.$constructor<YatspGUID>;
+export declare function guid(params?: string | core.$YatspGUIDParams): YatspGUID;
+export interface YatspUUID extends YatspStringFormat<"uuid"> {
+    _yatsp: core.$YatspUUIDInternals;
+}
+export declare const YatspUUID: core.$constructor<YatspUUID>;
+export declare function uuid(params?: string | core.$YatspUUIDParams): YatspUUID;
+export declare function uuidv4(params?: string | core.$YatspUUIDv4Params): YatspUUID;
+export declare function uuidv6(params?: string | core.$YatspUUIDv6Params): YatspUUID;
+export declare function uuidv7(params?: string | core.$YatspUUIDv7Params): YatspUUID;
+export interface YatspURL extends YatspStringFormat<"url"> {
+    _yatsp: core.$YatspURLInternals;
+}
+export declare const YatspURL: core.$constructor<YatspURL>;
+export declare function url(params?: string | core.$YatspURLParams): YatspURL;
+export declare function httpUrl(params?: string | Omit<core.$YatspURLParams, "protocol" | "hostname">): YatspURL;
+export interface YatspEmoji extends YatspStringFormat<"emoji"> {
+    _yatsp: core.$YatspEmojiInternals;
+}
+export declare const YatspEmoji: core.$constructor<YatspEmoji>;
+export declare function emoji(params?: string | core.$YatspEmojiParams): YatspEmoji;
+export interface YatspNanoID extends YatspStringFormat<"nanoid"> {
+    _yatsp: core.$YatspNanoIDInternals;
+}
+export declare const YatspNanoID: core.$constructor<YatspNanoID>;
+export declare function nanoid(params?: string | core.$YatspNanoIDParams): YatspNanoID;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link YatspCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export interface YatspCUID extends YatspStringFormat<"cuid"> {
+    _yatsp: core.$YatspCUIDInternals;
+}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link YatspCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export declare const YatspCUID: core.$constructor<YatspCUID>;
+/**
+ * Validates a CUID v1 string.
+ *
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export declare function cuid(params?: string | core.$YatspCUIDParams): YatspCUID;
+export interface YatspCUID2 extends YatspStringFormat<"cuid2"> {
+    _yatsp: core.$YatspCUID2Internals;
+}
+export declare const YatspCUID2: core.$constructor<YatspCUID2>;
+export declare function cuid2(params?: string | core.$YatspCUID2Params): YatspCUID2;
+export interface YatspULID extends YatspStringFormat<"ulid"> {
+    _yatsp: core.$YatspULIDInternals;
+}
+export declare const YatspULID: core.$constructor<YatspULID>;
+export declare function ulid(params?: string | core.$YatspULIDParams): YatspULID;
+export interface YatspXID extends YatspStringFormat<"xid"> {
+    _yatsp: core.$YatspXIDInternals;
+}
+export declare const YatspXID: core.$constructor<YatspXID>;
+export declare function xid(params?: string | core.$YatspXIDParams): YatspXID;
+export interface YatspKSUID extends YatspStringFormat<"ksuid"> {
+    _yatsp: core.$YatspKSUIDInternals;
+}
+export declare const YatspKSUID: core.$constructor<YatspKSUID>;
+export declare function ksuid(params?: string | core.$YatspKSUIDParams): YatspKSUID;
+export interface YatspIPv4 extends YatspStringFormat<"ipv4"> {
+    _yatsp: core.$YatspIPv4Internals;
+}
+export declare const YatspIPv4: core.$constructor<YatspIPv4>;
+export declare function ipv4(params?: string | core.$YatspIPv4Params): YatspIPv4;
+export interface YatspMAC extends YatspStringFormat<"mac"> {
+    _yatsp: core.$YatspMACInternals;
+}
+export declare const YatspMAC: core.$constructor<YatspMAC>;
+export declare function mac(params?: string | core.$YatspMACParams): YatspMAC;
+export interface YatspIPv6 extends YatspStringFormat<"ipv6"> {
+    _yatsp: core.$YatspIPv6Internals;
+}
+export declare const YatspIPv6: core.$constructor<YatspIPv6>;
+export declare function ipv6(params?: string | core.$YatspIPv6Params): YatspIPv6;
+export interface YatspCIDRv4 extends YatspStringFormat<"cidrv4"> {
+    _yatsp: core.$YatspCIDRv4Internals;
+}
+export declare const YatspCIDRv4: core.$constructor<YatspCIDRv4>;
+export declare function cidrv4(params?: string | core.$YatspCIDRv4Params): YatspCIDRv4;
+export interface YatspCIDRv6 extends YatspStringFormat<"cidrv6"> {
+    _yatsp: core.$YatspCIDRv6Internals;
+}
+export declare const YatspCIDRv6: core.$constructor<YatspCIDRv6>;
+export declare function cidrv6(params?: string | core.$YatspCIDRv6Params): YatspCIDRv6;
+export interface YatspBase64 extends YatspStringFormat<"base64"> {
+    _yatsp: core.$YatspBase64Internals;
+}
+export declare const YatspBase64: core.$constructor<YatspBase64>;
+export declare function base64(params?: string | core.$YatspBase64Params): YatspBase64;
+export interface YatspBase64URL extends YatspStringFormat<"base64url"> {
+    _yatsp: core.$YatspBase64URLInternals;
+}
+export declare const YatspBase64URL: core.$constructor<YatspBase64URL>;
+export declare function base64url(params?: string | core.$YatspBase64URLParams): YatspBase64URL;
+export interface YatspE164 extends YatspStringFormat<"e164"> {
+    _yatsp: core.$YatspE164Internals;
+}
+export declare const YatspE164: core.$constructor<YatspE164>;
+export declare function e164(params?: string | core.$YatspE164Params): YatspE164;
+export interface YatspCreditCard extends YatspStringFormat<"credit_card"> {
+    _yatsp: core.$YatspCreditCardInternals;
+}
+export declare const YatspCreditCard: core.$constructor<YatspCreditCard>;
+export declare function creditCard(params?: string | core.$YatspCreditCardParams): YatspCreditCard;
+export interface YatspIBAN extends YatspStringFormat<"iban"> {
+    _yatsp: core.$YatspIBANInternals;
+}
+export declare const YatspIBAN: core.$constructor<YatspIBAN>;
+export declare function iban(params?: string | core.$YatspIBANParams): YatspIBAN;
+export interface YatspJWT extends YatspStringFormat<"jwt"> {
+    _yatsp: core.$YatspJWTInternals;
+}
+export declare const YatspJWT: core.$constructor<YatspJWT>;
+export declare function jwt(params?: string | core.$YatspJWTParams): YatspJWT;
+export interface YatspCustomStringFormat<Format extends string = string> extends YatspStringFormat<Format>, core.$YatspCustomStringFormat<Format> {
+    _yatsp: core.$YatspCustomStringFormatInternals<Format>;
+    "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export declare const YatspCustomStringFormat: core.$constructor<YatspCustomStringFormat>;
+export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$YatspStringFormatParams): YatspCustomStringFormat<Format>;
+export declare function hostname(_params?: string | core.$YatspStringFormatParams): YatspCustomStringFormat<"hostname">;
+export declare function hex(_params?: string | core.$YatspStringFormatParams): YatspCustomStringFormat<"hex">;
+export declare function currencyCode(_params?: string | core.$YatspStringFormatParams): YatspCustomStringFormat<"currency_code">;
+export declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = "hex">(alg: Alg, params?: {
+    enc?: Enc;
+} & core.$YatspStringFormatParams): YatspCustomStringFormat<`${Alg}_${Enc}`>;
+export interface _YatspNumber<Internals extends core.$YatspNumberInternals = core.$YatspNumberInternals> extends _YatspType<Internals> {
+    gt(value: number, params?: string | core.$YatspCheckGreaterThanParams): this;
+    /** Identical to .min() */
+    gte(value: number, params?: string | core.$YatspCheckGreaterThanParams): this;
+    min(value: number, params?: string | core.$YatspCheckGreaterThanParams): this;
+    lt(value: number, params?: string | core.$YatspCheckLessThanParams): this;
+    /** Identical to .max() */
+    lte(value: number, params?: string | core.$YatspCheckLessThanParams): this;
+    max(value: number, params?: string | core.$YatspCheckLessThanParams): this;
+    /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+    int(params?: string | core.$YatspCheckNumberFormatParams): this;
+    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+    safe(params?: string | core.$YatspCheckNumberFormatParams): this;
+    positive(params?: string | core.$YatspCheckGreaterThanParams): this;
+    nonnegative(params?: string | core.$YatspCheckGreaterThanParams): this;
+    negative(params?: string | core.$YatspCheckLessThanParams): this;
+    nonpositive(params?: string | core.$YatspCheckLessThanParams): this;
+    multipleOf(value: number, params?: string | core.$YatspCheckMultipleOfParams): this;
+    /** @deprecated Use `.multipleOf()` instead. */
+    step(value: number, params?: string | core.$YatspCheckMultipleOfParams): this;
+    /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+    finite(params?: unknown): this;
+    minValue: number | null;
+    maxValue: number | null;
+    /** @deprecated Check the `format` property instead.  */
+    isInt: boolean;
+    /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+    isFinite: boolean;
+    format: string | null;
+}
+export interface YatspNumber extends _YatspNumber<core.$YatspNumberInternals<number>> {
+}
+export declare const YatspNumber: core.$constructor<YatspNumber>;
+export declare function number(params?: string | core.$YatspNumberParams): YatspNumber;
+export interface YatspNumberFormat<Format extends $YatspNumberFormats = $YatspNumberFormats> extends YatspNumber {
+    _yatsp: core.$YatspNumberFormatInternals<Format>;
+}
+export declare const YatspNumberFormat: core.$constructor<YatspNumberFormat>;
+export interface YatspInt extends YatspNumberFormat<"safeint"> {
+}
+export declare function int(params?: string | core.$YatspCheckNumberFormatParams): YatspInt;
+export interface YatspFloat32 extends YatspNumberFormat<"float32"> {
+}
+export declare function float32(params?: string | core.$YatspCheckNumberFormatParams): YatspFloat32;
+export interface YatspFloat64 extends YatspNumberFormat<"float64"> {
+}
+export declare function float64(params?: string | core.$YatspCheckNumberFormatParams): YatspFloat64;
+export interface YatspInt32 extends YatspNumberFormat<"int32"> {
+}
+export declare function int32(params?: string | core.$YatspCheckNumberFormatParams): YatspInt32;
+export interface YatspUInt32 extends YatspNumberFormat<"uint32"> {
+}
+export declare function uint32(params?: string | core.$YatspCheckNumberFormatParams): YatspUInt32;
+export interface _YatspBoolean<T extends core.$YatspBooleanInternals = core.$YatspBooleanInternals> extends _YatspType<T> {
+}
+export interface YatspBoolean extends _YatspBoolean<core.$YatspBooleanInternals<boolean>> {
+}
+export declare const YatspBoolean: core.$constructor<YatspBoolean>;
+export declare function boolean(params?: string | core.$YatspBooleanParams): YatspBoolean;
+export interface _YatspBigInt<T extends core.$YatspBigIntInternals = core.$YatspBigIntInternals> extends _YatspType<T> {
+    gte(value: bigint, params?: string | core.$YatspCheckGreaterThanParams): this;
+    /** Alias of `.gte()` */
+    min(value: bigint, params?: string | core.$YatspCheckGreaterThanParams): this;
+    gt(value: bigint, params?: string | core.$YatspCheckGreaterThanParams): this;
+    /** Alias of `.lte()` */
+    lte(value: bigint, params?: string | core.$YatspCheckLessThanParams): this;
+    max(value: bigint, params?: string | core.$YatspCheckLessThanParams): this;
+    lt(value: bigint, params?: string | core.$YatspCheckLessThanParams): this;
+    positive(params?: string | core.$YatspCheckGreaterThanParams): this;
+    negative(params?: string | core.$YatspCheckLessThanParams): this;
+    nonpositive(params?: string | core.$YatspCheckLessThanParams): this;
+    nonnegative(params?: string | core.$YatspCheckGreaterThanParams): this;
+    multipleOf(value: bigint, params?: string | core.$YatspCheckMultipleOfParams): this;
+    minValue: bigint | null;
+    maxValue: bigint | null;
+    format: string | null;
+}
+export interface YatspBigInt extends _YatspBigInt<core.$YatspBigIntInternals<bigint>> {
+}
+export declare const YatspBigInt: core.$constructor<YatspBigInt>;
+export declare function bigint(params?: string | core.$YatspBigIntParams): YatspBigInt;
+export interface YatspBigIntFormat<Format extends $YatspBigIntFormats = $YatspBigIntFormats> extends YatspBigInt {
+    _yatsp: core.$YatspBigIntFormatInternals<Format>;
+}
+export declare const YatspBigIntFormat: core.$constructor<YatspBigIntFormat>;
+export interface YatspInt64 extends YatspBigIntFormat<"int64"> {
+}
+export declare function int64(params?: string | core.$YatspBigIntFormatParams): YatspInt64;
+export interface YatspUInt64 extends YatspBigIntFormat<"uint64"> {
+}
+export declare function uint64(params?: string | core.$YatspBigIntFormatParams): YatspUInt64;
+export interface YatspSymbol extends _YatspType<core.$YatspSymbolInternals> {
+}
+export declare const YatspSymbol: core.$constructor<YatspSymbol>;
+export declare function symbol(params?: string | core.$YatspSymbolParams): YatspSymbol;
+export interface YatspUndefined extends _YatspType<core.$YatspUndefinedInternals> {
+}
+export declare const YatspUndefined: core.$constructor<YatspUndefined>;
+declare function _undefined(params?: string | core.$YatspUndefinedParams): YatspUndefined;
+export { _undefined as undefined };
+export interface YatspNull extends _YatspType<core.$YatspNullInternals> {
+}
+export declare const YatspNull: core.$constructor<YatspNull>;
+declare function _null(params?: string | core.$YatspNullParams): YatspNull;
+export { _null as null };
+export interface YatspAny extends _YatspType<core.$YatspAnyInternals> {
+}
+export declare const YatspAny: core.$constructor<YatspAny>;
+export declare function any(): YatspAny;
+export interface YatspUnknown extends _YatspType<core.$YatspUnknownInternals> {
+}
+export declare const YatspUnknown: core.$constructor<YatspUnknown>;
+export declare function unknown(): YatspUnknown;
+export interface YatspNever extends _YatspType<core.$YatspNeverInternals> {
+}
+export declare const YatspNever: core.$constructor<YatspNever>;
+export declare function never(params?: string | core.$YatspNeverParams): YatspNever;
+export interface YatspVoid extends _YatspType<core.$YatspVoidInternals> {
+}
+export declare const YatspVoid: core.$constructor<YatspVoid>;
+declare function _void(params?: string | core.$YatspVoidParams): YatspVoid;
+export { _void as void };
+export interface _YatspDate<T extends core.$YatspDateInternals = core.$YatspDateInternals> extends _YatspType<T> {
+    min(value: number | Date, params?: string | core.$YatspCheckGreaterThanParams): this;
+    max(value: number | Date, params?: string | core.$YatspCheckLessThanParams): this;
+    /** @deprecated Not recommended. */
+    minDate: Date | null;
+    /** @deprecated Not recommended. */
+    maxDate: Date | null;
+}
+export interface YatspDate extends _YatspDate<core.$YatspDateInternals<Date>> {
+}
+export declare const YatspDate: core.$constructor<YatspDate>;
+export declare function date(params?: string | core.$YatspDateParams): YatspDate;
+export interface YatspArray<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspArrayInternals<T>>, core.$YatspArray<T> {
+    element: T;
+    min(minLength: number, params?: string | core.$YatspCheckMinLengthParams): this;
+    nonempty(params?: string | core.$YatspCheckMinLengthParams): this;
+    max(maxLength: number, params?: string | core.$YatspCheckMaxLengthParams): this;
+    length(len: number, params?: string | core.$YatspCheckLengthEqualsParams): this;
+    unwrap(): T;
+    "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export declare const YatspArray: core.$constructor<YatspArray>;
+export declare function array<T extends core.SomeType>(element: T, params?: string | core.$YatspArrayParams): YatspArray<T>;
+export declare function keyof<T extends YatspObject>(schema: T): YatspEnum<util.KeysEnum<T["_yatsp"]["output"]>>;
+export type SafeExtendShape<Base extends core.$YatspShape, Ext extends core.$YatspLooseShape> = {
+    [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
+};
+export interface YatspObject<
+/** @ts-ignore Cast variance */
+out Shape extends core.$YatspShape = core.$YatspLooseShape, out Config extends core.$YatspObjectConfig = core.$strip> extends _YatspType<core.$YatspObjectInternals<Shape, Config>>, core.$YatspObject<Shape, Config> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    shape: Shape;
+    keyof(): YatspEnum<util.ToEnum<keyof Shape & string>>;
+    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+    catchall<T extends core.SomeType>(schema: T): YatspObject<Shape, core.$catchall<T>>;
+    /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+    passthrough(): YatspObject<Shape, core.$loose>;
+    /** Consider `z.looseObject(A.shape)` instead */
+    loose(): YatspObject<Shape, core.$loose>;
+    /** Consider `z.strictObject(A.shape)` instead */
+    strict(): YatspObject<Shape, core.$strict>;
+    /** This is the default behavior. This method call is likely unnecessary. */
+    strip(): YatspObject<Shape, core.$strip>;
+    extend<U extends core.$YatspLooseShape>(shape: U): YatspObject<util.Extend<Shape, util.Writeable<U>>, Config>;
+    safeExtend<U extends core.$YatspLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>): YatspObject<util.Extend<Shape, util.Writeable<U>>, Config>;
+    /**
+     * @deprecated Use [`A.extend(B.shape)`](https://yatsp.dev/api?id=extend) instead.
+     */
+    merge<U extends YatspObject>(other: U): YatspObject<util.Extend<Shape, U["shape"]>, U["_yatsp"]["config"]>;
+    pick<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): YatspObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    omit<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): YatspObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+    partial(): YatspObject<{
+        -readonly [k in keyof Shape]: YatspOptional<Shape[k]>;
+    }, Config>;
+    partial<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): YatspObject<{
+        -readonly [k in keyof Shape]: k extends keyof M ? YatspOptional<Shape[k]> : Shape[k];
+    }, Config>;
+    exactPartial(): YatspObject<{
+        -readonly [k in keyof Shape]: YatspExactOptional<Shape[k]>;
+    }, Config>;
+    exactPartial<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): YatspObject<{
+        -readonly [k in keyof Shape]: k extends keyof M ? YatspExactOptional<Shape[k]> : Shape[k];
+    }, Config>;
+    required(): YatspObject<{
+        -readonly [k in keyof Shape]: YatspNonOptional<Shape[k]>;
+    }, Config>;
+    required<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): YatspObject<{
+        -readonly [k in keyof Shape]: k extends keyof M ? YatspNonOptional<Shape[k]> : Shape[k];
+    }, Config>;
+}
+export declare const YatspObject: core.$constructor<YatspObject>;
+export declare function object<T extends core.$YatspLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$YatspObjectParams): YatspObject<util.Writeable<T>, core.$strip>;
+export declare function strictObject<T extends core.$YatspLooseShape>(shape: T, params?: string | core.$YatspObjectParams): YatspObject<util.Writeable<T>, core.$strict>;
+export declare function looseObject<T extends core.$YatspLooseShape>(shape: T, params?: string | core.$YatspObjectParams): YatspObject<util.Writeable<T>, core.$loose>;
+export interface YatspUnion<T extends readonly core.SomeType[] = readonly core.$YatspType[]> extends _YatspType<core.$YatspUnionInternals<T>>, core.$YatspUnion<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    options: T;
+}
+export declare const YatspUnion: core.$constructor<YatspUnion>;
+export declare function union<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$YatspUnionParams): YatspUnion<T>;
+export interface YatspXor<T extends readonly core.SomeType[] = readonly core.$YatspType[]> extends _YatspType<core.$YatspXorInternals<T>>, core.$YatspXor<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    options: T;
+}
+export declare const YatspXor: core.$constructor<YatspXor>;
+/** Creates an exclusive union (XOR) where exactly one option must match.
+ * Unlike regular unions that succeed when any option matches, xor fails if
+ * zero or more than one option matches the input. */
+export declare function xor<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$YatspXorParams): YatspXor<T>;
+export interface YatspDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$YatspType[], Disc extends string = string> extends YatspUnion<Options>, core.$YatspDiscriminatedUnion<Options, Disc> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    _yatsp: core.$YatspDiscriminatedUnionInternals<Options, Disc>;
+    def: core.$YatspDiscriminatedUnionDef<Options, Disc>;
+}
+export declare const YatspDiscriminatedUnion: core.$constructor<YatspDiscriminatedUnion>;
+export declare function discriminatedUnion<Types extends readonly [core.$YatspTypeDiscriminable, ...core.$YatspTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$YatspDiscriminatedUnionParams): YatspDiscriminatedUnion<Types, Disc>;
+export interface YatspIntersection<A extends core.SomeType = core.$YatspType, B extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspIntersectionInternals<A, B>>, core.$YatspIntersection<A, B> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export declare const YatspIntersection: core.$constructor<YatspIntersection>;
+export declare function intersection<T extends core.SomeType, U extends core.SomeType>(left: T, right: U): YatspIntersection<T, U>;
+export interface YatspTuple<T extends util.TupleItems = readonly core.$YatspType[], Rest extends core.SomeType | null = core.$YatspType | null> extends _YatspType<core.$YatspTupleInternals<T, Rest>>, core.$YatspTuple<T, Rest> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    rest<Rest extends core.SomeType = core.$YatspType>(rest: Rest): YatspTuple<T, Rest>;
+    partial(): YatspTuple<{
+        -readonly [k in keyof T]: YatspOptional<T[k]>;
+    }, Rest>;
+}
+export declare const YatspTuple: core.$constructor<YatspTuple>;
+export declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]]>(items: T, params?: string | core.$YatspTupleParams): YatspTuple<T, null>;
+export declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], Rest extends core.SomeType>(items: T, rest: Rest, params?: string | core.$YatspTupleParams): YatspTuple<T, Rest>;
+export declare function tuple(items: [], params?: string | core.$YatspTupleParams): YatspTuple<[], null>;
+export interface YatspRecord<Key extends core.$YatspRecordKey = core.$YatspRecordKey, Value extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspRecordInternals<Key, Value>>, core.$YatspRecord<Key, Value> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    keyType: Key;
+    valueType: Value;
+}
+export declare const YatspRecord: core.$constructor<YatspRecord>;
+export declare function record<Key extends core.$YatspRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$YatspRecordParams): YatspRecord<Key, Value>;
+export declare function partialRecord<Key extends core.$YatspRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$YatspRecordParams): YatspRecord<Key & core.$partial, Value>;
+export declare function looseRecord<Key extends core.$YatspRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$YatspRecordParams): YatspRecord<Key, Value>;
+export interface YatspMap<Key extends core.SomeType = core.$YatspType, Value extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspMapInternals<Key, Value>>, core.$YatspMap<Key, Value> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    keyType: Key;
+    valueType: Value;
+    min(minSize: number, params?: string | core.$YatspCheckMinSizeParams): this;
+    nonempty(params?: string | core.$YatspCheckMinSizeParams): this;
+    max(maxSize: number, params?: string | core.$YatspCheckMaxSizeParams): this;
+    size(size: number, params?: string | core.$YatspCheckSizeEqualsParams): this;
+}
+export declare const YatspMap: core.$constructor<YatspMap>;
+export declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$YatspMapParams): YatspMap<Key, Value>;
+export interface YatspSet<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspSetInternals<T>>, core.$YatspSet<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    min(minSize: number, params?: string | core.$YatspCheckMinSizeParams): this;
+    nonempty(params?: string | core.$YatspCheckMinSizeParams): this;
+    max(maxSize: number, params?: string | core.$YatspCheckMaxSizeParams): this;
+    size(size: number, params?: string | core.$YatspCheckSizeEqualsParams): this;
+}
+export declare const YatspSet: core.$constructor<YatspSet>;
+export declare function set<Value extends core.SomeType>(valueType: Value, params?: string | core.$YatspSetParams): YatspSet<Value>;
+export interface YatspEnum<
+/** @ts-ignore Cast variance */
+out T extends util.EnumLike = util.EnumLike> extends _YatspType<core.$YatspEnumInternals<T>>, core.$YatspEnum<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    enum: T;
+    options: Array<T[keyof T]>;
+    extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$YatspEnumParams): YatspEnum<util.Flatten<Pick<T, U[number]>>>;
+    exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$YatspEnumParams): YatspEnum<util.Flatten<Omit<T, U[number]>>>;
+}
+export declare const YatspEnum: core.$constructor<YatspEnum>;
+declare function _enum<const T extends readonly string[]>(values: T, params?: string | core.$YatspEnumParams): YatspEnum<util.ToEnum<T[number]>>;
+declare function _enum<const T extends util.EnumLike>(entries: T, params?: string | core.$YatspEnumParams): YatspEnum<T>;
+export { _enum as enum };
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+export declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$YatspEnumParams): YatspEnum<T>;
+export interface YatspLiteral<T extends util.Literal = util.Literal> extends _YatspType<core.$YatspLiteralInternals<T>>, core.$YatspLiteral<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    values: Set<T>;
+    /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+    value: T;
+}
+export declare const YatspLiteral: core.$constructor<YatspLiteral>;
+export declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$YatspLiteralParams): YatspLiteral<T[number]>;
+export declare function literal<const T extends util.Literal>(value: T, params?: string | core.$YatspLiteralParams): YatspLiteral<T>;
+export interface YatspFile extends _YatspType<core.$YatspFileInternals>, core.$YatspFile {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    min(size: number, params?: string | core.$YatspCheckMinSizeParams): this;
+    max(size: number, params?: string | core.$YatspCheckMaxSizeParams): this;
+    mime(types: util.MimeTypes | Array<util.MimeTypes>, params?: string | core.$YatspCheckMimeTypeParams): this;
+}
+export declare const YatspFile: core.$constructor<YatspFile>;
+export declare function file(params?: string | core.$YatspFileParams): YatspFile;
+export interface YatspTransform<O = unknown, I = unknown> extends _YatspType<core.$YatspTransformInternals<O, I>>, core.$YatspTransform<O, I> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export declare const YatspTransform: core.$constructor<YatspTransform>;
+export declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.$RefinementCtx) => O): YatspTransform<Awaited<O>, I>;
+export interface YatspOptional<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspOptionalInternals<T>>, core.$YatspOptional<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspOptional: core.$constructor<YatspOptional>;
+export declare function optional<T extends core.SomeType>(innerType: T): YatspOptional<T>;
+export interface YatspExactOptional<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspExactOptionalInternals<T>>, core.$YatspExactOptional<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspExactOptional: core.$constructor<YatspExactOptional>;
+export declare function exactOptional<T extends core.SomeType>(innerType: T): YatspExactOptional<T>;
+export interface YatspNullable<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspNullableInternals<T>>, core.$YatspNullable<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspNullable: core.$constructor<YatspNullable>;
+export declare function nullable<T extends core.SomeType>(innerType: T): YatspNullable<T>;
+export declare function nullish<T extends core.SomeType>(innerType: T): YatspOptional<YatspNullable<T>>;
+export interface YatspDefault<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspDefaultInternals<T>>, core.$YatspDefault<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeDefault(): T;
+}
+export declare const YatspDefault: core.$constructor<YatspDefault>;
+export declare function _default<T extends core.SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): YatspDefault<T>;
+export interface YatspPrefault<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspPrefaultInternals<T>>, core.$YatspPrefault<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspPrefault: core.$constructor<YatspPrefault>;
+export declare function prefault<T extends core.SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): YatspPrefault<T>;
+export interface YatspNonOptional<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspNonOptionalInternals<T>>, core.$YatspNonOptional<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspNonOptional: core.$constructor<YatspNonOptional>;
+export declare function nonoptional<T extends core.SomeType>(innerType: T, params?: string | core.$YatspNonOptionalParams): YatspNonOptional<T>;
+export interface YatspSuccess<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspSuccessInternals<T>>, core.$YatspSuccess<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspSuccess: core.$constructor<YatspSuccess>;
+export declare function success<T extends core.SomeType>(innerType: T): YatspSuccess<T>;
+export interface YatspCatch<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspCatchInternals<T>>, core.$YatspCatch<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+    /** @deprecated Use `.unwrap()` instead. */
+    removeCatch(): T;
+}
+export declare const YatspCatch: core.$constructor<YatspCatch>;
+declare function _catch<T extends core.SomeType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$YatspCatchCtx) => core.output<T>)): YatspCatch<T>;
+export { _catch as catch };
+export interface YatspNaN extends _YatspType<core.$YatspNaNInternals>, core.$YatspNaN {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export declare const YatspNaN: core.$constructor<YatspNaN>;
+export declare function nan(params?: string | core.$YatspNaNParams): YatspNaN;
+export interface YatspPipe<A extends core.SomeType = core.$YatspType, B extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspPipeInternals<A, B>>, core.$YatspPipe<A, B> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    in: A;
+    out: B;
+}
+export declare const YatspPipe: core.$constructor<YatspPipe>;
+export declare function pipe<const A extends core.SomeType, B extends core.$YatspType<unknown, core.output<A>> = core.$YatspType<unknown, core.output<A>>>(in_: A, out: B | core.$YatspType<unknown, core.output<A>>): YatspPipe<A, B>;
+export interface YatspCodec<A extends core.SomeType = core.$YatspType, B extends core.SomeType = core.$YatspType> extends YatspPipe<A, B>, core.$YatspCodec<A, B> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    _yatsp: core.$YatspCodecInternals<A, B>;
+    def: core.$YatspCodecDef<A, B>;
+}
+export declare const YatspCodec: core.$constructor<YatspCodec>;
+export declare function codec<const A extends core.SomeType, B extends core.SomeType = core.$YatspType>(in_: A, out: B, params: {
+    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;
+    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;
+}): YatspCodec<A, B>;
+export declare function invertCodec<A extends core.SomeType, B extends core.SomeType>(codec: YatspCodec<A, B>): YatspCodec<B, A>;
+export interface YatspPreprocess<B extends core.SomeType = core.$YatspType, I = unknown> extends YatspPipe<core.$YatspTransform<unknown, I>, B>, core.$YatspPreprocess<B, I> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    _yatsp: core.$YatspPreprocessInternals<B, I>;
+    def: core.$YatspPreprocessDef<B, I>;
+}
+export declare const YatspPreprocess: core.$constructor<YatspPreprocess>;
+export interface YatspReadonly<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspReadonlyInternals<T>>, core.$YatspReadonly<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspReadonly: core.$constructor<YatspReadonly>;
+export declare function readonly<T extends core.SomeType>(innerType: T): YatspReadonly<T>;
+export interface YatspTemplateLiteral<Template extends string = string> extends _YatspType<core.$YatspTemplateLiteralInternals<Template>>, core.$YatspTemplateLiteral<Template> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export declare const YatspTemplateLiteral: core.$constructor<YatspTemplateLiteral>;
+export declare function templateLiteral<const Parts extends core.$YatspTemplateLiteralPart[]>(parts: Parts, params?: string | core.$YatspTemplateLiteralParams): YatspTemplateLiteral<core.$PartsToTemplateLiteral<Parts>>;
+export interface YatspLazy<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspLazyInternals<T>>, core.$YatspLazy<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspLazy: core.$constructor<YatspLazy>;
+export declare function lazy<T extends core.SomeType>(getter: () => T): YatspLazy<T>;
+export interface YatspPromise<T extends core.SomeType = core.$YatspType> extends _YatspType<core.$YatspPromiseInternals<T>>, core.$YatspPromise<T> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    unwrap(): T;
+}
+export declare const YatspPromise: core.$constructor<YatspPromise>;
+export declare function promise<T extends core.SomeType>(innerType: T): YatspPromise<T>;
+export interface YatspFunction<Args extends core.$YatspFunctionIn = core.$YatspFunctionIn, Returns extends core.$YatspFunctionOut = core.$YatspFunctionOut> extends _YatspType<core.$YatspFunctionInternals<Args, Returns>>, core.$YatspFunction<Args, Returns> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+    _def: core.$YatspFunctionDef<Args, Returns>;
+    _input: core.$InferInnerFunctionType<Args, Returns>;
+    _output: core.$InferOuterFunctionType<Args, Returns>;
+    input<const Items extends util.TupleItems, const Rest extends core.$YatspFunctionOut = core.$YatspFunctionOut>(args: Items, rest?: Rest): YatspFunction<core.$YatspTuple<Items, Rest>, Returns>;
+    input<NewArgs extends core.$YatspFunctionIn>(args: NewArgs): YatspFunction<NewArgs, Returns>;
+    input(...args: any[]): YatspFunction<any, Returns>;
+    output<NewReturns extends core.$YatspType>(output: NewReturns): YatspFunction<Args, NewReturns>;
+}
+export declare const YatspFunction: core.$constructor<YatspFunction>;
+export declare function _function(): YatspFunction;
+export declare function _function<const In extends ReadonlyArray<core.$YatspType>>(params: {
+    input: In;
+}): YatspFunction<YatspTuple<In, null>, core.$YatspFunctionOut>;
+export declare function _function<const In extends ReadonlyArray<core.$YatspType>, const Out extends core.$YatspFunctionOut = core.$YatspFunctionOut>(params: {
+    input: In;
+    output: Out;
+}): YatspFunction<YatspTuple<In, null>, Out>;
+export declare function _function<const In extends core.$YatspFunctionIn = core.$YatspFunctionIn>(params: {
+    input: In;
+}): YatspFunction<In, core.$YatspFunctionOut>;
+export declare function _function<const Out extends core.$YatspFunctionOut = core.$YatspFunctionOut>(params: {
+    output: Out;
+}): YatspFunction<core.$YatspFunctionIn, Out>;
+export declare function _function<In extends core.$YatspFunctionIn = core.$YatspFunctionIn, Out extends core.$YatspType = core.$YatspType>(params?: {
+    input: In;
+    output: Out;
+}): YatspFunction<In, Out>;
+export { _function as function };
+export interface YatspCustom<O = unknown, I = unknown> extends _YatspType<core.$YatspCustomInternals<O, I>>, core.$YatspCustom<O, I> {
+    "~standard": YatspStandardSchemaWithJSON<this>;
+}
+export declare const YatspCustom: core.$constructor<YatspCustom>;
+export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$YatspCheck<O>;
+export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$YatspCustomParams | undefined): YatspCustom<O, O>;
+export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$YatspCustomParams): core.$YatspCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>, params?: core.$YatspSuperRefineParams): core.$YatspCheck<T>;
+export declare const describe: typeof core.describe;
+export declare const meta: typeof core.meta;
+type YatspInstanceOfParams = core.Params<YatspCustom, core.$YatspIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
+export interface YatspInstanceOf<T = unknown> extends YatspCustom<T, T> {
+    properties<Shape extends {
+        [k in keyof T as T[k] extends Function ? never : k]?: core.$YatspType<unknown, T[k]>;
+    }>(shape: Shape, params?: string | core.$YatspCheckPropertiesParams): YatspInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+}
+export declare const YatspInstanceOf: core.$constructor<YatspInstanceOf>;
+declare function _instanceof<T extends typeof util.Class>(cls: T, params?: YatspInstanceOfParams): YatspInstanceOf<InstanceType<T>>;
+export { _instanceof as instanceof };
+export declare const stringbool: (_params?: string | core.$YatspStringBoolParams) => YatspCodec<YatspString, YatspBoolean>;
+type _YatspJSONSchema = YatspUnion<[
+    YatspString,
+    YatspNumber,
+    YatspBoolean,
+    YatspNull,
+    YatspArray<YatspJSONSchema>,
+    YatspRecord<YatspString, YatspJSONSchema>
+]>;
+type _YatspJSONSchemaInternals = _YatspJSONSchema["_yatsp"];
+export interface YatspJSONSchemaInternals extends _YatspJSONSchemaInternals {
+    output: util.JSONType;
+    input: util.JSONType;
+}
+export interface YatspJSONSchema extends _YatspJSONSchema {
+    _yatsp: YatspJSONSchemaInternals;
+}
+export declare function json(params?: string | core.$YatspCustomParams): YatspJSONSchema;
+export declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): YatspPreprocess<U, B>;