@rspack/core 1.3.7 → 1.3.9

package/compiled/zod/index.d.ts

@@ -1,1772 +1,2 @@
-type Primitive = string | number | symbol | bigint | boolean | null | undefined;
-type Scalars = Primitive | Primitive[];
-
-declare namespace util {
-    type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;
-    export type isAny<T> = 0 extends 1 & T ? true : false;
-    export const assertEqual: <A, B>(val: AssertEqual<A, B>) => AssertEqual<A, B>;
-    export function assertIs<T>(_arg: T): void;
-    export function assertNever(_x: never): never;
-    export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-    export type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;
-    export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
-    export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
-    export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
-    export const getValidEnumValues: (obj: any) => any[];
-    export const objectValues: (obj: any) => any[];
-    export const objectKeys: ObjectConstructor["keys"];
-    export const find: <T>(arr: T[], checker: (arg: T) => any) => T | undefined;
-    export type identity<T> = objectUtil.identity<T>;
-    export type flatten<T> = objectUtil.flatten<T>;
-    export type noUndefined<T> = T extends undefined ? never : T;
-    export const isInteger: NumberConstructor["isInteger"];
-    export function joinValues<T extends any[]>(array: T, separator?: string): string;
-    export const jsonStringifyReplacer: (_: string, value: any) => any;
-    export {};
-}
-declare namespace objectUtil {
-    export type MergeShapes<U, V> = keyof U & keyof V extends never ? U & V : {
-        [k in Exclude<keyof U, keyof V>]: U[k];
-    } & V;
-    type optionalKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? k : never;
-    }[keyof T];
-    type requiredKeys<T extends object> = {
-        [k in keyof T]: undefined extends T[k] ? never : k;
-    }[keyof T];
-    export type addQuestionMarks<T extends object, _O = any> = {
-        [K in requiredKeys<T>]: T[K];
-    } & {
-        [K in optionalKeys<T>]?: T[K];
-    } & {
-        [k in keyof T]?: unknown;
-    };
-    export type identity<T> = T;
-    export type flatten<T> = identity<{
-        [k in keyof T]: T[k];
-    }>;
-    export type noNeverKeys<T> = {
-        [k in keyof T]: [T[k]] extends [never] ? never : k;
-    }[keyof T];
-    export type noNever<T> = identity<{
-        [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
-    }>;
-    export const mergeShapes: <U, T>(first: U, second: T) => T & U;
-    export type extendShape<A extends object, B extends object> = keyof A & keyof B extends never ? A & B : {
-        [K in keyof A as K extends keyof B ? never : K]: A[K];
-    } & {
-        [K in keyof B]: B[K];
-    };
-    export {};
-}
-declare const ZodParsedType: {
-    string: "string";
-    number: "number";
-    bigint: "bigint";
-    boolean: "boolean";
-    symbol: "symbol";
-    undefined: "undefined";
-    object: "object";
-    function: "function";
-    map: "map";
-    nan: "nan";
-    integer: "integer";
-    float: "float";
-    date: "date";
-    null: "null";
-    array: "array";
-    unknown: "unknown";
-    promise: "promise";
-    void: "void";
-    never: "never";
-    set: "set";
-};
-type ZodParsedType = keyof typeof ZodParsedType;
-declare const getParsedType: (data: any) => ZodParsedType;
-
-type allKeys<T> = T extends any ? keyof T : never;
-type inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = typeToFlattenedError<TypeOf<T>, U>;
-type typeToFlattenedError<T, U = string> = {
-    formErrors: U[];
-    fieldErrors: {
-        [P in allKeys<T>]?: U[];
-    };
-};
-declare const ZodIssueCode: {
-    invalid_type: "invalid_type";
-    invalid_literal: "invalid_literal";
-    custom: "custom";
-    invalid_union: "invalid_union";
-    invalid_union_discriminator: "invalid_union_discriminator";
-    invalid_enum_value: "invalid_enum_value";
-    unrecognized_keys: "unrecognized_keys";
-    invalid_arguments: "invalid_arguments";
-    invalid_return_type: "invalid_return_type";
-    invalid_date: "invalid_date";
-    invalid_string: "invalid_string";
-    too_small: "too_small";
-    too_big: "too_big";
-    invalid_intersection_types: "invalid_intersection_types";
-    not_multiple_of: "not_multiple_of";
-    not_finite: "not_finite";
-};
-type ZodIssueCode = keyof typeof ZodIssueCode;
-type ZodIssueBase = {
-    path: (string | number)[];
-    message?: string;
-};
-interface ZodInvalidTypeIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_type;
-    expected: ZodParsedType;
-    received: ZodParsedType;
-}
-interface ZodInvalidLiteralIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_literal;
-    expected: unknown;
-    received: unknown;
-}
-interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.unrecognized_keys;
-    keys: string[];
-}
-interface ZodInvalidUnionIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_union;
-    unionErrors: ZodError[];
-}
-interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_union_discriminator;
-    options: Primitive[];
-}
-interface ZodInvalidEnumValueIssue extends ZodIssueBase {
-    received: string | number;
-    code: typeof ZodIssueCode.invalid_enum_value;
-    options: (string | number)[];
-}
-interface ZodInvalidArgumentsIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_arguments;
-    argumentsError: ZodError;
-}
-interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_return_type;
-    returnTypeError: ZodError;
-}
-interface ZodInvalidDateIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_date;
-}
-type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "cidr" | "base64" | "jwt" | "base64url" | {
-    includes: string;
-    position?: number;
-} | {
-    startsWith: string;
-} | {
-    endsWith: string;
-};
-interface ZodInvalidStringIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_string;
-    validation: StringValidation;
-}
-interface ZodTooSmallIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.too_small;
-    minimum: number | bigint;
-    inclusive: boolean;
-    exact?: boolean;
-    type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-interface ZodTooBigIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.too_big;
-    maximum: number | bigint;
-    inclusive: boolean;
-    exact?: boolean;
-    type: "array" | "string" | "number" | "set" | "date" | "bigint";
-}
-interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.invalid_intersection_types;
-}
-interface ZodNotMultipleOfIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.not_multiple_of;
-    multipleOf: number | bigint;
-}
-interface ZodNotFiniteIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.not_finite;
-}
-interface ZodCustomIssue extends ZodIssueBase {
-    code: typeof ZodIssueCode.custom;
-    params?: {
-        [k: string]: any;
-    };
-}
-type DenormalizedError = {
-    [k: string]: DenormalizedError | string[];
-};
-type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodNotFiniteIssue | ZodCustomIssue;
-type ZodIssue = ZodIssueOptionalMessage & {
-    fatal?: boolean;
-    message: string;
-};
-declare const quotelessJson: (obj: any) => string;
-type recursiveZodFormattedError<T> = T extends [any, ...any[]] ? {
-    [K in keyof T]?: ZodFormattedError<T[K]>;
-} : T extends any[] ? {
-    [k: number]: ZodFormattedError<T[number]>;
-} : T extends object ? {
-    [K in keyof T]?: ZodFormattedError<T[K]>;
-} : unknown;
-type ZodFormattedError<T, U = string> = {
-    _errors: U[];
-} & recursiveZodFormattedError<NonNullable<T>>;
-type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;
-declare class ZodError<T = any> extends Error {
-    issues: ZodIssue[];
-    get errors(): ZodIssue[];
-    constructor(issues: ZodIssue[]);
-    format(): ZodFormattedError<T>;
-    format<U>(mapper: (issue: ZodIssue) => U): ZodFormattedError<T, U>;
-    static create: (issues: ZodIssue[]) => ZodError<any>;
-    static assert(value: unknown): asserts value is ZodError;
-    toString(): string;
-    get message(): string;
-    get isEmpty(): boolean;
-    addIssue: (sub: ZodIssue) => void;
-    addIssues: (subs?: ZodIssue[]) => void;
-    flatten(): typeToFlattenedError<T>;
-    flatten<U>(mapper?: (issue: ZodIssue) => U): typeToFlattenedError<T, U>;
-    get formErrors(): typeToFlattenedError<T, string>;
-}
-type stripPath<T extends object> = T extends any ? util.OmitKeys<T, "path"> : never;
-type IssueData = stripPath<ZodIssueOptionalMessage> & {
-    path?: (string | number)[];
-    fatal?: boolean;
-};
-type ErrorMapCtx = {
-    defaultError: string;
-    data: any;
-};
-type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
-    message: string;
-};
-
-declare const errorMap: ZodErrorMap;
-
-declare function setErrorMap(map: ZodErrorMap): void;
-declare function getErrorMap(): ZodErrorMap;
-
-declare const makeIssue: (params: {
-    data: any;
-    path: (string | number)[];
-    errorMaps: ZodErrorMap[];
-    issueData: IssueData;
-}) => ZodIssue;
-type ParseParams = {
-    path: (string | number)[];
-    errorMap: ZodErrorMap;
-    async: boolean;
-};
-type ParsePathComponent = string | number;
-type ParsePath = ParsePathComponent[];
-declare const EMPTY_PATH: ParsePath;
-interface ParseContext {
-    readonly common: {
-        readonly issues: ZodIssue[];
-        readonly contextualErrorMap?: ZodErrorMap;
-        readonly async: boolean;
-    };
-    readonly path: ParsePath;
-    readonly schemaErrorMap?: ZodErrorMap;
-    readonly parent: ParseContext | null;
-    readonly data: any;
-    readonly parsedType: ZodParsedType;
-}
-type ParseInput = {
-    data: any;
-    path: (string | number)[];
-    parent: ParseContext;
-};
-declare function addIssueToContext(ctx: ParseContext, issueData: IssueData): void;
-type ObjectPair = {
-    key: SyncParseReturnType<any>;
-    value: SyncParseReturnType<any>;
-};
-declare class ParseStatus {
-    value: "aborted" | "dirty" | "valid";
-    dirty(): void;
-    abort(): void;
-    static mergeArray(status: ParseStatus, results: SyncParseReturnType<any>[]): SyncParseReturnType;
-    static mergeObjectAsync(status: ParseStatus, pairs: {
-        key: ParseReturnType<any>;
-        value: ParseReturnType<any>;
-    }[]): Promise<SyncParseReturnType<any>>;
-    static mergeObjectSync(status: ParseStatus, pairs: {
-        key: SyncParseReturnType<any>;
-        value: SyncParseReturnType<any>;
-        alwaysSet?: boolean;
-    }[]): SyncParseReturnType;
-}
-interface ParseResult {
-    status: "aborted" | "dirty" | "valid";
-    data: any;
-}
-type INVALID = {
-    status: "aborted";
-};
-declare const INVALID: INVALID;
-type DIRTY<T> = {
-    status: "dirty";
-    value: T;
-};
-declare const DIRTY: <T>(value: T) => DIRTY<T>;
-type OK<T> = {
-    status: "valid";
-    value: T;
-};
-declare const OK: <T>(value: T) => OK<T>;
-type SyncParseReturnType<T = any> = OK<T> | DIRTY<T> | INVALID;
-type AsyncParseReturnType<T> = Promise<SyncParseReturnType<T>>;
-type ParseReturnType<T> = SyncParseReturnType<T> | AsyncParseReturnType<T>;
-declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
-declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
-declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
-declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
-
-declare namespace enumUtil {
-    type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
-    type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
-    type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
-    type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
-    export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
-    export {};
-}
-
-declare namespace errorUtil {
-    type ErrMessage = string | {
-        message?: string;
-    };
-    const errToObj: (message?: ErrMessage) => {
-        message?: string | undefined;
-    };
-    const toString: (message?: ErrMessage) => string | undefined;
-}
-
-declare namespace partialUtil {
-    type DeepPartial<T extends ZodTypeAny> = T extends ZodObject<ZodRawShape> ? ZodObject<{
-        [k in keyof T["shape"]]: ZodOptional<DeepPartial<T["shape"][k]>>;
-    }, T["_def"]["unknownKeys"], T["_def"]["catchall"]> : T extends ZodArray<infer Type, infer Card> ? ZodArray<DeepPartial<Type>, Card> : T extends ZodOptional<infer Type> ? ZodOptional<DeepPartial<Type>> : T extends ZodNullable<infer Type> ? ZodNullable<DeepPartial<Type>> : T extends ZodTuple<infer Items> ? {
-        [k in keyof Items]: Items[k] extends ZodTypeAny ? DeepPartial<Items[k]> : never;
-    } extends infer PI ? PI extends ZodTupleItems ? ZodTuple<PI> : never : never : T;
-}
-
-/**
- * The Standard Schema interface.
- */
-type StandardSchemaV1<Input = unknown, Output = Input> = {
-    /**
-     * The Standard Schema properties.
-     */
-    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
-};
-declare namespace StandardSchemaV1 {
-    /**
-     * The Standard Schema properties interface.
-     */
-    export interface Props<Input = unknown, Output = Input> {
-        /**
-         * The version number of the standard.
-         */
-        readonly version: 1;
-        /**
-         * The vendor name of the schema library.
-         */
-        readonly vendor: string;
-        /**
-         * Validates unknown input values.
-         */
-        readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
-        /**
-         * Inferred types associated with the schema.
-         */
-        readonly types?: Types<Input, Output> | undefined;
-    }
-    /**
-     * The result interface of the validate function.
-     */
-    export type Result<Output> = SuccessResult<Output> | FailureResult;
-    /**
-     * The result interface if validation succeeds.
-     */
-    export interface SuccessResult<Output> {
-        /**
-         * The typed output value.
-         */
-        readonly value: Output;
-        /**
-         * The non-existent issues.
-         */
-        readonly issues?: undefined;
-    }
-    /**
-     * The result interface if validation fails.
-     */
-    export interface FailureResult {
-        /**
-         * The issues of failed validation.
-         */
-        readonly issues: ReadonlyArray<Issue>;
-    }
-    /**
-     * The issue interface of the failure output.
-     */
-    export interface Issue {
-        /**
-         * The error message of the issue.
-         */
-        readonly message: string;
-        /**
-         * The path of the issue, if any.
-         */
-        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
-    }
-    /**
-     * The path segment interface of the issue.
-     */
-    export interface PathSegment {
-        /**
-         * The key representing a path segment.
-         */
-        readonly key: PropertyKey;
-    }
-    /**
-     * The Standard Schema types interface.
-     */
-    export interface Types<Input = unknown, Output = Input> {
-        /**
-         * The input type of the schema.
-         */
-        readonly input: Input;
-        /**
-         * The output type of the schema.
-         */
-        readonly output: Output;
-    }
-    /**
-     * Infers the input type of a Standard Schema.
-     */
-    export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["input"];
-    /**
-     * Infers the output type of a Standard Schema.
-     */
-    export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema["~standard"]["types"]>["output"];
-    export {};
-}
-
-interface RefinementCtx {
-    addIssue: (arg: IssueData) => void;
-    path: (string | number)[];
-}
-type ZodRawShape = {
-    [k: string]: ZodTypeAny;
-};
-type ZodTypeAny = ZodType<any, any, any>;
-type TypeOf<T extends ZodType<any, any, any>> = T["_output"];
-type input<T extends ZodType<any, any, any>> = T["_input"];
-type output<T extends ZodType<any, any, any>> = T["_output"];
-
-type CustomErrorParams = Partial<util.Omit<ZodCustomIssue, "code">>;
-interface ZodTypeDef {
-    errorMap?: ZodErrorMap;
-    description?: string;
-}
-type RawCreateParams = {
-    errorMap?: ZodErrorMap;
-    invalid_type_error?: string;
-    required_error?: string;
-    message?: string;
-    description?: string;
-} | undefined;
-type ProcessedCreateParams = {
-    errorMap?: ZodErrorMap;
-    description?: string;
-};
-type SafeParseSuccess<Output> = {
-    success: true;
-    data: Output;
-    error?: never;
-};
-type SafeParseError<Input> = {
-    success: false;
-    error: ZodError<Input>;
-    data?: never;
-};
-type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
-    readonly _type: Output;
-    readonly _output: Output;
-    readonly _input: Input;
-    readonly _def: Def;
-    get description(): string | undefined;
-    "~standard": StandardSchemaV1.Props<Input, Output>;
-    abstract _parse(input: ParseInput): ParseReturnType<Output>;
-    _getType(input: ParseInput): string;
-    _getOrReturnCtx(input: ParseInput, ctx?: ParseContext | undefined): ParseContext;
-    _processInputParams(input: ParseInput): {
-        status: ParseStatus;
-        ctx: ParseContext;
-    };
-    _parseSync(input: ParseInput): SyncParseReturnType<Output>;
-    _parseAsync(input: ParseInput): AsyncParseReturnType<Output>;
-    parse(data: unknown, params?: Partial<ParseParams>): Output;
-    safeParse(data: unknown, params?: Partial<ParseParams>): SafeParseReturnType<Input, Output>;
-    "~validate"(data: unknown): StandardSchemaV1.Result<Output> | Promise<StandardSchemaV1.Result<Output>>;
-    parseAsync(data: unknown, params?: Partial<ParseParams>): Promise<Output>;
-    safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
-    /** Alias of safeParseAsync */
-    spa: (data: unknown, params?: Partial<ParseParams>) => Promise<SafeParseReturnType<Input, Output>>;
-    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
-    refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
-    refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
-    refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
-    _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
-    superRefine<RefinedOutput extends Output>(refinement: (arg: Output, ctx: RefinementCtx) => arg is RefinedOutput): ZodEffects<this, RefinedOutput, Input>;
-    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => void): ZodEffects<this, Output, Input>;
-    superRefine(refinement: (arg: Output, ctx: RefinementCtx) => Promise<void>): ZodEffects<this, Output, Input>;
-    constructor(def: Def);
-    optional(): ZodOptional<this>;
-    nullable(): ZodNullable<this>;
-    nullish(): ZodOptional<ZodNullable<this>>;
-    array(): ZodArray<this>;
-    promise(): ZodPromise<this>;
-    or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
-    and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
-    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
-    default(def: util.noUndefined<Input>): ZodDefault<this>;
-    default(def: () => util.noUndefined<Input>): ZodDefault<this>;
-    brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
-    catch(def: Output): ZodCatch<this>;
-    catch(def: (ctx: {
-        error: ZodError;
-        input: Input;
-    }) => Output): ZodCatch<this>;
-    describe(description: string): this;
-    pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
-    readonly(): ZodReadonly<this>;
-    isOptional(): boolean;
-    isNullable(): boolean;
-}
-type IpVersion = "v4" | "v6";
-type ZodStringCheck = {
-    kind: "min";
-    value: number;
-    message?: string;
-} | {
-    kind: "max";
-    value: number;
-    message?: string;
-} | {
-    kind: "length";
-    value: number;
-    message?: string;
-} | {
-    kind: "email";
-    message?: string;
-} | {
-    kind: "url";
-    message?: string;
-} | {
-    kind: "emoji";
-    message?: string;
-} | {
-    kind: "uuid";
-    message?: string;
-} | {
-    kind: "nanoid";
-    message?: string;
-} | {
-    kind: "cuid";
-    message?: string;
-} | {
-    kind: "includes";
-    value: string;
-    position?: number;
-    message?: string;
-} | {
-    kind: "cuid2";
-    message?: string;
-} | {
-    kind: "ulid";
-    message?: string;
-} | {
-    kind: "startsWith";
-    value: string;
-    message?: string;
-} | {
-    kind: "endsWith";
-    value: string;
-    message?: string;
-} | {
-    kind: "regex";
-    regex: RegExp;
-    message?: string;
-} | {
-    kind: "trim";
-    message?: string;
-} | {
-    kind: "toLowerCase";
-    message?: string;
-} | {
-    kind: "toUpperCase";
-    message?: string;
-} | {
-    kind: "jwt";
-    alg?: string;
-    message?: string;
-} | {
-    kind: "datetime";
-    offset: boolean;
-    local: boolean;
-    precision: number | null;
-    message?: string;
-} | {
-    kind: "date";
-    message?: string;
-} | {
-    kind: "time";
-    precision: number | null;
-    message?: string;
-} | {
-    kind: "duration";
-    message?: string;
-} | {
-    kind: "ip";
-    version?: IpVersion;
-    message?: string;
-} | {
-    kind: "cidr";
-    version?: IpVersion;
-    message?: string;
-} | {
-    kind: "base64";
-    message?: string;
-} | {
-    kind: "base64url";
-    message?: string;
-};
-interface ZodStringDef extends ZodTypeDef {
-    checks: ZodStringCheck[];
-    typeName: ZodFirstPartyTypeKind.ZodString;
-    coerce: boolean;
-}
-declare function datetimeRegex(args: {
-    precision?: number | null;
-    offset?: boolean;
-    local?: boolean;
-}): RegExp;
-declare class ZodString extends ZodType<string, ZodStringDef, string> {
-    _parse(input: ParseInput): ParseReturnType<string>;
-    protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
-    _addCheck(check: ZodStringCheck): ZodString;
-    email(message?: errorUtil.ErrMessage): ZodString;
-    url(message?: errorUtil.ErrMessage): ZodString;
-    emoji(message?: errorUtil.ErrMessage): ZodString;
-    uuid(message?: errorUtil.ErrMessage): ZodString;
-    nanoid(message?: errorUtil.ErrMessage): ZodString;
-    cuid(message?: errorUtil.ErrMessage): ZodString;
-    cuid2(message?: errorUtil.ErrMessage): ZodString;
-    ulid(message?: errorUtil.ErrMessage): ZodString;
-    base64(message?: errorUtil.ErrMessage): ZodString;
-    base64url(message?: errorUtil.ErrMessage): ZodString;
-    jwt(options?: {
-        alg?: string;
-        message?: string;
-    }): ZodString;
-    ip(options?: string | {
-        version?: IpVersion;
-        message?: string;
-    }): ZodString;
-    cidr(options?: string | {
-        version?: IpVersion;
-        message?: string;
-    }): ZodString;
-    datetime(options?: string | {
-        message?: string | undefined;
-        precision?: number | null;
-        offset?: boolean;
-        local?: boolean;
-    }): ZodString;
-    date(message?: string): ZodString;
-    time(options?: string | {
-        message?: string | undefined;
-        precision?: number | null;
-    }): ZodString;
-    duration(message?: errorUtil.ErrMessage): ZodString;
-    regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
-    includes(value: string, options?: {
-        message?: string;
-        position?: number;
-    }): ZodString;
-    startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
-    endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
-    min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
-    max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
-    length(len: number, message?: errorUtil.ErrMessage): ZodString;
-    /**
-     * Equivalent to `.min(1)`
-     */
-    nonempty(message?: errorUtil.ErrMessage): ZodString;
-    trim(): ZodString;
-    toLowerCase(): ZodString;
-    toUpperCase(): ZodString;
-    get isDatetime(): boolean;
-    get isDate(): boolean;
-    get isTime(): boolean;
-    get isDuration(): boolean;
-    get isEmail(): boolean;
-    get isURL(): boolean;
-    get isEmoji(): boolean;
-    get isUUID(): boolean;
-    get isNANOID(): boolean;
-    get isCUID(): boolean;
-    get isCUID2(): boolean;
-    get isULID(): boolean;
-    get isIP(): boolean;
-    get isCIDR(): boolean;
-    get isBase64(): boolean;
-    get isBase64url(): boolean;
-    get minLength(): number | null;
-    get maxLength(): number | null;
-    static create: (params?: RawCreateParams & {
-        coerce?: true;
-    }) => ZodString;
-}
-type ZodNumberCheck = {
-    kind: "min";
-    value: number;
-    inclusive: boolean;
-    message?: string;
-} | {
-    kind: "max";
-    value: number;
-    inclusive: boolean;
-    message?: string;
-} | {
-    kind: "int";
-    message?: string;
-} | {
-    kind: "multipleOf";
-    value: number;
-    message?: string;
-} | {
-    kind: "finite";
-    message?: string;
-};
-interface ZodNumberDef extends ZodTypeDef {
-    checks: ZodNumberCheck[];
-    typeName: ZodFirstPartyTypeKind.ZodNumber;
-    coerce: boolean;
-}
-declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
-    _parse(input: ParseInput): ParseReturnType<number>;
-    static create: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodNumber;
-    gte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    min: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-    gt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    lte(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    max: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-    lt(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    protected setLimit(kind: "min" | "max", value: number, inclusive: boolean, message?: string): ZodNumber;
-    _addCheck(check: ZodNumberCheck): ZodNumber;
-    int(message?: errorUtil.ErrMessage): ZodNumber;
-    positive(message?: errorUtil.ErrMessage): ZodNumber;
-    negative(message?: errorUtil.ErrMessage): ZodNumber;
-    nonpositive(message?: errorUtil.ErrMessage): ZodNumber;
-    nonnegative(message?: errorUtil.ErrMessage): ZodNumber;
-    multipleOf(value: number, message?: errorUtil.ErrMessage): ZodNumber;
-    step: (value: number, message?: errorUtil.ErrMessage) => ZodNumber;
-    finite(message?: errorUtil.ErrMessage): ZodNumber;
-    safe(message?: errorUtil.ErrMessage): ZodNumber;
-    get minValue(): number | null;
-    get maxValue(): number | null;
-    get isInt(): boolean;
-    get isFinite(): boolean;
-}
-type ZodBigIntCheck = {
-    kind: "min";
-    value: bigint;
-    inclusive: boolean;
-    message?: string;
-} | {
-    kind: "max";
-    value: bigint;
-    inclusive: boolean;
-    message?: string;
-} | {
-    kind: "multipleOf";
-    value: bigint;
-    message?: string;
-};
-interface ZodBigIntDef extends ZodTypeDef {
-    checks: ZodBigIntCheck[];
-    typeName: ZodFirstPartyTypeKind.ZodBigInt;
-    coerce: boolean;
-}
-declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
-    _parse(input: ParseInput): ParseReturnType<bigint>;
-    _getInvalidInput(input: ParseInput): INVALID;
-    static create: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodBigInt;
-    gte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    min: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
-    gt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    lte(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    max: (value: bigint, message?: errorUtil.ErrMessage) => ZodBigInt;
-    lt(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    protected setLimit(kind: "min" | "max", value: bigint, inclusive: boolean, message?: string): ZodBigInt;
-    _addCheck(check: ZodBigIntCheck): ZodBigInt;
-    positive(message?: errorUtil.ErrMessage): ZodBigInt;
-    negative(message?: errorUtil.ErrMessage): ZodBigInt;
-    nonpositive(message?: errorUtil.ErrMessage): ZodBigInt;
-    nonnegative(message?: errorUtil.ErrMessage): ZodBigInt;
-    multipleOf(value: bigint, message?: errorUtil.ErrMessage): ZodBigInt;
-    get minValue(): bigint | null;
-    get maxValue(): bigint | null;
-}
-interface ZodBooleanDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodBoolean;
-    coerce: boolean;
-}
-declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
-    _parse(input: ParseInput): ParseReturnType<boolean>;
-    static create: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodBoolean;
-}
-type ZodDateCheck = {
-    kind: "min";
-    value: number;
-    message?: string;
-} | {
-    kind: "max";
-    value: number;
-    message?: string;
-};
-interface ZodDateDef extends ZodTypeDef {
-    checks: ZodDateCheck[];
-    coerce: boolean;
-    typeName: ZodFirstPartyTypeKind.ZodDate;
-}
-declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    _addCheck(check: ZodDateCheck): ZodDate;
-    min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
-    max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
-    get minDate(): Date | null;
-    get maxDate(): Date | null;
-    static create: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodDate;
-}
-interface ZodSymbolDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodSymbol;
-}
-declare class ZodSymbol extends ZodType<symbol, ZodSymbolDef, symbol> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodSymbol;
-}
-interface ZodUndefinedDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodUndefined;
-}
-declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    params?: RawCreateParams;
-    static create: (params?: RawCreateParams) => ZodUndefined;
-}
-interface ZodNullDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodNull;
-}
-declare class ZodNull extends ZodType<null, ZodNullDef, null> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodNull;
-}
-interface ZodAnyDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodAny;
-}
-declare class ZodAny extends ZodType<any, ZodAnyDef, any> {
-    _any: true;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodAny;
-}
-interface ZodUnknownDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodUnknown;
-}
-declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {
-    _unknown: true;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodUnknown;
-}
-interface ZodNeverDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodNever;
-}
-declare class ZodNever extends ZodType<never, ZodNeverDef, never> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodNever;
-}
-interface ZodVoidDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodVoid;
-}
-declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: (params?: RawCreateParams) => ZodVoid;
-}
-interface ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodArray;
-    exactLength: {
-        value: number;
-        message?: string;
-    } | null;
-    minLength: {
-        value: number;
-        message?: string;
-    } | null;
-    maxLength: {
-        value: number;
-        message?: string;
-    } | null;
-}
-type ArrayCardinality = "many" | "atleastone";
-type arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = Cardinality extends "atleastone" ? [T["_output"], ...T["_output"][]] : T["_output"][];
-declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> extends ZodType<arrayOutputType<T, Cardinality>, ZodArrayDef<T>, Cardinality extends "atleastone" ? [T["_input"], ...T["_input"][]] : T["_input"][]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get element(): T;
-    min(minLength: number, message?: errorUtil.ErrMessage): this;
-    max(maxLength: number, message?: errorUtil.ErrMessage): this;
-    length(len: number, message?: errorUtil.ErrMessage): this;
-    nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1, "many">;
-}
-type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
-type UnknownKeysParam = "passthrough" | "strict" | "strip";
-interface ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodObject;
-    shape: () => T;
-    catchall: Catchall;
-    unknownKeys: UnknownKeys;
-}
-type mergeTypes<A, B> = {
-    [k in keyof A | keyof B]: k extends keyof B ? B[k] : k extends keyof A ? A[k] : never;
-};
-type objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<objectUtil.addQuestionMarks<baseObjectOutputType<Shape>>> & CatchallOutput<Catchall> & PassthroughType<UnknownKeys>;
-type baseObjectOutputType<Shape extends ZodRawShape> = {
-    [k in keyof Shape]: Shape[k]["_output"];
-};
-type objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectUtil.flatten<baseObjectInputType<Shape>> & CatchallInput<Catchall> & PassthroughType<UnknownKeys>;
-type baseObjectInputType<Shape extends ZodRawShape> = objectUtil.addQuestionMarks<{
-    [k in keyof Shape]: Shape[k]["_input"];
-}>;
-type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
-    [k: string]: T["_output"];
-};
-type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
-    [k: string]: T["_input"];
-};
-type PassthroughType<T extends UnknownKeysParam> = T extends "passthrough" ? {
-    [k: string]: unknown;
-} : unknown;
-type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
-type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-type noUnrecognized<Obj extends object, Shape extends object> = {
-    [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
-};
-declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
-    private _cached;
-    _getCached(): {
-        shape: T;
-        keys: string[];
-    };
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get shape(): T;
-    strict(message?: errorUtil.ErrMessage): ZodObject<T, "strict", Catchall>;
-    strip(): ZodObject<T, "strip", Catchall>;
-    passthrough(): ZodObject<T, "passthrough", Catchall>;
-    /**
-     * @deprecated In most cases, this is no longer needed - unknown properties are now silently stripped.
-     * If you want to pass through unknown properties, use `.passthrough()` instead.
-     */
-    nonstrict: () => ZodObject<T, "passthrough", Catchall>;
-    extend<Augmentation extends ZodRawShape>(augmentation: Augmentation): ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-    /**
-     * @deprecated Use `.extend` instead
-     *  */
-    augment: <Augmentation extends ZodRawShape>(augmentation: Augmentation) => ZodObject<objectUtil.extendShape<T, Augmentation>, UnknownKeys, Catchall>;
-    /**
-     * Prior to zod@1.0.12 there was a bug in the
-     * inferred type of merged objects. Please
-     * upgrade if you are experiencing issues.
-     */
-    merge<Incoming extends AnyZodObject, Augmentation extends Incoming["shape"]>(merging: Incoming): ZodObject<objectUtil.extendShape<T, Augmentation>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
-    setKey<Key extends string, Schema extends ZodTypeAny>(key: Key, schema: Schema): ZodObject<T & {
-        [k in Key]: Schema;
-    }, UnknownKeys, Catchall>;
-    catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
-    pick<Mask extends util.Exactly<{
-        [k in keyof T]?: true;
-    }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-    omit<Mask extends util.Exactly<{
-        [k in keyof T]?: true;
-    }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
-    /**
-     * @deprecated
-     */
-    deepPartial(): partialUtil.DeepPartial<this>;
-    partial(): ZodObject<{
-        [k in keyof T]: ZodOptional<T[k]>;
-    }, UnknownKeys, Catchall>;
-    partial<Mask extends util.Exactly<{
-        [k in keyof T]?: true;
-    }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
-        [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
-    }>, UnknownKeys, Catchall>;
-    required(): ZodObject<{
-        [k in keyof T]: deoptional<T[k]>;
-    }, UnknownKeys, Catchall>;
-    required<Mask extends util.Exactly<{
-        [k in keyof T]?: true;
-    }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
-        [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
-    }>, UnknownKeys, Catchall>;
-    keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any> extends infer T_2 ? { [k in keyof T_2]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, any>[k]; } : never, baseObjectInputType<T_1> extends infer T_3 ? { [k_1 in keyof T_3]: baseObjectInputType<T_1>[k_1]; } : never>;
-}
-type AnyZodObject = ZodObject<any, any, any>;
-type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
-interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[
-    ZodTypeAny,
-    ZodTypeAny,
-    ...ZodTypeAny[]
-]>> extends ZodTypeDef {
-    options: T;
-    typeName: ZodFirstPartyTypeKind.ZodUnion;
-}
-declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get options(): T;
-    static create: <T_1 extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
-}
-type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
-    [key in Discriminator]: ZodTypeAny;
-} & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
-interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
-    discriminator: Discriminator;
-    options: Options;
-    optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
-    typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion;
-}
-declare class ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get discriminator(): Discriminator;
-    get options(): Options;
-    get optionsMap(): Map<Primitive, ZodDiscriminatedUnionOption<any>>;
-    /**
-     * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
-     * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
-     * have a different value for each object in the union.
-     * @param discriminator the name of the discriminator property
-     * @param types an array of object schemas
-     * @param params
-     */
-    static create<Discriminator extends string, Types extends readonly [
-        ZodDiscriminatedUnionOption<Discriminator>,
-        ...ZodDiscriminatedUnionOption<Discriminator>[]
-    ]>(discriminator: Discriminator, options: Types, params?: RawCreateParams): ZodDiscriminatedUnion<Discriminator, Types>;
-}
-interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    left: T;
-    right: U;
-    typeName: ZodFirstPartyTypeKind.ZodIntersection;
-}
-declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
-}
-type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-type AssertArray<T> = T extends any[] ? T : never;
-type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
-    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;
-}>;
-type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
-type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
-    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;
-}>;
-type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
-interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> extends ZodTypeDef {
-    items: T;
-    rest: Rest;
-    typeName: ZodFirstPartyTypeKind.ZodTuple;
-}
-type AnyZodTuple = ZodTuple<[
-    ZodTypeAny,
-    ...ZodTypeAny[]
-] | [], ZodTypeAny | null>;
-declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get items(): T;
-    rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
-}
-interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    valueType: Value;
-    keyType: Key;
-    typeName: ZodFirstPartyTypeKind.ZodRecord;
-}
-type KeySchema = ZodType<string | number | symbol, any, any>;
-type RecordType<K extends string | number | symbol, V> = [
-    string
-] extends [K] ? Record<K, V> : [number] extends [K] ? Record<K, V> : [symbol] extends [K] ? Record<K, V> : [BRAND<string | number | symbol>] extends [K] ? Record<K, V> : Partial<Record<K, V>>;
-declare class ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<RecordType<Key["_output"], Value["_output"]>, ZodRecordDef<Key, Value>, RecordType<Key["_input"], Value["_input"]>> {
-    get keySchema(): Key;
-    get valueSchema(): Value;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get element(): Value;
-    static create<Value extends ZodTypeAny>(valueType: Value, params?: RawCreateParams): ZodRecord<ZodString, Value>;
-    static create<Keys extends KeySchema, Value extends ZodTypeAny>(keySchema: Keys, valueType: Value, params?: RawCreateParams): ZodRecord<Keys, Value>;
-}
-interface ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    valueType: Value;
-    keyType: Key;
-    typeName: ZodFirstPartyTypeKind.ZodMap;
-}
-declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Map<Key["_output"], Value["_output"]>, ZodMapDef<Key, Value>, Map<Key["_input"], Value["_input"]>> {
-    get keySchema(): Key;
-    get valueSchema(): Value;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <Key_1 extends ZodTypeAny = ZodTypeAny, Value_1 extends ZodTypeAny = ZodTypeAny>(keyType: Key_1, valueType: Value_1, params?: RawCreateParams) => ZodMap<Key_1, Value_1>;
-}
-interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    valueType: Value;
-    typeName: ZodFirstPartyTypeKind.ZodSet;
-    minSize: {
-        value: number;
-        message?: string;
-    } | null;
-    maxSize: {
-        value: number;
-        message?: string;
-    } | null;
-}
-declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<Set<Value["_output"]>, ZodSetDef<Value>, Set<Value["_input"]>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    min(minSize: number, message?: errorUtil.ErrMessage): this;
-    max(maxSize: number, message?: errorUtil.ErrMessage): this;
-    size(size: number, message?: errorUtil.ErrMessage): this;
-    nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
-    static create: <Value_1 extends ZodTypeAny = ZodTypeAny>(valueType: Value_1, params?: RawCreateParams) => ZodSet<Value_1>;
-}
-interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    args: Args;
-    returns: Returns;
-    typeName: ZodFirstPartyTypeKind.ZodFunction;
-}
-type OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_input"] extends Array<any> ? (...args: Args["_input"]) => Returns["_output"] : never;
-type InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = Args["_output"] extends Array<any> ? (...args: Args["_output"]) => Returns["_input"] : never;
-declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> extends ZodType<OuterTypeOfFunction<Args, Returns>, ZodFunctionDef<Args, Returns>, InnerTypeOfFunction<Args, Returns>> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    parameters(): Args;
-    returnType(): Returns;
-    args<Items extends Parameters<(typeof ZodTuple)["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
-    returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
-    implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
-    strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
-    validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
-    static create(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>;
-    static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;
-    static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;
-    static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;
-}
-interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    getter: () => T;
-    typeName: ZodFirstPartyTypeKind.ZodLazy;
-}
-declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
-    get schema(): T;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(getter: () => T_1, params?: RawCreateParams) => ZodLazy<T_1>;
-}
-interface ZodLiteralDef<T = any> extends ZodTypeDef {
-    value: T;
-    typeName: ZodFirstPartyTypeKind.ZodLiteral;
-}
-declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get value(): T;
-    static create: <T_1 extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
-}
-type ArrayKeys = keyof any[];
-type Indices<T> = Exclude<keyof T, ArrayKeys>;
-type EnumValues<T extends string = string> = readonly [T, ...T[]];
-type Values<T extends EnumValues> = {
-    [k in T[number]]: k;
-};
-interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDef {
-    values: T;
-    typeName: ZodFirstPartyTypeKind.ZodEnum;
-}
-type Writeable<T> = {
-    -readonly [P in keyof T]: T[P];
-};
-type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
-type typecast<A, T> = A extends T ? A : never;
-declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
-declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
-declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
-    #private;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    get options(): T;
-    get enum(): Values<T>;
-    get Values(): Values<T>;
-    get Enum(): Values<T>;
-    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;
-    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
-    static create: typeof createZodEnum;
-}
-interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
-    values: T;
-    typeName: ZodFirstPartyTypeKind.ZodNativeEnum;
-}
-type EnumLike = {
-    [k: string]: string | number;
-    [nu: number]: string;
-};
-declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {
-    #private;
-    _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
-    get enum(): T;
-    static create: <T_1 extends EnumLike>(values: T_1, params?: RawCreateParams) => ZodNativeEnum<T_1>;
-}
-interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodPromise;
-}
-declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
-    unwrap(): T;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
-}
-type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
-type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
-type RefinementEffect<T> = {
-    type: "refinement";
-    refinement: (arg: T, ctx: RefinementCtx) => any;
-};
-type TransformEffect<T> = {
-    type: "transform";
-    transform: (arg: T, ctx: RefinementCtx) => any;
-};
-type PreprocessEffect<T> = {
-    type: "preprocess";
-    transform: (arg: T, ctx: RefinementCtx) => any;
-};
-type Effect<T> = RefinementEffect<T> | TransformEffect<T> | PreprocessEffect<T>;
-interface ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    schema: T;
-    typeName: ZodFirstPartyTypeKind.ZodEffects;
-    effect: Effect<any>;
-}
-declare class ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> extends ZodType<Output, ZodEffectsDef<T>, Input> {
-    innerType(): T;
-    sourceType(): T;
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-}
-
-interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodOptional;
-}
-type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
-declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
-}
-interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodNullable;
-}
-type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
-declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    unwrap(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
-}
-interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    defaultValue: () => util.noUndefined<T["_input"]>;
-    typeName: ZodFirstPartyTypeKind.ZodDefault;
-}
-declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    removeDefault(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
-    }) => ZodDefault<T_1>;
-}
-interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    catchValue: (ctx: {
-        error: ZodError;
-        input: unknown;
-    }) => T["_input"];
-    typeName: ZodFirstPartyTypeKind.ZodCatch;
-}
-declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    removeCatch(): T;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
-        errorMap?: ZodErrorMap | undefined;
-        invalid_type_error?: string | undefined;
-        required_error?: string | undefined;
-        message?: string | undefined;
-        description?: string | undefined;
-    } & {
-        catch: T_1["_output"] | (() => T_1["_output"]);
-    }) => ZodCatch<T_1>;
-}
-interface ZodNaNDef extends ZodTypeDef {
-    typeName: ZodFirstPartyTypeKind.ZodNaN;
-}
-declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    static create: (params?: RawCreateParams) => ZodNaN;
-}
-interface ZodBrandedDef<T extends ZodTypeAny> extends ZodTypeDef {
-    type: T;
-    typeName: ZodFirstPartyTypeKind.ZodBranded;
-}
-declare const BRAND: unique symbol;
-type BRAND<T extends string | number | symbol> = {
-    [BRAND]: {
-        [k in T]: true;
-    };
-};
-declare class ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> extends ZodType<T["_output"] & BRAND<B>, ZodBrandedDef<T>, T["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    unwrap(): T;
-}
-interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodTypeDef {
-    in: A;
-    out: B;
-    typeName: ZodFirstPartyTypeKind.ZodPipeline;
-}
-declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
-    _parse(input: ParseInput): ParseReturnType<any>;
-    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
-}
-type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
-    readonly [Symbol.toStringTag]: string;
-} | Date | Error | Generator | Promise<unknown> | RegExp;
-type MakeReadonly<T> = T extends Map<infer K, infer V> ? ReadonlyMap<K, V> : T extends Set<infer V> ? ReadonlySet<V> : T extends [infer Head, ...infer Tail] ? readonly [Head, ...Tail] : T extends Array<infer V> ? ReadonlyArray<V> : T extends BuiltIn ? T : Readonly<T>;
-interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
-    innerType: T;
-    typeName: ZodFirstPartyTypeKind.ZodReadonly;
-}
-declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
-    _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
-    unwrap(): T;
-}
-type CustomParams = CustomErrorParams & {
-    fatal?: boolean;
-};
-declare function custom<T>(check?: (data: any) => any, _params?: string | CustomParams | ((input: any) => CustomParams), 
-/**
- * @deprecated
- *
- * Pass `fatal` into the params object instead:
- *
- * ```ts
- * z.string().custom((val) => val.length > 5, { fatal: false })
- * ```
- *
- */
-fatal?: boolean): ZodType<T, ZodTypeDef, T>;
-
-declare const late: {
-    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip">;
-};
-declare enum ZodFirstPartyTypeKind {
-    ZodString = "ZodString",
-    ZodNumber = "ZodNumber",
-    ZodNaN = "ZodNaN",
-    ZodBigInt = "ZodBigInt",
-    ZodBoolean = "ZodBoolean",
-    ZodDate = "ZodDate",
-    ZodSymbol = "ZodSymbol",
-    ZodUndefined = "ZodUndefined",
-    ZodNull = "ZodNull",
-    ZodAny = "ZodAny",
-    ZodUnknown = "ZodUnknown",
-    ZodNever = "ZodNever",
-    ZodVoid = "ZodVoid",
-    ZodArray = "ZodArray",
-    ZodObject = "ZodObject",
-    ZodUnion = "ZodUnion",
-    ZodDiscriminatedUnion = "ZodDiscriminatedUnion",
-    ZodIntersection = "ZodIntersection",
-    ZodTuple = "ZodTuple",
-    ZodRecord = "ZodRecord",
-    ZodMap = "ZodMap",
-    ZodSet = "ZodSet",
-    ZodFunction = "ZodFunction",
-    ZodLazy = "ZodLazy",
-    ZodLiteral = "ZodLiteral",
-    ZodEnum = "ZodEnum",
-    ZodEffects = "ZodEffects",
-    ZodNativeEnum = "ZodNativeEnum",
-    ZodOptional = "ZodOptional",
-    ZodNullable = "ZodNullable",
-    ZodDefault = "ZodDefault",
-    ZodCatch = "ZodCatch",
-    ZodPromise = "ZodPromise",
-    ZodBranded = "ZodBranded",
-    ZodPipeline = "ZodPipeline",
-    ZodReadonly = "ZodReadonly"
-}
-type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any> | ZodReadonly<any> | ZodSymbol;
-declare abstract class Class {
-    constructor(..._: any[]);
-}
-declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
-declare const stringType: (params?: RawCreateParams & {
-    coerce?: true;
-}) => ZodString;
-declare const numberType: (params?: RawCreateParams & {
-    coerce?: boolean;
-}) => ZodNumber;
-declare const nanType: (params?: RawCreateParams) => ZodNaN;
-declare const bigIntType: (params?: RawCreateParams & {
-    coerce?: boolean;
-}) => ZodBigInt;
-declare const booleanType: (params?: RawCreateParams & {
-    coerce?: boolean;
-}) => ZodBoolean;
-declare const dateType: (params?: RawCreateParams & {
-    coerce?: boolean;
-}) => ZodDate;
-declare const symbolType: (params?: RawCreateParams) => ZodSymbol;
-declare const undefinedType: (params?: RawCreateParams) => ZodUndefined;
-declare const nullType: (params?: RawCreateParams) => ZodNull;
-declare const anyType: (params?: RawCreateParams) => ZodAny;
-declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
-declare const neverType: (params?: RawCreateParams) => ZodNever;
-declare const voidType: (params?: RawCreateParams) => ZodVoid;
-declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T>;
-declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, objectOutputType<T, ZodTypeAny, "strip">, objectInputType<T, ZodTypeAny, "strip">>;
-declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict">;
-declare const unionType: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
-declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
-declare const intersectionType: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: RawCreateParams) => ZodIntersection<T, U>;
-declare const tupleType: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T, params?: RawCreateParams) => ZodTuple<T, null>;
-declare const recordType: typeof ZodRecord.create;
-declare const mapType: <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(keyType: Key, valueType: Value, params?: RawCreateParams) => ZodMap<Key, Value>;
-declare const setType: <Value extends ZodTypeAny = ZodTypeAny>(valueType: Value, params?: RawCreateParams) => ZodSet<Value>;
-declare const functionType: typeof ZodFunction.create;
-declare const lazyType: <T extends ZodTypeAny>(getter: () => T, params?: RawCreateParams) => ZodLazy<T>;
-declare const literalType: <T extends Primitive>(value: T, params?: RawCreateParams) => ZodLiteral<T>;
-declare const enumType: typeof createZodEnum;
-declare const nativeEnumType: <T extends EnumLike>(values: T, params?: RawCreateParams) => ZodNativeEnum<T>;
-declare const promiseType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodPromise<T>;
-declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-declare const optionalType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodOptional<T>;
-declare const nullableType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodNullable<T>;
-declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
-declare const pipelineType: typeof ZodPipeline.create;
-declare const ostring: () => ZodOptional<ZodString>;
-declare const onumber: () => ZodOptional<ZodNumber>;
-declare const oboolean: () => ZodOptional<ZodBoolean>;
-declare const coerce: {
-    string: (params?: RawCreateParams & {
-        coerce?: true;
-    }) => ZodString;
-    number: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodNumber;
-    boolean: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodBoolean;
-    bigint: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodBigInt;
-    date: (params?: RawCreateParams & {
-        coerce?: boolean;
-    }) => ZodDate;
-};
-
-declare const NEVER: never;
-
-type z_AnyZodObject = AnyZodObject;
-type z_AnyZodTuple = AnyZodTuple;
-type z_ArrayCardinality = ArrayCardinality;
-type z_ArrayKeys = ArrayKeys;
-type z_AssertArray<T> = AssertArray<T>;
-type z_AsyncParseReturnType<T> = AsyncParseReturnType<T>;
-type z_BRAND<T extends string | number | symbol> = BRAND<T>;
-type z_CatchallInput<T extends ZodType> = CatchallInput<T>;
-type z_CatchallOutput<T extends ZodType> = CatchallOutput<T>;
-type z_CustomErrorParams = CustomErrorParams;
-declare const z_DIRTY: typeof DIRTY;
-type z_DenormalizedError = DenormalizedError;
-declare const z_EMPTY_PATH: typeof EMPTY_PATH;
-type z_Effect<T> = Effect<T>;
-type z_EnumLike = EnumLike;
-type z_EnumValues<T extends string = string> = EnumValues<T>;
-type z_ErrorMapCtx = ErrorMapCtx;
-type z_FilterEnum<Values, ToExclude> = FilterEnum<Values, ToExclude>;
-declare const z_INVALID: typeof INVALID;
-type z_Indices<T> = Indices<T>;
-type z_InnerTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = InnerTypeOfFunction<Args, Returns>;
-type z_InputTypeOfTuple<T extends ZodTupleItems | []> = InputTypeOfTuple<T>;
-type z_InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = InputTypeOfTupleWithRest<T, Rest>;
-type z_IpVersion = IpVersion;
-type z_IssueData = IssueData;
-type z_KeySchema = KeySchema;
-declare const z_NEVER: typeof NEVER;
-declare const z_OK: typeof OK;
-type z_ObjectPair = ObjectPair;
-type z_OuterTypeOfFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = OuterTypeOfFunction<Args, Returns>;
-type z_OutputTypeOfTuple<T extends ZodTupleItems | []> = OutputTypeOfTuple<T>;
-type z_OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = OutputTypeOfTupleWithRest<T, Rest>;
-type z_ParseContext = ParseContext;
-type z_ParseInput = ParseInput;
-type z_ParseParams = ParseParams;
-type z_ParsePath = ParsePath;
-type z_ParsePathComponent = ParsePathComponent;
-type z_ParseResult = ParseResult;
-type z_ParseReturnType<T> = ParseReturnType<T>;
-type z_ParseStatus = ParseStatus;
-declare const z_ParseStatus: typeof ParseStatus;
-type z_PassthroughType<T extends UnknownKeysParam> = PassthroughType<T>;
-type z_PreprocessEffect<T> = PreprocessEffect<T>;
-type z_Primitive = Primitive;
-type z_ProcessedCreateParams = ProcessedCreateParams;
-type z_RawCreateParams = RawCreateParams;
-type z_RecordType<K extends string | number | symbol, V> = RecordType<K, V>;
-type z_Refinement<T> = Refinement<T>;
-type z_RefinementCtx = RefinementCtx;
-type z_RefinementEffect<T> = RefinementEffect<T>;
-type z_SafeParseError<Input> = SafeParseError<Input>;
-type z_SafeParseReturnType<Input, Output> = SafeParseReturnType<Input, Output>;
-type z_SafeParseSuccess<Output> = SafeParseSuccess<Output>;
-type z_Scalars = Scalars;
-type z_SomeZodObject = SomeZodObject;
-type z_StringValidation = StringValidation;
-type z_SuperRefinement<T> = SuperRefinement<T>;
-type z_SyncParseReturnType<T = any> = SyncParseReturnType<T>;
-type z_TransformEffect<T> = TransformEffect<T>;
-type z_TypeOf<T extends ZodType<any, any, any>> = TypeOf<T>;
-type z_UnknownKeysParam = UnknownKeysParam;
-type z_Values<T extends EnumValues> = Values<T>;
-type z_Writeable<T> = Writeable<T>;
-type z_ZodAny = ZodAny;
-declare const z_ZodAny: typeof ZodAny;
-type z_ZodAnyDef = ZodAnyDef;
-type z_ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = ZodArray<T, Cardinality>;
-declare const z_ZodArray: typeof ZodArray;
-type z_ZodArrayDef<T extends ZodTypeAny = ZodTypeAny> = ZodArrayDef<T>;
-type z_ZodBigInt = ZodBigInt;
-declare const z_ZodBigInt: typeof ZodBigInt;
-type z_ZodBigIntCheck = ZodBigIntCheck;
-type z_ZodBigIntDef = ZodBigIntDef;
-type z_ZodBoolean = ZodBoolean;
-declare const z_ZodBoolean: typeof ZodBoolean;
-type z_ZodBooleanDef = ZodBooleanDef;
-type z_ZodBranded<T extends ZodTypeAny, B extends string | number | symbol> = ZodBranded<T, B>;
-declare const z_ZodBranded: typeof ZodBranded;
-type z_ZodBrandedDef<T extends ZodTypeAny> = ZodBrandedDef<T>;
-type z_ZodCatch<T extends ZodTypeAny> = ZodCatch<T>;
-declare const z_ZodCatch: typeof ZodCatch;
-type z_ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> = ZodCatchDef<T>;
-type z_ZodCustomIssue = ZodCustomIssue;
-type z_ZodDate = ZodDate;
-declare const z_ZodDate: typeof ZodDate;
-type z_ZodDateCheck = ZodDateCheck;
-type z_ZodDateDef = ZodDateDef;
-type z_ZodDefault<T extends ZodTypeAny> = ZodDefault<T>;
-declare const z_ZodDefault: typeof ZodDefault;
-type z_ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> = ZodDefaultDef<T>;
-type z_ZodDiscriminatedUnion<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[]> = ZodDiscriminatedUnion<Discriminator, Options>;
-declare const z_ZodDiscriminatedUnion: typeof ZodDiscriminatedUnion;
-type z_ZodDiscriminatedUnionDef<Discriminator extends string, Options extends readonly ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> = ZodDiscriminatedUnionDef<Discriminator, Options>;
-type z_ZodDiscriminatedUnionOption<Discriminator extends string> = ZodDiscriminatedUnionOption<Discriminator>;
-type z_ZodEffects<T extends ZodTypeAny, Output = output<T>, Input = input<T>> = ZodEffects<T, Output, Input>;
-declare const z_ZodEffects: typeof ZodEffects;
-type z_ZodEffectsDef<T extends ZodTypeAny = ZodTypeAny> = ZodEffectsDef<T>;
-type z_ZodEnum<T extends [string, ...string[]]> = ZodEnum<T>;
-declare const z_ZodEnum: typeof ZodEnum;
-type z_ZodEnumDef<T extends EnumValues = EnumValues> = ZodEnumDef<T>;
-type z_ZodError<T = any> = ZodError<T>;
-declare const z_ZodError: typeof ZodError;
-type z_ZodErrorMap = ZodErrorMap;
-type z_ZodFirstPartySchemaTypes = ZodFirstPartySchemaTypes;
-type z_ZodFirstPartyTypeKind = ZodFirstPartyTypeKind;
-declare const z_ZodFirstPartyTypeKind: typeof ZodFirstPartyTypeKind;
-type z_ZodFormattedError<T, U = string> = ZodFormattedError<T, U>;
-type z_ZodFunction<Args extends ZodTuple<any, any>, Returns extends ZodTypeAny> = ZodFunction<Args, Returns>;
-declare const z_ZodFunction: typeof ZodFunction;
-type z_ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> = ZodFunctionDef<Args, Returns>;
-type z_ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> = ZodIntersection<T, U>;
-declare const z_ZodIntersection: typeof ZodIntersection;
-type z_ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends ZodTypeAny = ZodTypeAny> = ZodIntersectionDef<T, U>;
-type z_ZodInvalidArgumentsIssue = ZodInvalidArgumentsIssue;
-type z_ZodInvalidDateIssue = ZodInvalidDateIssue;
-type z_ZodInvalidEnumValueIssue = ZodInvalidEnumValueIssue;
-type z_ZodInvalidIntersectionTypesIssue = ZodInvalidIntersectionTypesIssue;
-type z_ZodInvalidLiteralIssue = ZodInvalidLiteralIssue;
-type z_ZodInvalidReturnTypeIssue = ZodInvalidReturnTypeIssue;
-type z_ZodInvalidStringIssue = ZodInvalidStringIssue;
-type z_ZodInvalidTypeIssue = ZodInvalidTypeIssue;
-type z_ZodInvalidUnionDiscriminatorIssue = ZodInvalidUnionDiscriminatorIssue;
-type z_ZodInvalidUnionIssue = ZodInvalidUnionIssue;
-type z_ZodIssue = ZodIssue;
-type z_ZodIssueBase = ZodIssueBase;
-type z_ZodIssueCode = ZodIssueCode;
-type z_ZodIssueOptionalMessage = ZodIssueOptionalMessage;
-type z_ZodLazy<T extends ZodTypeAny> = ZodLazy<T>;
-declare const z_ZodLazy: typeof ZodLazy;
-type z_ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> = ZodLazyDef<T>;
-type z_ZodLiteral<T> = ZodLiteral<T>;
-declare const z_ZodLiteral: typeof ZodLiteral;
-type z_ZodLiteralDef<T = any> = ZodLiteralDef<T>;
-type z_ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMap<Key, Value>;
-declare const z_ZodMap: typeof ZodMap;
-type z_ZodMapDef<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny> = ZodMapDef<Key, Value>;
-type z_ZodNaN = ZodNaN;
-declare const z_ZodNaN: typeof ZodNaN;
-type z_ZodNaNDef = ZodNaNDef;
-type z_ZodNativeEnum<T extends EnumLike> = ZodNativeEnum<T>;
-declare const z_ZodNativeEnum: typeof ZodNativeEnum;
-type z_ZodNativeEnumDef<T extends EnumLike = EnumLike> = ZodNativeEnumDef<T>;
-type z_ZodNever = ZodNever;
-declare const z_ZodNever: typeof ZodNever;
-type z_ZodNeverDef = ZodNeverDef;
-type z_ZodNonEmptyArray<T extends ZodTypeAny> = ZodNonEmptyArray<T>;
-type z_ZodNotFiniteIssue = ZodNotFiniteIssue;
-type z_ZodNotMultipleOfIssue = ZodNotMultipleOfIssue;
-type z_ZodNull = ZodNull;
-declare const z_ZodNull: typeof ZodNull;
-type z_ZodNullDef = ZodNullDef;
-type z_ZodNullable<T extends ZodTypeAny> = ZodNullable<T>;
-declare const z_ZodNullable: typeof ZodNullable;
-type z_ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> = ZodNullableDef<T>;
-type z_ZodNullableType<T extends ZodTypeAny> = ZodNullableType<T>;
-type z_ZodNumber = ZodNumber;
-declare const z_ZodNumber: typeof ZodNumber;
-type z_ZodNumberCheck = ZodNumberCheck;
-type z_ZodNumberDef = ZodNumberDef;
-type z_ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall, UnknownKeys>, Input = objectInputType<T, Catchall, UnknownKeys>> = ZodObject<T, UnknownKeys, Catchall, Output, Input>;
-declare const z_ZodObject: typeof ZodObject;
-type z_ZodObjectDef<T extends ZodRawShape = ZodRawShape, UnknownKeys extends UnknownKeysParam = UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny> = ZodObjectDef<T, UnknownKeys, Catchall>;
-type z_ZodOptional<T extends ZodTypeAny> = ZodOptional<T>;
-declare const z_ZodOptional: typeof ZodOptional;
-type z_ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> = ZodOptionalDef<T>;
-type z_ZodOptionalType<T extends ZodTypeAny> = ZodOptionalType<T>;
-type z_ZodParsedType = ZodParsedType;
-type z_ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> = ZodPipeline<A, B>;
-declare const z_ZodPipeline: typeof ZodPipeline;
-type z_ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> = ZodPipelineDef<A, B>;
-type z_ZodPromise<T extends ZodTypeAny> = ZodPromise<T>;
-declare const z_ZodPromise: typeof ZodPromise;
-type z_ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> = ZodPromiseDef<T>;
-type z_ZodRawShape = ZodRawShape;
-type z_ZodReadonly<T extends ZodTypeAny> = ZodReadonly<T>;
-declare const z_ZodReadonly: typeof ZodReadonly;
-type z_ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> = ZodReadonlyDef<T>;
-type z_ZodRecord<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecord<Key, Value>;
-declare const z_ZodRecord: typeof ZodRecord;
-type z_ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> = ZodRecordDef<Key, Value>;
-type z_ZodSet<Value extends ZodTypeAny = ZodTypeAny> = ZodSet<Value>;
-declare const z_ZodSet: typeof ZodSet;
-type z_ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> = ZodSetDef<Value>;
-type z_ZodString = ZodString;
-declare const z_ZodString: typeof ZodString;
-type z_ZodStringCheck = ZodStringCheck;
-type z_ZodStringDef = ZodStringDef;
-type z_ZodSymbol = ZodSymbol;
-declare const z_ZodSymbol: typeof ZodSymbol;
-type z_ZodSymbolDef = ZodSymbolDef;
-type z_ZodTooBigIssue = ZodTooBigIssue;
-type z_ZodTooSmallIssue = ZodTooSmallIssue;
-type z_ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> = ZodTuple<T, Rest>;
-declare const z_ZodTuple: typeof ZodTuple;
-type z_ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest extends ZodTypeAny | null = null> = ZodTupleDef<T, Rest>;
-type z_ZodTupleItems = ZodTupleItems;
-type z_ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> = ZodType<Output, Def, Input>;
-declare const z_ZodType: typeof ZodType;
-type z_ZodTypeAny = ZodTypeAny;
-type z_ZodTypeDef = ZodTypeDef;
-type z_ZodUndefined = ZodUndefined;
-declare const z_ZodUndefined: typeof ZodUndefined;
-type z_ZodUndefinedDef = ZodUndefinedDef;
-type z_ZodUnion<T extends ZodUnionOptions> = ZodUnion<T>;
-declare const z_ZodUnion: typeof ZodUnion;
-type z_ZodUnionDef<T extends ZodUnionOptions = Readonly<[
-    ZodTypeAny,
-    ZodTypeAny,
-    ...ZodTypeAny[]
-]>> = ZodUnionDef<T>;
-type z_ZodUnionOptions = ZodUnionOptions;
-type z_ZodUnknown = ZodUnknown;
-declare const z_ZodUnknown: typeof ZodUnknown;
-type z_ZodUnknownDef = ZodUnknownDef;
-type z_ZodUnrecognizedKeysIssue = ZodUnrecognizedKeysIssue;
-type z_ZodVoid = ZodVoid;
-declare const z_ZodVoid: typeof ZodVoid;
-type z_ZodVoidDef = ZodVoidDef;
-declare const z_addIssueToContext: typeof addIssueToContext;
-type z_arrayOutputType<T extends ZodTypeAny, Cardinality extends ArrayCardinality = "many"> = arrayOutputType<T, Cardinality>;
-type z_baseObjectInputType<Shape extends ZodRawShape> = baseObjectInputType<Shape>;
-type z_baseObjectOutputType<Shape extends ZodRawShape> = baseObjectOutputType<Shape>;
-declare const z_coerce: typeof coerce;
-declare const z_custom: typeof custom;
-declare const z_datetimeRegex: typeof datetimeRegex;
-type z_deoptional<T extends ZodTypeAny> = deoptional<T>;
-declare const z_getErrorMap: typeof getErrorMap;
-declare const z_getParsedType: typeof getParsedType;
-type z_inferFlattenedErrors<T extends ZodType<any, any, any>, U = string> = inferFlattenedErrors<T, U>;
-type z_inferFormattedError<T extends ZodType<any, any, any>, U = string> = inferFormattedError<T, U>;
-type z_input<T extends ZodType<any, any, any>> = input<T>;
-declare const z_isAborted: typeof isAborted;
-declare const z_isAsync: typeof isAsync;
-declare const z_isDirty: typeof isDirty;
-declare const z_isValid: typeof isValid;
-declare const z_late: typeof late;
-declare const z_makeIssue: typeof makeIssue;
-type z_mergeTypes<A, B> = mergeTypes<A, B>;
-type z_noUnrecognized<Obj extends object, Shape extends object> = noUnrecognized<Obj, Shape>;
-type z_objectInputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectInputType<Shape, Catchall, UnknownKeys>;
-type z_objectOutputType<Shape extends ZodRawShape, Catchall extends ZodTypeAny, UnknownKeys extends UnknownKeysParam = UnknownKeysParam> = objectOutputType<Shape, Catchall, UnknownKeys>;
-import z_objectUtil = objectUtil;
-declare const z_oboolean: typeof oboolean;
-declare const z_onumber: typeof onumber;
-declare const z_ostring: typeof ostring;
-type z_output<T extends ZodType<any, any, any>> = output<T>;
-declare const z_quotelessJson: typeof quotelessJson;
-declare const z_setErrorMap: typeof setErrorMap;
-type z_typeToFlattenedError<T, U = string> = typeToFlattenedError<T, U>;
-type z_typecast<A, T> = typecast<A, T>;
-import z_util = util;
-declare namespace z {
-  export { z_DIRTY as DIRTY, z_EMPTY_PATH as EMPTY_PATH, z_INVALID as INVALID, z_NEVER as NEVER, z_OK as OK, z_ParseStatus as ParseStatus, ZodType as Schema, z_ZodAny as ZodAny, z_ZodArray as ZodArray, z_ZodBigInt as ZodBigInt, z_ZodBoolean as ZodBoolean, z_ZodBranded as ZodBranded, z_ZodCatch as ZodCatch, z_ZodDate as ZodDate, z_ZodDefault as ZodDefault, z_ZodDiscriminatedUnion as ZodDiscriminatedUnion, z_ZodEffects as ZodEffects, z_ZodEnum as ZodEnum, z_ZodError as ZodError, z_ZodFirstPartyTypeKind as ZodFirstPartyTypeKind, z_ZodFunction as ZodFunction, z_ZodIntersection as ZodIntersection, z_ZodLazy as ZodLazy, z_ZodLiteral as ZodLiteral, z_ZodMap as ZodMap, z_ZodNaN as ZodNaN, z_ZodNativeEnum as ZodNativeEnum, z_ZodNever as ZodNever, z_ZodNull as ZodNull, z_ZodNullable as ZodNullable, z_ZodNumber as ZodNumber, z_ZodObject as ZodObject, z_ZodOptional as ZodOptional, z_ZodPipeline as ZodPipeline, z_ZodPromise as ZodPromise, z_ZodReadonly as ZodReadonly, z_ZodRecord as ZodRecord, ZodType as ZodSchema, z_ZodSet as ZodSet, z_ZodString as ZodString, z_ZodSymbol as ZodSymbol, ZodEffects as ZodTransformer, z_ZodTuple as ZodTuple, z_ZodType as ZodType, z_ZodUndefined as ZodUndefined, z_ZodUnion as ZodUnion, z_ZodUnknown as ZodUnknown, z_ZodVoid as ZodVoid, z_addIssueToContext as addIssueToContext, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, z_coerce as coerce, z_custom as custom, dateType as date, z_datetimeRegex as datetimeRegex, errorMap as defaultErrorMap, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, z_getErrorMap as getErrorMap, z_getParsedType as getParsedType, instanceOfType as instanceof, intersectionType as intersection, z_isAborted as isAborted, z_isAsync as isAsync, z_isDirty as isDirty, z_isValid as isValid, z_late as late, lazyType as lazy, literalType as literal, z_makeIssue as makeIssue, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, z_objectUtil as objectUtil, z_oboolean as oboolean, z_onumber as onumber, optionalType as optional, z_ostring as ostring, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, z_quotelessJson as quotelessJson, recordType as record, setType as set, z_setErrorMap as setErrorMap, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, z_util as util, voidType as void };
-  export type { z_AnyZodObject as AnyZodObject, z_AnyZodTuple as AnyZodTuple, z_ArrayCardinality as ArrayCardinality, z_ArrayKeys as ArrayKeys, z_AssertArray as AssertArray, z_AsyncParseReturnType as AsyncParseReturnType, z_BRAND as BRAND, z_CatchallInput as CatchallInput, z_CatchallOutput as CatchallOutput, z_CustomErrorParams as CustomErrorParams, z_DenormalizedError as DenormalizedError, z_Effect as Effect, z_EnumLike as EnumLike, z_EnumValues as EnumValues, z_ErrorMapCtx as ErrorMapCtx, z_FilterEnum as FilterEnum, z_Indices as Indices, z_InnerTypeOfFunction as InnerTypeOfFunction, z_InputTypeOfTuple as InputTypeOfTuple, z_InputTypeOfTupleWithRest as InputTypeOfTupleWithRest, z_IpVersion as IpVersion, z_IssueData as IssueData, z_KeySchema as KeySchema, z_ObjectPair as ObjectPair, z_OuterTypeOfFunction as OuterTypeOfFunction, z_OutputTypeOfTuple as OutputTypeOfTuple, z_OutputTypeOfTupleWithRest as OutputTypeOfTupleWithRest, z_ParseContext as ParseContext, z_ParseInput as ParseInput, z_ParseParams as ParseParams, z_ParsePath as ParsePath, z_ParsePathComponent as ParsePathComponent, z_ParseResult as ParseResult, z_ParseReturnType as ParseReturnType, z_PassthroughType as PassthroughType, z_PreprocessEffect as PreprocessEffect, z_Primitive as Primitive, z_ProcessedCreateParams as ProcessedCreateParams, z_RawCreateParams as RawCreateParams, z_RecordType as RecordType, z_Refinement as Refinement, z_RefinementCtx as RefinementCtx, z_RefinementEffect as RefinementEffect, z_SafeParseError as SafeParseError, z_SafeParseReturnType as SafeParseReturnType, z_SafeParseSuccess as SafeParseSuccess, z_Scalars as Scalars, z_SomeZodObject as SomeZodObject, z_StringValidation as StringValidation, z_SuperRefinement as SuperRefinement, z_SyncParseReturnType as SyncParseReturnType, z_TransformEffect as TransformEffect, z_TypeOf as TypeOf, z_UnknownKeysParam as UnknownKeysParam, z_Values as Values, z_Writeable as Writeable, z_ZodAnyDef as ZodAnyDef, z_ZodArrayDef as ZodArrayDef, z_ZodBigIntCheck as ZodBigIntCheck, z_ZodBigIntDef as ZodBigIntDef, z_ZodBooleanDef as ZodBooleanDef, z_ZodBrandedDef as ZodBrandedDef, z_ZodCatchDef as ZodCatchDef, z_ZodCustomIssue as ZodCustomIssue, z_ZodDateCheck as ZodDateCheck, z_ZodDateDef as ZodDateDef, z_ZodDefaultDef as ZodDefaultDef, z_ZodDiscriminatedUnionDef as ZodDiscriminatedUnionDef, z_ZodDiscriminatedUnionOption as ZodDiscriminatedUnionOption, z_ZodEffectsDef as ZodEffectsDef, z_ZodEnumDef as ZodEnumDef, z_ZodErrorMap as ZodErrorMap, z_ZodFirstPartySchemaTypes as ZodFirstPartySchemaTypes, z_ZodFormattedError as ZodFormattedError, z_ZodFunctionDef as ZodFunctionDef, z_ZodIntersectionDef as ZodIntersectionDef, z_ZodInvalidArgumentsIssue as ZodInvalidArgumentsIssue, z_ZodInvalidDateIssue as ZodInvalidDateIssue, z_ZodInvalidEnumValueIssue as ZodInvalidEnumValueIssue, z_ZodInvalidIntersectionTypesIssue as ZodInvalidIntersectionTypesIssue, z_ZodInvalidLiteralIssue as ZodInvalidLiteralIssue, z_ZodInvalidReturnTypeIssue as ZodInvalidReturnTypeIssue, z_ZodInvalidStringIssue as ZodInvalidStringIssue, z_ZodInvalidTypeIssue as ZodInvalidTypeIssue, z_ZodInvalidUnionDiscriminatorIssue as ZodInvalidUnionDiscriminatorIssue, z_ZodInvalidUnionIssue as ZodInvalidUnionIssue, z_ZodIssue as ZodIssue, z_ZodIssueBase as ZodIssueBase, z_ZodIssueCode as ZodIssueCode, z_ZodIssueOptionalMessage as ZodIssueOptionalMessage, z_ZodLazyDef as ZodLazyDef, z_ZodLiteralDef as ZodLiteralDef, z_ZodMapDef as ZodMapDef, z_ZodNaNDef as ZodNaNDef, z_ZodNativeEnumDef as ZodNativeEnumDef, z_ZodNeverDef as ZodNeverDef, z_ZodNonEmptyArray as ZodNonEmptyArray, z_ZodNotFiniteIssue as ZodNotFiniteIssue, z_ZodNotMultipleOfIssue as ZodNotMultipleOfIssue, z_ZodNullDef as ZodNullDef, z_ZodNullableDef as ZodNullableDef, z_ZodNullableType as ZodNullableType, z_ZodNumberCheck as ZodNumberCheck, z_ZodNumberDef as ZodNumberDef, z_ZodObjectDef as ZodObjectDef, z_ZodOptionalDef as ZodOptionalDef, z_ZodOptionalType as ZodOptionalType, z_ZodParsedType as ZodParsedType, z_ZodPipelineDef as ZodPipelineDef, z_ZodPromiseDef as ZodPromiseDef, z_ZodRawShape as ZodRawShape, z_ZodReadonlyDef as ZodReadonlyDef, z_ZodRecordDef as ZodRecordDef, z_ZodSetDef as ZodSetDef, z_ZodStringCheck as ZodStringCheck, z_ZodStringDef as ZodStringDef, z_ZodSymbolDef as ZodSymbolDef, z_ZodTooBigIssue as ZodTooBigIssue, z_ZodTooSmallIssue as ZodTooSmallIssue, z_ZodTupleDef as ZodTupleDef, z_ZodTupleItems as ZodTupleItems, z_ZodTypeAny as ZodTypeAny, z_ZodTypeDef as ZodTypeDef, z_ZodUndefinedDef as ZodUndefinedDef, z_ZodUnionDef as ZodUnionDef, z_ZodUnionOptions as ZodUnionOptions, z_ZodUnknownDef as ZodUnknownDef, z_ZodUnrecognizedKeysIssue as ZodUnrecognizedKeysIssue, z_ZodVoidDef as ZodVoidDef, z_arrayOutputType as arrayOutputType, z_baseObjectInputType as baseObjectInputType, z_baseObjectOutputType as baseObjectOutputType, z_deoptional as deoptional, TypeOf as infer, z_inferFlattenedErrors as inferFlattenedErrors, z_inferFormattedError as inferFormattedError, z_input as input, z_mergeTypes as mergeTypes, z_noUnrecognized as noUnrecognized, z_objectInputType as objectInputType, z_objectOutputType as objectOutputType, z_output as output, z_typeToFlattenedError as typeToFlattenedError, z_typecast as typecast };
-}
-
-export { BRAND, DIRTY, EMPTY_PATH, INVALID, NEVER, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodBranded, ZodCatch, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodError, ZodFirstPartyTypeKind, ZodFunction, ZodIntersection, ZodIssueCode, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodParsedType, ZodPipeline, ZodPromise, ZodReadonly, ZodRecord, ZodType as ZodSchema, ZodSet, ZodString, ZodSymbol, ZodEffects as ZodTransformer, ZodTuple, ZodType, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, addIssueToContext, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, coerce, custom, dateType as date, datetimeRegex, errorMap as defaultErrorMap, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getErrorMap, getParsedType, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, pipelineType as pipeline, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, symbolType as symbol, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, util, voidType as void, z };
-export type { AnyZodObject, AnyZodTuple, ArrayCardinality, ArrayKeys, AssertArray, AsyncParseReturnType, CatchallInput, CatchallOutput, CustomErrorParams, DenormalizedError, Effect, EnumLike, EnumValues, ErrorMapCtx, FilterEnum, Indices, InnerTypeOfFunction, InputTypeOfTuple, InputTypeOfTupleWithRest, IpVersion, IssueData, KeySchema, ObjectPair, OuterTypeOfFunction, OutputTypeOfTuple, OutputTypeOfTupleWithRest, ParseContext, ParseInput, ParseParams, ParsePath, ParsePathComponent, ParseResult, ParseReturnType, PassthroughType, PreprocessEffect, Primitive, ProcessedCreateParams, RawCreateParams, RecordType, Refinement, RefinementCtx, RefinementEffect, SafeParseError, SafeParseReturnType, SafeParseSuccess, Scalars, SomeZodObject, StringValidation, SuperRefinement, SyncParseReturnType, TransformEffect, TypeOf, UnknownKeysParam, Values, Writeable, ZodAnyDef, ZodArrayDef, ZodBigIntCheck, ZodBigIntDef, ZodBooleanDef, ZodBrandedDef, ZodCatchDef, ZodCustomIssue, ZodDateCheck, ZodDateDef, ZodDefaultDef, ZodDiscriminatedUnionDef, ZodDiscriminatedUnionOption, ZodEffectsDef, ZodEnumDef, ZodErrorMap, ZodFirstPartySchemaTypes, ZodFormattedError, ZodFunctionDef, ZodIntersectionDef, ZodInvalidArgumentsIssue, ZodInvalidDateIssue, ZodInvalidEnumValueIssue, ZodInvalidIntersectionTypesIssue, ZodInvalidLiteralIssue, ZodInvalidReturnTypeIssue, ZodInvalidStringIssue, ZodInvalidTypeIssue, ZodInvalidUnionDiscriminatorIssue, ZodInvalidUnionIssue, ZodIssue, ZodIssueBase, ZodIssueOptionalMessage, ZodLazyDef, ZodLiteralDef, ZodMapDef, ZodNaNDef, ZodNativeEnumDef, ZodNeverDef, ZodNonEmptyArray, ZodNotFiniteIssue, ZodNotMultipleOfIssue, ZodNullDef, ZodNullableDef, ZodNullableType, ZodNumberCheck, ZodNumberDef, ZodObjectDef, ZodOptionalDef, ZodOptionalType, ZodPipelineDef, ZodPromiseDef, ZodRawShape, ZodReadonlyDef, ZodRecordDef, ZodSetDef, ZodStringCheck, ZodStringDef, ZodSymbolDef, ZodTooBigIssue, ZodTooSmallIssue, ZodTupleDef, ZodTupleItems, ZodTypeAny, ZodTypeDef, ZodUndefinedDef, ZodUnionDef, ZodUnionOptions, ZodUnknownDef, ZodUnrecognizedKeysIssue, ZodVoidDef, arrayOutputType, baseObjectInputType, baseObjectOutputType, deoptional, TypeOf as infer, inferFlattenedErrors, inferFormattedError, input, mergeTypes, noUnrecognized, objectInputType, objectOutputType, output, typeToFlattenedError, typecast };
+export * from "./lib";
+export as namespace Zod;