import * as checks from "./checks.cjs";
import type { $ZodNumberFormats } from "./checks.cjs";
import type { $ZodBigIntFormats } from "./checks.cjs";
import * as core from "./core.cjs";
import type * as errors from "./errors.cjs";
import type * as JSONSchema from "./json-schema.cjs";
import type { StandardSchemaV1 } from "./standard-schema.cjs";
import type { ProcessParams, ToJSONSchemaContext } from "./to-json-schema.cjs";
import * as util from "./util.cjs";
import { version } from "./versions.cjs";
export interface ParseContext<T extends errors.$ZodIssueBase = never> {
    /** Customize error messages. */
    readonly error?: errors.$ZodErrorMap<T>;
    /** Include the `input` field in issue objects. Default `false`. */
    readonly reportInput?: boolean;
    /** Skip eval-based fast path. Default `false`. */
    readonly jitless?: boolean;
}
/** @internal */
export interface ParseContextInternal<T extends errors.$ZodIssueBase = never> extends ParseContext<T> {
    readonly async?: boolean | undefined;
    readonly direction?: "forward" | "backward";
    readonly skipChecks?: boolean;
}
/** Gives a container cycle support: `attach` wraps its parse, and `alloc` registers the object it builds into before any child is parsed so a reference back to the same input resolves to it. */
export interface $ZodMemoizer {
    attach(inst: $ZodType): void;
    guard(inst: $ZodType): void;
    alloc<T extends object>(inst: $ZodType, payload: ParsePayload, empty: T, ctx: ParseContextInternal): T;
}
export interface ParsePayload<T = unknown> {
    value: T;
    issues: errors.$ZodRawIssue[];
    /** A way to mark a whole payload as aborted. Used in codecs/pipes. */
    aborted?: boolean;
    /** @internal Set when the value came from a repeat visit to a node still being
     * parsed. Its checks run on the node itself, against the finished value. */
    memo?: boolean | undefined;
}
export type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;
export interface $ZodTypeDef {
    type: "string" | "number" | "int" | "boolean" | "bigint" | "symbol" | "null" | "undefined" | "void" | "never" | "any" | "unknown" | "date" | "object" | "record" | "file" | "array" | "tuple" | "union" | "intersection" | "map" | "set" | "enum" | "literal" | "nullable" | "optional" | "nonoptional" | "success" | "transform" | "default" | "prefault" | "catch" | "nan" | "pipe" | "readonly" | "template_literal" | "promise" | "lazy" | "function" | "custom";
    error?: errors.$ZodErrorMap<never> | undefined;
    checks?: checks.$ZodCheck<never>[];
}
export interface _$ZodTypeInternals {
    /** The `@zod/core` version of this schema */
    version: typeof version;
    /** Schema definition. */
    def: $ZodTypeDef;
    /** @internal Randomly generated ID for this schema. */
    /** @internal List of deferred initializers. */
    deferred: util.AnyFunc[] | undefined;
    /** @internal Parses input and runs all checks (refinements). */
    run(payload: ParsePayload<any>, ctx: ParseContextInternal): util.MaybeAsync<ParsePayload>;
    /** @internal Parses input, doesn't run checks. */
    parse(payload: ParsePayload<any>, ctx: ParseContextInternal): util.MaybeAsync<ParsePayload>;
    /** @internal  Stores identifiers for the set of traits implemented by this schema. */
    traits: Set<string>;
    /** @internal Indicates that a schema output type should be considered optional inside objects.
     * @default Required
     */
    /** @internal Three rungs, each strictly stronger than the last:
     *   undefined    — required; the container may not omit this slot
     *   "optional"   — the container may omit it; nothing is supplied in its place
     *   "defaulted"  — the container may omit it AND this schema substitutes a value
     * Consumers asking "may the slot be absent?" test `!== undefined`.
     * $ZodOptional asks the stronger question and tests `=== "defaulted"`. */
    optin?: "optional" | "defaulted" | undefined;
    /** @internal */
    optout?: "optional" | undefined;
    /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
     *
     * Defined on: enum, const, literal, null, undefined
     * Passthrough: optional, nullable, branded, default, catch, pipe
     * Todo: unions?
     */
    values?: util.PrimitiveSet | undefined;
    /** Default value bubbled up from  */
    /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
    propValues?: util.PropValues | undefined;
    /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
    pattern: RegExp | undefined;
    /** @internal The constructor function of this schema. */
    constr: new (def: any) => $ZodType;
    /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */
    bag: Record<string, unknown>;
    /** @internal The set of issues this schema might throw during type checking. */
    isst: errors.$ZodIssueBase;
    /** @internal Subject to change, not a public API. */
    processJSONSchema?: ((ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams) => void) | undefined;
    /** An optional method used to override `toJSONSchema` logic. */
    toJSONSchema?: () => unknown;
    /** @internal The parent of this schema. Only set during certain clone operations. */
    parent?: $ZodType | undefined;
}
/** @internal */
export interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
    /** @internal The inferred output type */
    output: O;
    /** @internal The inferred input type */
    input: I;
}
export type $ZodStandardSchema<T> = StandardSchemaV1.Props<core.input<T>, core.output<T>>;
export type SomeType = {
    _zod: _$ZodTypeInternals;
};
export interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {
    _zod: Internals;
    "~standard": $ZodStandardSchema<this>;
}
export interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T["output"], T["input"], T> {
}
export declare const $ZodType: core.$constructor<$ZodType>;
export declare function standardProps(inst: $ZodType): StandardSchemaV1.Props<any, any>;
export { clone } from "./util.cjs";
export interface $ZodStringDef extends $ZodTypeDef {
    type: "string";
    coerce?: boolean;
    checks?: checks.$ZodCheck<string>[];
}
export interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {
    def: $ZodStringDef;
    /** @deprecated Internal API, use with caution (not deprecated) */
    pattern: RegExp;
    /** @deprecated Internal API, use with caution (not deprecated) */
    isst: errors.$ZodIssueInvalidType;
    bag: util.LoosePartial<{
        minimum: number;
        maximum: number;
        patterns: Set<RegExp>;
        format: string;
        contentEncoding: string;
        /** the pattern admits strings its `format` keyword forbids, so `toJSONSchema` must not emit it */
        laxFormat: boolean;
    }>;
}
export interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {
}
export declare const $ZodString: core.$constructor<$ZodString>;
export interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, checks.$ZodCheckStringFormatDef<Format> {
}
export interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, checks.$ZodCheckStringFormatInternals {
    def: $ZodStringFormatDef<Format>;
}
export interface $ZodStringFormat<Format extends string = string> extends $ZodType {
    _zod: $ZodStringFormatInternals<Format>;
}
export declare const $ZodStringFormat: core.$constructor<$ZodStringFormat>;
export interface $ZodGUIDDef extends $ZodStringFormatDef<"guid"> {
}
export interface $ZodGUIDInternals extends $ZodStringFormatInternals<"guid"> {
}
export interface $ZodGUID extends $ZodType {
    _zod: $ZodGUIDInternals;
}
export declare const $ZodGUID: core.$constructor<$ZodGUID>;
export interface $ZodUUIDDef extends $ZodStringFormatDef<"uuid"> {
    version?: "v1" | "v2" | "v3" | "v4" | "v5" | "v6" | "v7" | "v8";
}
export interface $ZodUUIDInternals extends $ZodStringFormatInternals<"uuid"> {
    def: $ZodUUIDDef;
}
export interface $ZodUUID extends $ZodType {
    _zod: $ZodUUIDInternals;
}
export declare const $ZodUUID: core.$constructor<$ZodUUID>;
export interface $ZodEmailDef extends $ZodStringFormatDef<"email"> {
}
export interface $ZodEmailInternals extends $ZodStringFormatInternals<"email"> {
}
export interface $ZodEmail extends $ZodType {
    _zod: $ZodEmailInternals;
}
export declare const $ZodEmail: core.$constructor<$ZodEmail>;
export interface $ZodURLDef extends $ZodStringFormatDef<"url"> {
    hostname?: RegExp | undefined;
    protocol?: RegExp | undefined;
    normalize?: boolean | undefined;
}
export interface $ZodURLInternals extends $ZodStringFormatInternals<"url"> {
    def: $ZodURLDef;
}
export interface $ZodURL extends $ZodType {
    _zod: $ZodURLInternals;
}
/** The `://` guard rejected the input before the URL constructor saw it. */
export declare const URL_BAD_FORMAT = 1;
/** The URL constructor rejected the input. */
export declare const URL_UNPARSEABLE = 2;
/** Parses a URL for `$ZodURL`, applying the one guard the URL constructor cannot express. Returns the parsed URL, or a code naming the stage that rejected it — the runtime needs that distinction to pick an issue note, and compiled code only needs to know it is not a URL. */
export declare function parseURLObject(trimmed: string, def: Pick<$ZodURLDef, "protocol" | "normalize">): URL | typeof URL_BAD_FORMAT | typeof URL_UNPARSEABLE;
/** The URL parser deletes every ASCII tab, LF and CR from its input before it parses, so `new URL("https://exa\nmple.com")` reports on `example.com`. Applying the same deletion to the returned value closes the half of that divergence which can move the host; the parser's other rewrite, stripping C0 controls at the edges, cannot. */
export declare function stripTabAndNewline(value: string): string;
export declare function urlHostnameOk(url: URL, hostname: RegExp): boolean;
export declare function urlProtocolOk(url: URL, protocol: RegExp): boolean;
export declare const $ZodURL: core.$constructor<$ZodURL>;
export interface $ZodEmojiDef extends $ZodStringFormatDef<"emoji"> {
}
export interface $ZodEmojiInternals extends $ZodStringFormatInternals<"emoji"> {
}
export interface $ZodEmoji extends $ZodType {
    _zod: $ZodEmojiInternals;
}
export declare const $ZodEmoji: core.$constructor<$ZodEmoji>;
export interface $ZodNanoIDDef extends $ZodStringFormatDef<"nanoid"> {
    length?: number | undefined;
}
export interface $ZodNanoIDInternals extends $ZodStringFormatInternals<"nanoid"> {
    def: $ZodNanoIDDef;
}
export interface $ZodNanoID extends $ZodType {
    _zod: $ZodNanoIDInternals;
}
export declare const $ZodNanoID: core.$constructor<$ZodNanoID>;
/**
 * @deprecated CUID v1 is deprecated by its authors due to information leakage
 * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
 * See https://github.com/paralleldrive/cuid.
 */
export interface $ZodCUIDDef extends $ZodStringFormatDef<"cuid"> {
}
/**
 * @deprecated CUID v1 is deprecated by its authors due to information leakage
 * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
 * See https://github.com/paralleldrive/cuid.
 */
export interface $ZodCUIDInternals extends $ZodStringFormatInternals<"cuid"> {
}
/**
 * @deprecated CUID v1 is deprecated by its authors due to information leakage
 * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
 * See https://github.com/paralleldrive/cuid.
 */
export interface $ZodCUID extends $ZodType {
    _zod: $ZodCUIDInternals;
}
/**
 * @deprecated CUID v1 is deprecated by its authors due to information leakage
 * (timestamps embedded in the id). Use {@link $ZodCUID2} instead.
 * See https://github.com/paralleldrive/cuid.
 */
export declare const $ZodCUID: core.$constructor<$ZodCUID>;
export interface $ZodCUID2Def extends $ZodStringFormatDef<"cuid2"> {
}
export interface $ZodCUID2Internals extends $ZodStringFormatInternals<"cuid2"> {
}
export interface $ZodCUID2 extends $ZodType {
    _zod: $ZodCUID2Internals;
}
export declare const $ZodCUID2: core.$constructor<$ZodCUID2>;
export interface $ZodULIDDef extends $ZodStringFormatDef<"ulid"> {
}
export interface $ZodULIDInternals extends $ZodStringFormatInternals<"ulid"> {
}
export interface $ZodULID extends $ZodType {
    _zod: $ZodULIDInternals;
}
export declare const $ZodULID: core.$constructor<$ZodULID>;
export interface $ZodXIDDef extends $ZodStringFormatDef<"xid"> {
}
export interface $ZodXIDInternals extends $ZodStringFormatInternals<"xid"> {
}
export interface $ZodXID extends $ZodType {
    _zod: $ZodXIDInternals;
}
export declare const $ZodXID: core.$constructor<$ZodXID>;
export interface $ZodKSUIDDef extends $ZodStringFormatDef<"ksuid"> {
}
export interface $ZodKSUIDInternals extends $ZodStringFormatInternals<"ksuid"> {
}
export interface $ZodKSUID extends $ZodType {
    _zod: $ZodKSUIDInternals;
}
export declare const $ZodKSUID: core.$constructor<$ZodKSUID>;
export interface $ZodISODateTimeDef extends $ZodStringFormatDef<"datetime"> {
    precision: number | null;
    offset: boolean;
    local: boolean;
}
export interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {
    def: $ZodISODateTimeDef;
}
export interface $ZodISODateTime extends $ZodType {
    _zod: $ZodISODateTimeInternals;
}
export declare const $ZodISODateTime: core.$constructor<$ZodISODateTime>;
export interface $ZodISODateDef extends $ZodStringFormatDef<"date"> {
}
export interface $ZodISODateInternals extends $ZodStringFormatInternals<"date"> {
}
export interface $ZodISODate extends $ZodType {
    _zod: $ZodISODateInternals;
}
export declare const $ZodISODate: core.$constructor<$ZodISODate>;
export interface $ZodISOTimeDef extends $ZodStringFormatDef<"time"> {
    precision?: number | null;
}
export interface $ZodISOTimeInternals extends $ZodStringFormatInternals<"time"> {
    def: $ZodISOTimeDef;
}
export interface $ZodISOTime extends $ZodType {
    _zod: $ZodISOTimeInternals;
}
export declare const $ZodISOTime: core.$constructor<$ZodISOTime>;
export interface $ZodISODurationDef extends $ZodStringFormatDef<"duration"> {
}
export interface $ZodISODurationInternals extends $ZodStringFormatInternals<"duration"> {
}
export interface $ZodISODuration extends $ZodType {
    _zod: $ZodISODurationInternals;
}
export declare const $ZodISODuration: core.$constructor<$ZodISODuration>;
export interface $ZodIPv4Def extends $ZodStringFormatDef<"ipv4"> {
    version?: "v4";
}
export interface $ZodIPv4Internals extends $ZodStringFormatInternals<"ipv4"> {
    def: $ZodIPv4Def;
}
export interface $ZodIPv4 extends $ZodType {
    _zod: $ZodIPv4Internals;
}
export declare const $ZodIPv4: core.$constructor<$ZodIPv4>;
export interface $ZodIPv6Def extends $ZodStringFormatDef<"ipv6"> {
    version?: "v6";
}
export interface $ZodIPv6Internals extends $ZodStringFormatInternals<"ipv6"> {
    def: $ZodIPv6Def;
}
export interface $ZodIPv6 extends $ZodType {
    _zod: $ZodIPv6Internals;
}
export declare function isValidIPv6(value: string): boolean;
export declare const $ZodIPv6: core.$constructor<$ZodIPv6>;
export interface $ZodMACDef extends $ZodStringFormatDef<"mac"> {
    delimiter?: string;
}
export interface $ZodMACInternals extends $ZodStringFormatInternals<"mac"> {
    def: $ZodMACDef;
}
export interface $ZodMAC extends $ZodType {
    _zod: $ZodMACInternals;
}
export declare const $ZodMAC: core.$constructor<$ZodMAC>;
export interface $ZodCIDRv4Def extends $ZodStringFormatDef<"cidrv4"> {
    version?: "v4";
}
export interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<"cidrv4"> {
    def: $ZodCIDRv4Def;
}
export interface $ZodCIDRv4 extends $ZodType {
    _zod: $ZodCIDRv4Internals;
}
export declare const $ZodCIDRv4: core.$constructor<$ZodCIDRv4>;
export interface $ZodCIDRv6Def extends $ZodStringFormatDef<"cidrv6"> {
    version?: "v6";
}
export interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<"cidrv6"> {
    def: $ZodCIDRv6Def;
}
export interface $ZodCIDRv6 extends $ZodType {
    _zod: $ZodCIDRv6Internals;
}
export declare function isValidCIDRv6(value: string): boolean;
export declare const $ZodCIDRv6: core.$constructor<$ZodCIDRv6>;
export declare function isValidBase64(data: string): boolean;
export interface $ZodBase64Def extends $ZodStringFormatDef<"base64"> {
}
export interface $ZodBase64Internals extends $ZodStringFormatInternals<"base64"> {
}
export interface $ZodBase64 extends $ZodType {
    _zod: $ZodBase64Internals;
}
export declare const $ZodBase64: core.$constructor<$ZodBase64>;
export declare function isValidBase64URL(data: string): boolean;
export interface $ZodBase64URLDef extends $ZodStringFormatDef<"base64url"> {
}
export interface $ZodBase64URLInternals extends $ZodStringFormatInternals<"base64url"> {
}
export interface $ZodBase64URL extends $ZodType {
    _zod: $ZodBase64URLInternals;
}
export declare const $ZodBase64URL: core.$constructor<$ZodBase64URL>;
export interface $ZodE164Def extends $ZodStringFormatDef<"e164"> {
}
export interface $ZodE164Internals extends $ZodStringFormatInternals<"e164"> {
}
export interface $ZodE164 extends $ZodType {
    _zod: $ZodE164Internals;
}
export declare const $ZodE164: core.$constructor<$ZodE164>;
export declare function isValidCreditCard(input: string): boolean;
export interface $ZodCreditCardDef extends $ZodStringFormatDef<"credit_card"> {
}
export interface $ZodCreditCardInternals extends $ZodStringFormatInternals<"credit_card"> {
    def: $ZodCreditCardDef;
}
export interface $ZodCreditCard extends $ZodType {
    _zod: $ZodCreditCardInternals;
}
export declare const $ZodCreditCard: core.$constructor<$ZodCreditCard>;
export declare function isValidJWT(token: string, algorithm?: util.JWTAlgorithm | null): boolean;
export interface $ZodJWTDef extends $ZodStringFormatDef<"jwt"> {
    alg?: util.JWTAlgorithm | undefined;
}
export interface $ZodJWTInternals extends $ZodStringFormatInternals<"jwt"> {
    def: $ZodJWTDef;
}
export interface $ZodJWT extends $ZodType {
    _zod: $ZodJWTInternals;
}
export declare const $ZodJWT: core.$constructor<$ZodJWT>;
export interface $ZodCustomStringFormatDef<Format extends string = string> extends $ZodStringFormatDef<Format> {
    fn: (val: string) => unknown;
}
export interface $ZodCustomStringFormatInternals<Format extends string = string> extends $ZodStringFormatInternals<Format> {
    def: $ZodCustomStringFormatDef<Format>;
}
export interface $ZodCustomStringFormat<Format extends string = string> extends $ZodStringFormat<Format> {
    _zod: $ZodCustomStringFormatInternals<Format>;
}
export declare const $ZodCustomStringFormat: core.$constructor<$ZodCustomStringFormat>;
export interface $ZodNumberDef extends $ZodTypeDef {
    type: "number";
    coerce?: boolean;
}
export interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {
    def: $ZodNumberDef;
    /** @deprecated Internal API, use with caution (not deprecated) */
    pattern: RegExp;
    /** @deprecated Internal API, use with caution (not deprecated) */
    isst: errors.$ZodIssueInvalidType;
    bag: util.LoosePartial<{
        minimum: number;
        maximum: number;
        exclusiveMinimum: number;
        exclusiveMaximum: number;
        format: string;
        pattern: RegExp;
    }>;
}
export interface $ZodNumber<Input = unknown> extends $ZodType {
    _zod: $ZodNumberInternals<Input>;
}
export declare const $ZodNumber: core.$constructor<$ZodNumber>;
export interface $ZodNumberFormatDef<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodNumberDef, checks.$ZodCheckNumberFormatDef<Format> {
}
export interface $ZodNumberFormatInternals<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodNumberInternals<number>, checks.$ZodCheckNumberFormatInternals<Format> {
    def: $ZodNumberFormatDef<Format>;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends $ZodType {
    _zod: $ZodNumberFormatInternals<Format>;
}
export declare const $ZodNumberFormat: core.$constructor<$ZodNumberFormat>;
export interface $ZodBooleanDef extends $ZodTypeDef {
    type: "boolean";
    coerce?: boolean;
    checks?: checks.$ZodCheck<boolean>[];
}
export interface $ZodBooleanInternals<T = unknown> extends $ZodTypeInternals<boolean, T> {
    pattern: RegExp;
    def: $ZodBooleanDef;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodBoolean<T = unknown> extends $ZodType {
    _zod: $ZodBooleanInternals<T>;
}
export declare const $ZodBoolean: core.$constructor<$ZodBoolean>;
export interface $ZodBigIntDef extends $ZodTypeDef {
    type: "bigint";
    coerce?: boolean;
}
export interface $ZodBigIntInternals<T = unknown> extends $ZodTypeInternals<bigint, T> {
    pattern: RegExp;
    /** @internal Internal API, use with caution */
    def: $ZodBigIntDef;
    isst: errors.$ZodIssueInvalidType;
    bag: util.LoosePartial<{
        minimum: bigint;
        maximum: bigint;
        format: string;
    }>;
}
export interface $ZodBigInt<T = unknown> extends $ZodType {
    _zod: $ZodBigIntInternals<T>;
}
export declare const $ZodBigInt: core.$constructor<$ZodBigInt>;
export interface $ZodBigIntFormatDef<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodBigIntDef, checks.$ZodCheckBigIntFormatDef<Format> {
    check: "bigint_format";
}
export interface $ZodBigIntFormatInternals<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodBigIntInternals<bigint>, checks.$ZodCheckBigIntFormatInternals<Format> {
    def: $ZodBigIntFormatDef<Format>;
}
export interface $ZodBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends $ZodType {
    _zod: $ZodBigIntFormatInternals<Format>;
}
export declare const $ZodBigIntFormat: core.$constructor<$ZodBigIntFormat>;
export interface $ZodSymbolDef extends $ZodTypeDef {
    type: "symbol";
}
export interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {
    def: $ZodSymbolDef;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodSymbol extends $ZodType {
    _zod: $ZodSymbolInternals;
}
export declare const $ZodSymbol: core.$constructor<$ZodSymbol>;
export interface $ZodUndefinedDef extends $ZodTypeDef {
    type: "undefined";
}
export interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {
    pattern: RegExp;
    def: $ZodUndefinedDef;
    values: util.PrimitiveSet;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodUndefined extends $ZodType {
    _zod: $ZodUndefinedInternals;
}
export declare const $ZodUndefined: core.$constructor<$ZodUndefined>;
export interface $ZodNullDef extends $ZodTypeDef {
    type: "null";
}
export interface $ZodNullInternals extends $ZodTypeInternals<null, null> {
    pattern: RegExp;
    def: $ZodNullDef;
    values: util.PrimitiveSet;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNull extends $ZodType {
    _zod: $ZodNullInternals;
}
export declare const $ZodNull: core.$constructor<$ZodNull>;
export interface $ZodAnyDef extends $ZodTypeDef {
    type: "any";
}
export interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {
    def: $ZodAnyDef;
    isst: never;
}
export interface $ZodAny extends $ZodType {
    _zod: $ZodAnyInternals;
}
export declare const $ZodAny: core.$constructor<$ZodAny>;
export interface $ZodUnknownDef extends $ZodTypeDef {
    type: "unknown";
}
export interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {
    def: $ZodUnknownDef;
    isst: never;
}
export interface $ZodUnknown extends $ZodType {
    _zod: $ZodUnknownInternals;
}
export declare const $ZodUnknown: core.$constructor<$ZodUnknown>;
export interface $ZodNeverDef extends $ZodTypeDef {
    type: "never";
}
export interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {
    def: $ZodNeverDef;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNever extends $ZodType {
    _zod: $ZodNeverInternals;
}
export declare const $ZodNever: core.$constructor<$ZodNever>;
export interface $ZodVoidDef extends $ZodTypeDef {
    type: "void";
}
export interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {
    def: $ZodVoidDef;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodVoid extends $ZodType {
    _zod: $ZodVoidInternals;
}
export declare const $ZodVoid: core.$constructor<$ZodVoid>;
export interface $ZodDateDef extends $ZodTypeDef {
    type: "date";
    coerce?: boolean;
}
export interface $ZodDateInternals<T = unknown> extends $ZodTypeInternals<Date, T> {
    def: $ZodDateDef;
    isst: errors.$ZodIssueInvalidType;
    bag: util.LoosePartial<{
        minimum: Date;
        maximum: Date;
        format: string;
    }>;
}
export interface $ZodDate<T = unknown> extends $ZodType {
    _zod: $ZodDateInternals<T>;
}
export declare const $ZodDate: core.$constructor<$ZodDate>;
export interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "array";
    element: T;
}
export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {
    def: $ZodArrayDef<T>;
    isst: errors.$ZodIssueInvalidType;
    output: core.output<T>[];
    input: core.input<T>[];
}
export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {
}
export declare const $ZodArray: core.$constructor<$ZodArray>;
type OptionalOutSchema = {
    _zod: {
        optout: "optional";
    };
};
type OptionalInSchema = {
    _zod: {
        optin: "optional" | "defaulted";
    };
};
export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, core.output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
} & {
    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
} & Extra>;
export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, core.input<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
    -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"];
} & {
    -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"];
} & Extra>;
export type $ZodObjectConfig = {
    out: Record<string, unknown>;
    in: Record<string, unknown>;
};
export type $loose = {
    out: Record<string, unknown>;
    in: Record<string, unknown>;
};
export type $strict = {
    out: {};
    in: {};
};
export type $strip = {
    out: {};
    in: {};
};
export type $catchall<T extends SomeType> = {
    out: {
        [k: string]: core.output<T>;
    };
    in: {
        [k: string]: core.input<T>;
    };
};
export type $ZodShape = Readonly<{
    [k: string]: $ZodType;
}>;
export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {
    type: "object";
    shape: Shape;
    catchall?: $ZodType | undefined;
}
export interface $ZodObjectInternals<
/** @ts-ignore Cast variance */
out Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
    def: $ZodObjectDef<Shape>;
    config: Config;
    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
    propValues: util.PropValues;
    output: $InferObjectOutput<Shape, Config["out"]>;
    input: $InferObjectInput<Shape, Config["in"]>;
    optin?: "optional" | undefined;
    optout?: "optional" | undefined;
}
export type $ZodLooseShape = Record<string, any>;
export interface $ZodObject<
/** @ts-ignore Cast variance */
out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
}
export declare const $ZodObject: core.$constructor<$ZodObject>;
export declare const $ZodObjectJIT: core.$constructor<$ZodObject>;
export type $InferUnionOutput<T extends SomeType> = T extends any ? core.output<T> : never;
export type $InferUnionInput<T extends SomeType> = T extends any ? core.input<T> : never;
export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
    type: "union";
    options: Options;
    inclusive?: boolean;
}
type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
    def: $ZodUnionDef<T>;
    isst: errors.$ZodIssueInvalidUnion;
    pattern: T[number]["_zod"]["pattern"];
    values: T[number]["_zod"]["values"];
    output: $InferUnionOutput<T[number]>;
    input: $InferUnionInput<T[number]>;
    optin: IsOptionalIn<T[number]> extends false ? "optional" | "defaulted" | undefined : "optional" | "defaulted";
    optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
}
export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {
    _zod: $ZodUnionInternals<T>;
}
export declare const $ZodUnion: core.$constructor<$ZodUnion>;
export interface $ZodXorInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<T> {
}
export interface $ZodXor<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodXorInternals<T>> {
    _zod: $ZodXorInternals<T>;
}
export declare const $ZodXor: core.$constructor<$ZodXor>;
export interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {
    discriminator: Disc;
    unionFallback?: boolean;
}
export interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {
    def: $ZodDiscriminatedUnionDef<Options, Disc>;
    propValues: util.PropValues;
    bag: util.LoosePartial<{
        optionsMap: Map<util.Primitive, $ZodType>;
    }>;
}
/** The discriminator values a member of `Options` can declare. An omittable discriminator contributes `undefined`, matching what `propValues` claims for it. */
export type $DiscriminatorValue<Options extends readonly SomeType[], Disc extends string> = {
    [I in keyof Options]: Options[I] extends {
        _zod: {
            output: infer Out;
        };
    } ? Disc extends keyof Out ? Out[Disc] : never : never;
}[number];
/** The member of `Options` that declares `V`. */
export type $DiscriminatedOption<Options extends readonly SomeType[], Disc extends string, V> = {
    [I in keyof Options]: Options[I] extends {
        _zod: {
            output: infer Out;
        };
    } ? Disc extends keyof Out ? V extends Out[Disc] ? Options[I] : never : never : never;
}[number];
/** Returns the option of `union` whose discriminator claims `value`. */
export declare function getDiscriminatedOption<Options extends readonly SomeType[], Disc extends string, const V extends $DiscriminatorValue<Options, Disc>>(union: $ZodDiscriminatedUnion<Options, Disc>, value: V): $DiscriminatedOption<Options, Disc, V>;
export interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {
    _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
}
export declare const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion>;
export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "intersection";
    left: Left;
    right: Right;
}
export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {
    def: $ZodIntersectionDef<A, B>;
    isst: never;
    optin: A["_zod"]["optin"] | B["_zod"]["optin"];
    optout: A["_zod"]["optout"] | B["_zod"]["optout"];
    output: core.output<A> & core.output<B>;
    input: core.input<A> & core.input<B>;
}
export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodIntersectionInternals<A, B>;
}
export declare const $ZodIntersection: core.$constructor<$ZodIntersection>;
export declare function mergeValues(a: any, b: any): {
    valid: true;
    data: any;
} | {
    valid: false;
    mergeErrorPath: (string | number)[];
};
export interface $ZodTupleDef<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
    type: "tuple";
    items: T;
    rest: Rest;
}
export type $InferTupleInputType<T extends util.TupleItems, Rest extends SomeType | null> = [
    ...TupleInputTypeWithOptionals<T>,
    ...(Rest extends SomeType ? core.input<Rest>[] : [])
];
type TupleInputTypeNoOptionals<T extends util.TupleItems> = {
    [k in keyof T]: core.input<T[k]>;
};
type TupleInputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
    ...infer Prefix extends SomeType[],
    infer Tail extends SomeType
] ? Tail["_zod"]["optin"] extends "optional" | "defaulted" ? [...TupleInputTypeWithOptionals<Prefix>, core.input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
export type $InferTupleOutputType<T extends util.TupleItems, Rest extends SomeType | null> = [
    ...TupleOutputTypeWithOptionals<T>,
    ...(Rest extends SomeType ? core.output<Rest>[] : [])
];
type TupleOutputTypeNoOptionals<T extends util.TupleItems> = {
    [k in keyof T]: core.output<T[k]>;
};
type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
    ...infer Prefix extends SomeType[],
    infer Tail extends SomeType
] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, core.output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {
    def: $ZodTupleDef<T, Rest>;
    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;
    output: $InferTupleOutputType<T, Rest>;
    input: $InferTupleInputType<T, Rest>;
}
export interface $ZodTuple<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
    _zod: $ZodTupleInternals<T, Rest>;
}
export declare const $ZodTuple: core.$constructor<$ZodTuple>;
export type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;
export interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "record";
    keyType: Key;
    valueType: Value;
    /** @default "strict" - errors on keys not matching keyType. "loose" passes through non-matching keys unchanged. */
    mode?: "strict" | "loose";
    partial?: boolean;
}
export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : [
    Value
] extends [OptionalInSchema] ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : Record<core.input<Key> & PropertyKey, core.input<Value>>;
export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
    def: $ZodRecordDef<Key, Value>;
    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
    optin?: "optional" | undefined;
    optout?: "optional" | undefined;
}
export type $partial = {
    "~~partial": true;
};
export interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodRecordInternals<Key, Value>;
}
export declare const $ZodRecord: core.$constructor<$ZodRecord>;
export interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "map";
    keyType: Key;
    valueType: Value;
}
export interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<core.output<Key>, core.output<Value>>, Map<core.input<Key>, core.input<Value>>> {
    def: $ZodMapDef<Key, Value>;
    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey | errors.$ZodIssueInvalidElement<unknown>;
    optin?: "optional" | undefined;
    optout?: "optional" | undefined;
}
export interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodMapInternals<Key, Value>;
}
export declare const $ZodMap: core.$constructor<$ZodMap>;
export interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "set";
    valueType: T;
}
export interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<core.output<T>>, Set<core.input<T>>> {
    def: $ZodSetDef<T>;
    isst: errors.$ZodIssueInvalidType;
    optin?: "optional" | undefined;
    optout?: "optional" | undefined;
}
export interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodSetInternals<T>;
}
export declare const $ZodSet: core.$constructor<$ZodSet>;
export type $InferEnumOutput<T extends util.EnumLike> = T[keyof T] & {};
export type $InferEnumInput<T extends util.EnumLike> = T[keyof T] & {};
export interface $ZodEnumDef<T extends util.EnumLike = util.EnumLike> extends $ZodTypeDef {
    type: "enum";
    entries: T;
}
export interface $ZodEnumInternals<
/** @ts-ignore Cast variance */
out T extends util.EnumLike = util.EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {
    def: $ZodEnumDef<T>;
    /** @deprecated Internal API, use with caution (not deprecated) */
    values: util.PrimitiveSet;
    /** @deprecated Internal API, use with caution (not deprecated) */
    pattern: RegExp;
    isst: errors.$ZodIssueInvalidValue;
}
export interface $ZodEnum<T extends util.EnumLike = util.EnumLike> extends $ZodType {
    _zod: $ZodEnumInternals<T>;
}
export declare const $ZodEnum: core.$constructor<$ZodEnum>;
export interface $ZodLiteralDef<T extends util.Literal> extends $ZodTypeDef {
    type: "literal";
    values: T[];
}
export interface $ZodLiteralInternals<T extends util.Literal = util.Literal> extends $ZodTypeInternals<T, T> {
    def: $ZodLiteralDef<T>;
    values: Set<T>;
    pattern: RegExp;
    isst: errors.$ZodIssueInvalidValue;
}
export interface $ZodLiteral<T extends util.Literal = util.Literal> extends $ZodType {
    _zod: $ZodLiteralInternals<T>;
}
export declare const $ZodLiteral: core.$constructor<$ZodLiteral>;
type _File = typeof globalThis extends {
    File: infer F extends new (...args: any[]) => any;
} ? InstanceType<F> : {};
/** Do not reference this directly. */
export interface File extends _File {
    readonly type: string;
    readonly size: number;
}
export interface $ZodFileDef extends $ZodTypeDef {
    type: "file";
}
export interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
    def: $ZodFileDef;
    isst: errors.$ZodIssueInvalidType;
    bag: util.LoosePartial<{
        minimum: number;
        maximum: number;
        mime: util.MimeTypes[];
    }>;
}
export interface $ZodFile extends $ZodType {
    _zod: $ZodFileInternals;
}
export declare const $ZodFile: core.$constructor<$ZodFile>;
export interface $ZodTransformDef extends $ZodTypeDef {
    type: "transform";
    transform: (input: unknown, payload: ParsePayload<unknown>) => util.MaybeAsync<unknown>;
}
export interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {
    def: $ZodTransformDef;
    isst: never;
}
export interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
    _zod: $ZodTransformInternals<O, I>;
}
export declare const $ZodTransform: core.$constructor<$ZodTransform>;
export interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "optional";
    innerType: T;
}
export interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T> | undefined, core.input<T> | undefined> {
    def: $ZodOptionalDef<T>;
    optin: "optional" | "defaulted";
    optout: "optional";
    isst: never;
    values: T["_zod"]["values"];
    pattern: T["_zod"]["pattern"];
}
export interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodOptionalInternals<T>;
}
export declare const $ZodOptional: core.$constructor<$ZodOptional>;
export interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {
}
export interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {
    def: $ZodExactOptionalDef<T>;
    output: core.output<T>;
    input: core.input<T>;
}
export interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodExactOptionalInternals<T>;
}
export declare const $ZodExactOptional: core.$constructor<$ZodExactOptional>;
export interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "nullable";
    innerType: T;
}
export interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T> | null, core.input<T> | null> {
    def: $ZodNullableDef<T>;
    optin: T["_zod"]["optin"];
    optout: T["_zod"]["optout"];
    isst: never;
    values: T["_zod"]["values"];
    pattern: T["_zod"]["pattern"];
}
export interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodNullableInternals<T>;
}
export declare const $ZodNullable: core.$constructor<$ZodNullable>;
export interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "default";
    innerType: T;
    /** The default value. May be a getter. */
    defaultValue: util.NoUndefined<core.output<T>>;
}
export interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
    def: $ZodDefaultDef<T>;
    optin: "defaulted";
    optout?: "optional" | undefined;
    isst: never;
    values: T["_zod"]["values"];
}
export interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodDefaultInternals<T>;
}
export declare const $ZodDefault: core.$constructor<$ZodDefault>;
export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "prefault";
    innerType: T;
    /** The default value. May be a getter. */
    defaultValue: core.input<T>;
}
export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
    def: $ZodPrefaultDef<T>;
    optin: "defaulted";
    optout?: "optional" | undefined;
    isst: never;
    values: T["_zod"]["values"];
}
export interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodPrefaultInternals<T>;
}
export declare const $ZodPrefault: core.$constructor<$ZodPrefault>;
export interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "nonoptional";
    innerType: T;
}
export interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, util.NoUndefined<core.input<T>>> {
    def: $ZodNonOptionalDef<T>;
    isst: errors.$ZodIssueInvalidType;
    values: T["_zod"]["values"];
    optin: "optional" | undefined;
    optout: "optional" | undefined;
}
export interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodNonOptionalInternals<T>;
}
export declare const $ZodNonOptional: core.$constructor<$ZodNonOptional>;
export interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "success";
    innerType: T;
}
export interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, core.input<T>> {
    def: $ZodSuccessDef<T>;
    isst: never;
    optin: T["_zod"]["optin"];
    optout: "optional" | undefined;
}
export interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodSuccessInternals<T>;
}
export declare const $ZodSuccess: core.$constructor<$ZodSuccess>;
export interface $ZodCatchCtx extends ParsePayload {
    /** @deprecated Use `ctx.issues` */
    error: {
        issues: errors.$ZodIssue[];
    };
    /** @deprecated Use `ctx.value` */
    input: unknown;
}
export interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "catch";
    innerType: T;
    catchValue: (ctx: $ZodCatchCtx) => unknown;
}
export interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T>> {
    def: $ZodCatchDef<T>;
    optin: T["_zod"]["optin"];
    optout: T["_zod"]["optout"];
    isst: never;
    values: T["_zod"]["values"];
}
export interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodCatchInternals<T>;
}
export declare const $ZodCatch: core.$constructor<$ZodCatch>;
export interface $ZodNaNDef extends $ZodTypeDef {
    type: "nan";
}
export interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {
    def: $ZodNaNDef;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodNaN extends $ZodType {
    _zod: $ZodNaNInternals;
}
export declare const $ZodNaN: core.$constructor<$ZodNaN>;
export interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "pipe";
    in: A;
    out: B;
    /** Only defined inside $ZodCodec instances. */
    transform?: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;
    /** Only defined inside $ZodCodec instances. */
    reverseTransform?: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;
}
export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<B>, core.input<A>> {
    def: $ZodPipeDef<A, B>;
    isst: never;
    values: A["_zod"]["values"];
    optin: A["_zod"]["optin"];
    optout: B["_zod"]["optout"];
    propValues: A["_zod"]["propValues"];
}
export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodPipeInternals<A, B>;
}
export declare const $ZodPipe: core.$constructor<$ZodPipe>;
export interface $ZodCodecDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodPipeDef<A, B> {
    transform: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;
    reverseTransform: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;
}
export interface $ZodCodecInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<B>, core.input<A>> {
    def: $ZodCodecDef<A, B>;
    isst: never;
    values: A["_zod"]["values"];
    optin: A["_zod"]["optin"];
    optout: B["_zod"]["optout"];
    propValues: A["_zod"]["propValues"];
}
export interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodCodecInternals<A, B>;
}
export declare const $ZodCodec: core.$constructor<$ZodCodec>;
export interface $ZodPreprocessDef<B extends SomeType = $ZodType, I = unknown> extends $ZodPipeDef<$ZodTransform<unknown, I>, B> {
    in: $ZodTransform<unknown, I>;
    out: B;
}
export interface $ZodPreprocessInternals<B extends SomeType = $ZodType, I = unknown> extends $ZodPipeInternals<$ZodTransform<unknown, I>, B> {
    def: $ZodPreprocessDef<B, I>;
    optin: B["_zod"]["optin"];
    optout: B["_zod"]["optout"];
}
export interface $ZodPreprocess<B extends SomeType = $ZodType, I = unknown> extends $ZodPipe<$ZodTransform<unknown, I>, B> {
    _zod: $ZodPreprocessInternals<B, I>;
}
export declare const $ZodPreprocess: core.$constructor<$ZodPreprocess>;
export interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "readonly";
    innerType: T;
}
export interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.MakeReadonly<core.output<T>>, util.MakeReadonly<core.input<T>>> {
    def: $ZodReadonlyDef<T>;
    optin: T["_zod"]["optin"];
    optout: T["_zod"]["optout"];
    isst: never;
    propValues: T["_zod"]["propValues"];
    values: T["_zod"]["values"];
}
export interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodReadonlyInternals<T>;
}
export declare const $ZodReadonly: core.$constructor<$ZodReadonly>;
export interface $ZodTemplateLiteralDef extends $ZodTypeDef {
    type: "template_literal";
    parts: $ZodTemplateLiteralPart[];
    format?: string | undefined;
}
export interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {
    pattern: RegExp;
    def: $ZodTemplateLiteralDef;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {
    _zod: $ZodTemplateLiteralInternals<Template>;
}
type LiteralPart = Exclude<util.Literal, symbol>;
interface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {
    pattern: RegExp;
}
interface SchemaPart extends $ZodType {
    _zod: SchemaPartInternals;
}
export type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
type UndefinedToEmptyString<T> = T extends undefined ? "" : T;
type AppendToTemplateLiteral<Template extends string, Suffix extends LiteralPart | $ZodType> = Suffix extends LiteralPart ? `${Template}${UndefinedToEmptyString<Suffix>}` : Suffix extends $ZodType ? `${Template}${core.output<Suffix> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
export type ConcatenateTupleOfStrings<T extends string[]> = T extends [
    infer First extends string,
    ...infer Rest extends string[]
] ? Rest extends string[] ? First extends "" ? ConcatenateTupleOfStrings<Rest> : `${First}${ConcatenateTupleOfStrings<Rest>}` : never : "";
export type ConvertPartsToStringTuple<Parts extends $ZodTemplateLiteralPart[]> = {
    [K in keyof Parts]: Parts[K] extends LiteralPart ? `${UndefinedToEmptyString<Parts[K]>}` : Parts[K] extends $ZodType ? `${core.output<Parts[K]> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
};
export type ToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = ConcatenateTupleOfStrings<ConvertPartsToStringTuple<Parts>>;
export type $PartsToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = [] extends Parts ? `` : Parts extends [...infer Rest, infer Last extends $ZodTemplateLiteralPart] ? Rest extends $ZodTemplateLiteralPart[] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never : never;
export declare const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral>;
export type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;
export type $ZodFunctionIn = $ZodFunctionArgs;
export type $ZodFunctionOut = $ZodType;
export type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;
export type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;
export type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;
export type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => Promise<core.output<Returns>>;
export interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {
    type: "function";
    input: In;
    output: Out;
}
export interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {
    def: $ZodFunctionDef<Args, Returns>;
    isst: errors.$ZodIssueInvalidType;
}
export interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {
    /** @deprecated */
    _def: $ZodFunctionDef<Args, Returns>;
    _input: $InferInnerFunctionType<Args, Returns>;
    _output: $InferOuterFunctionType<Args, Returns>;
    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this["_output"]>) => ReturnType<F> extends ReturnType<this["_output"]> ? ReturnType<F> : ReturnType<this["_output"]>;
    implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;
    input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;
    input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;
    input(...args: any[]): $ZodFunction<any, Returns>;
    output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;
}
export interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends $ZodType> {
    input?: I;
    output?: O;
}
export declare const $ZodFunction: core.$constructor<$ZodFunction>;
export interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "promise";
    innerType: T;
}
export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<core.output<T>>, util.MaybeAsync<core.input<T>>> {
    def: $ZodPromiseDef<T>;
    isst: never;
}
export interface $ZodPromise<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodPromiseInternals<T>;
}
export declare const $ZodPromise: core.$constructor<$ZodPromise>;
export interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
    type: "lazy";
    getter: () => T;
}
export interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T>> {
    def: $ZodLazyDef<T>;
    isst: never;
    /** Auto-cached way to retrieve the inner schema */
    innerType: T;
    pattern: T["_zod"]["pattern"];
    propValues: T["_zod"]["propValues"];
    optin: T["_zod"]["optin"];
    optout: T["_zod"]["optout"];
}
export interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
    _zod: $ZodLazyInternals<T>;
}
export declare const $ZodLazy: core.$constructor<$ZodLazy>;
export interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, checks.$ZodCheckDef {
    type: "custom";
    check: "custom";
    path?: PropertyKey[] | undefined;
    error?: errors.$ZodErrorMap | undefined;
    params?: Record<string, any> | undefined;
    fn: (arg: O) => unknown;
}
export interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, checks.$ZodCheckInternals<O> {
    def: $ZodCustomDef;
    issc: errors.$ZodIssue;
    isst: never;
    bag: util.LoosePartial<{
        Class: typeof util.Class;
    }>;
}
export interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {
    _zod: $ZodCustomInternals<O, I>;
}
export declare const $ZodCustom: core.$constructor<$ZodCustom>;
export type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;
export type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodCreditCard | $ZodJWT | $ZodCustomStringFormat<"hex"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<"hostname">;
