@nullix/zod-mongoose-studio 3.3.1 → 3.3.2

package/.output/server/chunks/routes/api/editor-types.get.mjs

@@ -1,7 +1,4 @@
-import process from 'node:process';globalThis._importMeta_=globalThis._importMeta_||{url:"file:///_entry.js",env:process.env};import { d as defineEventHandler, s as setHeader } from '../../nitro/nitro.mjs';
-import { readdir, readFile } from 'node:fs/promises';
-import { join, relative, dirname } from 'node:path';
-import { createRequire } from 'node:module';
+import { d as defineEventHandler, s as setHeader } from '../../nitro/nitro.mjs';
 import 'node:http';
 import 'node:vm';
 import 'esbuild';
@@ -13,31 +10,103 @@ import 'node:https';
 import 'node:events';
 import 'node:buffer';
 import 'node:fs';
+import 'node:path';
 import 'node:crypto';
 import 'node:url';
 import '@iconify/utils';
 import 'consola';
 
-const require$1 = createRequire(globalThis._importMeta_.url);
-const zodRoot = dirname(dirname(require$1.resolve("zod/v4")));
-let cachedTypes;
-async function collect(directory, files) {
-  for (const entry of await readdir(directory, { withFileTypes: true })) {
-    const path = join(directory, entry.name);
-    if (entry.isDirectory()) await collect(path, files);
-    else if (entry.name.endsWith(".d.ts")) {
-      files[`file:///node_modules/zod/${relative(zodRoot, path).replaceAll("\\", "/")}`] = await readFile(path, "utf8");
-    }
-  }
-}
+const editorTypes = {
+	"file:///node_modules/zod/v4/classic/checks.d.ts": "export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from \"../core/index.js\";\n",
+	"file:///node_modules/zod/v4/classic/coerce.d.ts": "import * as core from \"../core/index.js\";\nimport * as schemas from \"./schemas.js\";\nexport interface ZodCoercedString<T = unknown> extends schemas._ZodString<core.$ZodStringInternals<T>> {\n}\nexport declare function string<T = unknown>(params?: string | core.$ZodStringParams): ZodCoercedString<T>;\nexport interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {\n}\nexport declare function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T>;\nexport interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {\n}\nexport declare function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T>;\nexport interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {\n}\nexport declare function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T>;\nexport interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {\n}\nexport declare function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T>;\n",
+	"file:///node_modules/zod/v4/classic/compat.d.ts": "import * as core from \"../core/index.js\";\nimport type { ZodType } from \"./schemas.js\";\nexport type { \n/** @deprecated Use `z.output<T>` instead. */\noutput as TypeOf, \n/** @deprecated Use `z.output<T>` instead. */\noutput as Infer, \n/** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */\n$ZodTypes as ZodFirstPartySchemaTypes, } from \"../core/index.js\";\n/** @deprecated Use the raw string literal codes instead, e.g. \"invalid_type\". */\nexport declare const ZodIssueCode: {\n    readonly invalid_type: \"invalid_type\";\n    readonly too_big: \"too_big\";\n    readonly too_small: \"too_small\";\n    readonly invalid_format: \"invalid_format\";\n    readonly not_multiple_of: \"not_multiple_of\";\n    readonly unrecognized_keys: \"unrecognized_keys\";\n    readonly invalid_union: \"invalid_union\";\n    readonly invalid_key: \"invalid_key\";\n    readonly invalid_element: \"invalid_element\";\n    readonly invalid_value: \"invalid_value\";\n    readonly custom: \"custom\";\n};\n/** @deprecated Use `z.$ZodFlattenedError` */\nexport type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;\n/** @deprecated Use `z.$ZodFormattedError` */\nexport type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<core.output<T>, U>;\n/** Use `z.$brand` instead */\nexport type BRAND<T extends string | number | symbol = string | number | symbol> = {\n    [core.$brand]: {\n        [k in T]: true;\n    };\n};\nexport { $brand, config } from \"../core/index.js\";\n/** @deprecated Use `z.config(params)` instead. */\nexport declare function setErrorMap(map: core.$ZodErrorMap): void;\n/** @deprecated Use `z.config()` instead. */\nexport declare function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined;\nexport type { \n/** @deprecated Use z.ZodType (without generics) instead. */\nZodType as ZodTypeAny, \n/** @deprecated Use `z.ZodType` */\nZodType as ZodSchema, \n/** @deprecated Use `z.ZodType` */\nZodType as Schema, };\n/** Included for Zod 3 compatibility */\nexport type ZodRawShape = core.$ZodShape;\n/** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */\nexport declare enum ZodFirstPartyTypeKind {\n}\n",
+	"file:///node_modules/zod/v4/classic/errors.d.ts": "import * as core from \"../core/index.js\";\nimport { $ZodError } from \"../core/index.js\";\n/** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */\nexport type ZodIssue = core.$ZodIssue;\n/** An Error-like class used to store Zod validation issues.  */\nexport interface ZodError<T = unknown> extends $ZodError<T> {\n    /** @deprecated Use the `z.treeifyError(err)` function instead. */\n    format(): core.$ZodFormattedError<T>;\n    format<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFormattedError<T, U>;\n    /** @deprecated Use the `z.treeifyError(err)` function instead. */\n    flatten(): core.$ZodFlattenedError<T>;\n    flatten<U>(mapper: (issue: core.$ZodIssue) => U): core.$ZodFlattenedError<T, U>;\n    /** @deprecated Push directly to `.issues` instead. */\n    addIssue(issue: core.$ZodIssue): void;\n    /** @deprecated Push directly to `.issues` instead. */\n    addIssues(issues: core.$ZodIssue[]): void;\n    /** @deprecated Check `err.issues.length === 0` instead. */\n    isEmpty: boolean;\n}\nexport declare const ZodError: core.$constructor<ZodError>;\nexport declare const ZodRealError: core.$constructor<ZodError>;\nexport type { \n/** @deprecated Use `z.core.$ZodFlattenedError` instead. */\n$ZodFlattenedError as ZodFlattenedError, \n/** @deprecated Use `z.core.$ZodFormattedError` instead. */\n$ZodFormattedError as ZodFormattedError, \n/** @deprecated Use `z.core.$ZodErrorMap` instead. */\n$ZodErrorMap as ZodErrorMap, } from \"../core/index.js\";\n/** @deprecated Use `z.core.$ZodRawIssue` instead. */\nexport type IssueData = core.$ZodRawIssue;\n",
+	"file:///node_modules/zod/v4/classic/external.d.ts": "export * as core from \"../core/index.js\";\nexport * from \"./schemas.js\";\nexport * from \"./checks.js\";\nexport * from \"./errors.js\";\nexport * from \"./parse.js\";\nexport * from \"./compat.js\";\nexport type { infer, output, input } from \"../core/index.js\";\nexport { globalRegistry, type GlobalMeta, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from \"../core/index.js\";\nexport { toJSONSchema } from \"../core/json-schema-processors.js\";\nexport { fromJSONSchema } from \"./from-json-schema.js\";\nexport * as locales from \"../locales/index.js\";\nexport { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from \"./iso.js\";\nexport * as iso from \"./iso.js\";\nexport type { ZodCoercedString, ZodCoercedNumber, ZodCoercedBigInt, ZodCoercedBoolean, ZodCoercedDate, } from \"./coerce.js\";\nexport * as coerce from \"./coerce.js\";\n",
+	"file:///node_modules/zod/v4/classic/from-json-schema.d.ts": "import type * as JSONSchema from \"../core/json-schema.js\";\nimport { type $ZodRegistry } from \"../core/registries.js\";\nimport type { ZodType } from \"./schemas.js\";\ntype JSONSchemaVersion = \"draft-2020-12\" | \"draft-7\" | \"draft-4\" | \"openapi-3.0\";\ninterface FromJSONSchemaParams {\n    defaultTarget?: JSONSchemaVersion;\n    registry?: $ZodRegistry<any>;\n}\n/**\n * Converts a JSON Schema to a Zod schema. This function should be considered semi-experimental. It's behavior is liable to change. */\nexport declare function fromJSONSchema(schema: JSONSchema.JSONSchema | boolean, params?: FromJSONSchemaParams): ZodType;\nexport {};\n",
+	"file:///node_modules/zod/v4/classic/index.d.ts": "import * as z from \"./external.js\";\nexport { z };\nexport * from \"./external.js\";\nexport default z;\n",
+	"file:///node_modules/zod/v4/classic/iso.d.ts": "import * as core from \"../core/index.js\";\nimport * as schemas from \"./schemas.js\";\nexport interface ZodISODateTime extends schemas.ZodStringFormat {\n    _zod: core.$ZodISODateTimeInternals;\n}\nexport declare const ZodISODateTime: core.$constructor<ZodISODateTime>;\nexport declare function datetime(params?: string | core.$ZodISODateTimeParams): ZodISODateTime;\nexport interface ZodISODate extends schemas.ZodStringFormat {\n    _zod: core.$ZodISODateInternals;\n}\nexport declare const ZodISODate: core.$constructor<ZodISODate>;\nexport declare function date(params?: string | core.$ZodISODateParams): ZodISODate;\nexport interface ZodISOTime extends schemas.ZodStringFormat {\n    _zod: core.$ZodISOTimeInternals;\n}\nexport declare const ZodISOTime: core.$constructor<ZodISOTime>;\nexport declare function time(params?: string | core.$ZodISOTimeParams): ZodISOTime;\nexport interface ZodISODuration extends schemas.ZodStringFormat {\n    _zod: core.$ZodISODurationInternals;\n}\nexport declare const ZodISODuration: core.$constructor<ZodISODuration>;\nexport declare function duration(params?: string | core.$ZodISODurationParams): ZodISODuration;\n",
+	"file:///node_modules/zod/v4/classic/parse.d.ts": "import * as core from \"../core/index.js\";\nimport { type ZodError } from \"./errors.js\";\nexport type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;\nexport type ZodSafeParseSuccess<T> = {\n    success: true;\n    data: T;\n    error?: never;\n};\nexport type ZodSafeParseError<T> = {\n    success: false;\n    data?: never;\n    error: ZodError<T>;\n};\nexport declare const parse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {\n    callee?: core.util.AnyFunc;\n    Err?: core.$ZodErrorClass;\n}) => core.output<T>;\nexport declare const parseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>, _params?: {\n    callee?: core.util.AnyFunc;\n    Err?: core.$ZodErrorClass;\n}) => Promise<core.output<T>>;\nexport declare const safeParse: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;\nexport declare const safeParseAsync: <T extends core.$ZodType>(schema: T, value: unknown, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;\nexport declare const encode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.input<T>;\nexport declare const decode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => core.output<T>;\nexport declare const encodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.input<T>>;\nexport declare const decodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<core.output<T>>;\nexport declare const safeEncode: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.input<T>>;\nexport declare const safeDecode: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => ZodSafeParseResult<core.output<T>>;\nexport declare const safeEncodeAsync: <T extends core.$ZodType>(schema: T, value: core.output<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.input<T>>>;\nexport declare const safeDecodeAsync: <T extends core.$ZodType>(schema: T, value: core.input<T>, _ctx?: core.ParseContext<core.$ZodIssue>) => Promise<ZodSafeParseResult<core.output<T>>>;\n",
+	"file:///node_modules/zod/v4/classic/schemas.d.ts": "import * as core from \"../core/index.js\";\nimport { util } from \"../core/index.js\";\nimport type { StandardSchemaWithJSONProps } from \"../core/standard-schema.js\";\nimport * as parse from \"./parse.js\";\nexport type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;\nexport interface ZodType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {\n    def: Internals[\"def\"];\n    type: Internals[\"def\"][\"type\"];\n    /** @deprecated Use `.def` instead. */\n    _def: Internals[\"def\"];\n    /** @deprecated Use `z.output<typeof schema>` instead. */\n    _output: Internals[\"output\"];\n    /** @deprecated Use `z.input<typeof schema>` instead. */\n    _input: Internals[\"input\"];\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    /** Converts this schema to a JSON Schema representation. */\n    toJSONSchema(params?: core.ToJSONSchemaParams): core.ZodStandardJSONSchemaPayload<this>;\n    check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;\n    with(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;\n    clone(def?: Internals[\"def\"], params?: {\n        parent: boolean;\n    }): this;\n    register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R[\"_schema\"] ? undefined extends R[\"_meta\"] ? [core.$replace<R[\"_meta\"], this>?] : [core.$replace<R[\"_meta\"], this>] : [\"Incompatible schema\"]): this;\n    brand<T extends PropertyKey = PropertyKey, Dir extends \"in\" | \"out\" | \"inout\" = \"out\">(value?: T): PropertyKey extends T ? this : core.$ZodBranded<this, T, Dir>;\n    parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;\n    safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): parse.ZodSafeParseResult<core.output<this>>;\n    parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;\n    safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;\n    spa: (data: unknown, params?: core.ParseContext<core.$ZodIssue>) => Promise<parse.ZodSafeParseResult<core.output<this>>>;\n    encode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): core.input<this>;\n    decode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;\n    encodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.input<this>>;\n    decodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;\n    safeEncode(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): parse.ZodSafeParseResult<core.input<this>>;\n    safeDecode(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): parse.ZodSafeParseResult<core.output<this>>;\n    safeEncodeAsync(data: core.output<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.input<this>>>;\n    safeDecodeAsync(data: core.input<this>, params?: core.ParseContext<core.$ZodIssue>): Promise<parse.ZodSafeParseResult<core.output<this>>>;\n    refine<Ch extends (arg: core.output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | core.$ZodCustomParams): Ch extends (arg: any) => arg is infer R ? this & ZodType<R, core.input<this>> : this;\n    superRefine(refinement: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => void | Promise<void>): this;\n    overwrite(fn: (x: core.output<this>) => core.output<this>): this;\n    optional(): ZodOptional<this>;\n    exactOptional(): ZodExactOptional<this>;\n    nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;\n    nullable(): ZodNullable<this>;\n    nullish(): ZodOptional<ZodNullable<this>>;\n    default(def: util.NoUndefined<core.output<this>>): ZodDefault<this>;\n    default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;\n    prefault(def: () => core.input<this>): ZodPrefault<this>;\n    prefault(def: core.input<this>): ZodPrefault<this>;\n    array(): ZodArray<this>;\n    or<T extends core.SomeType>(option: T): ZodUnion<[this, T]>;\n    and<T extends core.SomeType>(incoming: T): ZodIntersection<this, T>;\n    transform<NewOut>(transform: (arg: core.output<this>, ctx: core.$RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;\n    catch(def: core.output<this>): ZodCatch<this>;\n    catch(def: (ctx: core.$ZodCatchCtx) => core.output<this>): ZodCatch<this>;\n    pipe<T extends core.$ZodType<any, core.output<this>>>(target: T | core.$ZodType<any, core.output<this>>): ZodPipe<this, T>;\n    readonly(): ZodReadonly<this>;\n    /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */\n    describe(description: string): this;\n    description?: string;\n    /** Returns the metadata associated with this instance in `z.globalRegistry` */\n    meta(): core.$replace<core.GlobalMeta, this> | undefined;\n    /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */\n    meta(data: core.$replace<core.GlobalMeta, this>): this;\n    /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):\n     *\n     * ```ts\n     * const schema = z.string().optional();\n     * const isOptional = schema.safeParse(undefined).success; // true\n     * ```\n     */\n    isOptional(): boolean;\n    /**\n     * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):\n     *\n     * ```ts\n     * const schema = z.string().nullable();\n     * const isNullable = schema.safeParse(null).success; // true\n     * ```\n     */\n    isNullable(): boolean;\n    apply<T>(fn: (schema: this) => T): T;\n}\nexport interface _ZodType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodType<any, any, Internals> {\n}\nexport declare const ZodType: core.$constructor<ZodType>;\nexport interface _ZodString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>> extends _ZodType<T> {\n    format: string | null;\n    minLength: number | null;\n    maxLength: number | null;\n    regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this;\n    includes(value: string, params?: string | core.$ZodCheckIncludesParams): this;\n    startsWith(value: string, params?: string | core.$ZodCheckStartsWithParams): this;\n    endsWith(value: string, params?: string | core.$ZodCheckEndsWithParams): this;\n    min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;\n    max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;\n    length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;\n    nonempty(params?: string | core.$ZodCheckMinLengthParams): this;\n    lowercase(params?: string | core.$ZodCheckLowerCaseParams): this;\n    uppercase(params?: string | core.$ZodCheckUpperCaseParams): this;\n    trim(): this;\n    normalize(form?: \"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\" | (string & {})): this;\n    toLowerCase(): this;\n    toUpperCase(): this;\n    slugify(): this;\n}\n/** @internal */\nexport declare const _ZodString: core.$constructor<_ZodString>;\nexport interface ZodString extends _ZodString<core.$ZodStringInternals<string>> {\n    /** @deprecated Use `z.email()` instead. */\n    email(params?: string | core.$ZodCheckEmailParams): this;\n    /** @deprecated Use `z.url()` instead. */\n    url(params?: string | core.$ZodCheckURLParams): this;\n    /** @deprecated Use `z.jwt()` instead. */\n    jwt(params?: string | core.$ZodCheckJWTParams): this;\n    /** @deprecated Use `z.emoji()` instead. */\n    emoji(params?: string | core.$ZodCheckEmojiParams): this;\n    /** @deprecated Use `z.guid()` instead. */\n    guid(params?: string | core.$ZodCheckGUIDParams): this;\n    /** @deprecated Use `z.uuid()` instead. */\n    uuid(params?: string | core.$ZodCheckUUIDParams): this;\n    /** @deprecated Use `z.uuid()` instead. */\n    uuidv4(params?: string | core.$ZodCheckUUIDParams): this;\n    /** @deprecated Use `z.uuid()` instead. */\n    uuidv6(params?: string | core.$ZodCheckUUIDParams): this;\n    /** @deprecated Use `z.uuid()` instead. */\n    uuidv7(params?: string | core.$ZodCheckUUIDParams): this;\n    /** @deprecated Use `z.nanoid()` instead. */\n    nanoid(params?: string | core.$ZodCheckNanoIDParams): this;\n    /** @deprecated Use `z.guid()` instead. */\n    guid(params?: string | core.$ZodCheckGUIDParams): this;\n    /** @deprecated Use `z.cuid()` instead. */\n    cuid(params?: string | core.$ZodCheckCUIDParams): this;\n    /** @deprecated Use `z.cuid2()` instead. */\n    cuid2(params?: string | core.$ZodCheckCUID2Params): this;\n    /** @deprecated Use `z.ulid()` instead. */\n    ulid(params?: string | core.$ZodCheckULIDParams): this;\n    /** @deprecated Use `z.base64()` instead. */\n    base64(params?: string | core.$ZodCheckBase64Params): this;\n    /** @deprecated Use `z.base64url()` instead. */\n    base64url(params?: string | core.$ZodCheckBase64URLParams): this;\n    /** @deprecated Use `z.xid()` instead. */\n    xid(params?: string | core.$ZodCheckXIDParams): this;\n    /** @deprecated Use `z.ksuid()` instead. */\n    ksuid(params?: string | core.$ZodCheckKSUIDParams): this;\n    /** @deprecated Use `z.ipv4()` instead. */\n    ipv4(params?: string | core.$ZodCheckIPv4Params): this;\n    /** @deprecated Use `z.ipv6()` instead. */\n    ipv6(params?: string | core.$ZodCheckIPv6Params): this;\n    /** @deprecated Use `z.cidrv4()` instead. */\n    cidrv4(params?: string | core.$ZodCheckCIDRv4Params): this;\n    /** @deprecated Use `z.cidrv6()` instead. */\n    cidrv6(params?: string | core.$ZodCheckCIDRv6Params): this;\n    /** @deprecated Use `z.e164()` instead. */\n    e164(params?: string | core.$ZodCheckE164Params): this;\n    /** @deprecated Use `z.iso.datetime()` instead. */\n    datetime(params?: string | core.$ZodCheckISODateTimeParams): this;\n    /** @deprecated Use `z.iso.date()` instead. */\n    date(params?: string | core.$ZodCheckISODateParams): this;\n    /** @deprecated Use `z.iso.time()` instead. */\n    time(params?: string | core.$ZodCheckISOTimeParams): this;\n    /** @deprecated Use `z.iso.duration()` instead. */\n    duration(params?: string | core.$ZodCheckISODurationParams): this;\n}\nexport declare const ZodString: core.$constructor<ZodString>;\nexport declare function string(params?: string | core.$ZodStringParams): ZodString;\nexport declare function string<T extends string>(params?: string | core.$ZodStringParams): core.$ZodType<T, T>;\nexport interface ZodStringFormat<Format extends string = string> extends _ZodString<core.$ZodStringFormatInternals<Format>> {\n}\nexport declare const ZodStringFormat: core.$constructor<ZodStringFormat>;\nexport interface ZodEmail extends ZodStringFormat<\"email\"> {\n    _zod: core.$ZodEmailInternals;\n}\nexport declare const ZodEmail: core.$constructor<ZodEmail>;\nexport declare function email(params?: string | core.$ZodEmailParams): ZodEmail;\nexport interface ZodGUID extends ZodStringFormat<\"guid\"> {\n    _zod: core.$ZodGUIDInternals;\n}\nexport declare const ZodGUID: core.$constructor<ZodGUID>;\nexport declare function guid(params?: string | core.$ZodGUIDParams): ZodGUID;\nexport interface ZodUUID extends ZodStringFormat<\"uuid\"> {\n    _zod: core.$ZodUUIDInternals;\n}\nexport declare const ZodUUID: core.$constructor<ZodUUID>;\nexport declare function uuid(params?: string | core.$ZodUUIDParams): ZodUUID;\nexport declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodUUID;\nexport declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodUUID;\nexport declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodUUID;\nexport interface ZodURL extends ZodStringFormat<\"url\"> {\n    _zod: core.$ZodURLInternals;\n}\nexport declare const ZodURL: core.$constructor<ZodURL>;\nexport declare function url(params?: string | core.$ZodURLParams): ZodURL;\nexport declare function httpUrl(params?: string | Omit<core.$ZodURLParams, \"protocol\" | \"hostname\">): ZodURL;\nexport interface ZodEmoji extends ZodStringFormat<\"emoji\"> {\n    _zod: core.$ZodEmojiInternals;\n}\nexport declare const ZodEmoji: core.$constructor<ZodEmoji>;\nexport declare function emoji(params?: string | core.$ZodEmojiParams): ZodEmoji;\nexport interface ZodNanoID extends ZodStringFormat<\"nanoid\"> {\n    _zod: core.$ZodNanoIDInternals;\n}\nexport declare const ZodNanoID: core.$constructor<ZodNanoID>;\nexport declare function nanoid(params?: string | core.$ZodNanoIDParams): ZodNanoID;\nexport interface ZodCUID extends ZodStringFormat<\"cuid\"> {\n    _zod: core.$ZodCUIDInternals;\n}\nexport declare const ZodCUID: core.$constructor<ZodCUID>;\nexport declare function cuid(params?: string | core.$ZodCUIDParams): ZodCUID;\nexport interface ZodCUID2 extends ZodStringFormat<\"cuid2\"> {\n    _zod: core.$ZodCUID2Internals;\n}\nexport declare const ZodCUID2: core.$constructor<ZodCUID2>;\nexport declare function cuid2(params?: string | core.$ZodCUID2Params): ZodCUID2;\nexport interface ZodULID extends ZodStringFormat<\"ulid\"> {\n    _zod: core.$ZodULIDInternals;\n}\nexport declare const ZodULID: core.$constructor<ZodULID>;\nexport declare function ulid(params?: string | core.$ZodULIDParams): ZodULID;\nexport interface ZodXID extends ZodStringFormat<\"xid\"> {\n    _zod: core.$ZodXIDInternals;\n}\nexport declare const ZodXID: core.$constructor<ZodXID>;\nexport declare function xid(params?: string | core.$ZodXIDParams): ZodXID;\nexport interface ZodKSUID extends ZodStringFormat<\"ksuid\"> {\n    _zod: core.$ZodKSUIDInternals;\n}\nexport declare const ZodKSUID: core.$constructor<ZodKSUID>;\nexport declare function ksuid(params?: string | core.$ZodKSUIDParams): ZodKSUID;\nexport interface ZodIPv4 extends ZodStringFormat<\"ipv4\"> {\n    _zod: core.$ZodIPv4Internals;\n}\nexport declare const ZodIPv4: core.$constructor<ZodIPv4>;\nexport declare function ipv4(params?: string | core.$ZodIPv4Params): ZodIPv4;\nexport interface ZodMAC extends ZodStringFormat<\"mac\"> {\n    _zod: core.$ZodMACInternals;\n}\nexport declare const ZodMAC: core.$constructor<ZodMAC>;\nexport declare function mac(params?: string | core.$ZodMACParams): ZodMAC;\nexport interface ZodIPv6 extends ZodStringFormat<\"ipv6\"> {\n    _zod: core.$ZodIPv6Internals;\n}\nexport declare const ZodIPv6: core.$constructor<ZodIPv6>;\nexport declare function ipv6(params?: string | core.$ZodIPv6Params): ZodIPv6;\nexport interface ZodCIDRv4 extends ZodStringFormat<\"cidrv4\"> {\n    _zod: core.$ZodCIDRv4Internals;\n}\nexport declare const ZodCIDRv4: core.$constructor<ZodCIDRv4>;\nexport declare function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodCIDRv4;\nexport interface ZodCIDRv6 extends ZodStringFormat<\"cidrv6\"> {\n    _zod: core.$ZodCIDRv6Internals;\n}\nexport declare const ZodCIDRv6: core.$constructor<ZodCIDRv6>;\nexport declare function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodCIDRv6;\nexport interface ZodBase64 extends ZodStringFormat<\"base64\"> {\n    _zod: core.$ZodBase64Internals;\n}\nexport declare const ZodBase64: core.$constructor<ZodBase64>;\nexport declare function base64(params?: string | core.$ZodBase64Params): ZodBase64;\nexport interface ZodBase64URL extends ZodStringFormat<\"base64url\"> {\n    _zod: core.$ZodBase64URLInternals;\n}\nexport declare const ZodBase64URL: core.$constructor<ZodBase64URL>;\nexport declare function base64url(params?: string | core.$ZodBase64URLParams): ZodBase64URL;\nexport interface ZodE164 extends ZodStringFormat<\"e164\"> {\n    _zod: core.$ZodE164Internals;\n}\nexport declare const ZodE164: core.$constructor<ZodE164>;\nexport declare function e164(params?: string | core.$ZodE164Params): ZodE164;\nexport interface ZodJWT extends ZodStringFormat<\"jwt\"> {\n    _zod: core.$ZodJWTInternals;\n}\nexport declare const ZodJWT: core.$constructor<ZodJWT>;\nexport declare function jwt(params?: string | core.$ZodJWTParams): ZodJWT;\nexport interface ZodCustomStringFormat<Format extends string = string> extends ZodStringFormat<Format>, core.$ZodCustomStringFormat<Format> {\n    _zod: core.$ZodCustomStringFormatInternals<Format>;\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n}\nexport declare const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat>;\nexport declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<Format>;\nexport declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<\"hostname\">;\nexport declare function hex(_params?: string | core.$ZodStringFormatParams): ZodCustomStringFormat<\"hex\">;\nexport declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = \"hex\">(alg: Alg, params?: {\n    enc?: Enc;\n} & core.$ZodStringFormatParams): ZodCustomStringFormat<`${Alg}_${Enc}`>;\nexport interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals> extends _ZodType<Internals> {\n    gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;\n    /** Identical to .min() */\n    gte(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;\n    min(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;\n    lt(value: number, params?: string | core.$ZodCheckLessThanParams): this;\n    /** Identical to .max() */\n    lte(value: number, params?: string | core.$ZodCheckLessThanParams): this;\n    max(value: number, params?: string | core.$ZodCheckLessThanParams): this;\n    /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */\n    int(params?: string | core.$ZodCheckNumberFormatParams): this;\n    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */\n    safe(params?: string | core.$ZodCheckNumberFormatParams): this;\n    positive(params?: string | core.$ZodCheckGreaterThanParams): this;\n    nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;\n    negative(params?: string | core.$ZodCheckLessThanParams): this;\n    nonpositive(params?: string | core.$ZodCheckLessThanParams): this;\n    multipleOf(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;\n    /** @deprecated Use `.multipleOf()` instead. */\n    step(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;\n    /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */\n    finite(params?: unknown): this;\n    minValue: number | null;\n    maxValue: number | null;\n    /** @deprecated Check the `format` property instead.  */\n    isInt: boolean;\n    /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */\n    isFinite: boolean;\n    format: string | null;\n}\nexport interface ZodNumber extends _ZodNumber<core.$ZodNumberInternals<number>> {\n}\nexport declare const ZodNumber: core.$constructor<ZodNumber>;\nexport declare function number(params?: string | core.$ZodNumberParams): ZodNumber;\nexport interface ZodNumberFormat extends ZodNumber {\n    _zod: core.$ZodNumberFormatInternals;\n}\nexport declare const ZodNumberFormat: core.$constructor<ZodNumberFormat>;\nexport interface ZodInt extends ZodNumberFormat {\n}\nexport declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodInt;\nexport interface ZodFloat32 extends ZodNumberFormat {\n}\nexport declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat32;\nexport interface ZodFloat64 extends ZodNumberFormat {\n}\nexport declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodFloat64;\nexport interface ZodInt32 extends ZodNumberFormat {\n}\nexport declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodInt32;\nexport interface ZodUInt32 extends ZodNumberFormat {\n}\nexport declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodUInt32;\nexport interface _ZodBoolean<T extends core.$ZodBooleanInternals = core.$ZodBooleanInternals> extends _ZodType<T> {\n}\nexport interface ZodBoolean extends _ZodBoolean<core.$ZodBooleanInternals<boolean>> {\n}\nexport declare const ZodBoolean: core.$constructor<ZodBoolean>;\nexport declare function boolean(params?: string | core.$ZodBooleanParams): ZodBoolean;\nexport interface _ZodBigInt<T extends core.$ZodBigIntInternals = core.$ZodBigIntInternals> extends _ZodType<T> {\n    gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;\n    /** Alias of `.gte()` */\n    min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;\n    gt(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;\n    /** Alias of `.lte()` */\n    lte(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;\n    max(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;\n    lt(value: bigint, params?: string | core.$ZodCheckLessThanParams): this;\n    positive(params?: string | core.$ZodCheckGreaterThanParams): this;\n    negative(params?: string | core.$ZodCheckLessThanParams): this;\n    nonpositive(params?: string | core.$ZodCheckLessThanParams): this;\n    nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;\n    multipleOf(value: bigint, params?: string | core.$ZodCheckMultipleOfParams): this;\n    minValue: bigint | null;\n    maxValue: bigint | null;\n    format: string | null;\n}\nexport interface ZodBigInt extends _ZodBigInt<core.$ZodBigIntInternals<bigint>> {\n}\nexport declare const ZodBigInt: core.$constructor<ZodBigInt>;\nexport declare function bigint(params?: string | core.$ZodBigIntParams): ZodBigInt;\nexport interface ZodBigIntFormat extends ZodBigInt {\n    _zod: core.$ZodBigIntFormatInternals;\n}\nexport declare const ZodBigIntFormat: core.$constructor<ZodBigIntFormat>;\nexport declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;\nexport declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodBigIntFormat;\nexport interface ZodSymbol extends _ZodType<core.$ZodSymbolInternals> {\n}\nexport declare const ZodSymbol: core.$constructor<ZodSymbol>;\nexport declare function symbol(params?: string | core.$ZodSymbolParams): ZodSymbol;\nexport interface ZodUndefined extends _ZodType<core.$ZodUndefinedInternals> {\n}\nexport declare const ZodUndefined: core.$constructor<ZodUndefined>;\ndeclare function _undefined(params?: string | core.$ZodUndefinedParams): ZodUndefined;\nexport { _undefined as undefined };\nexport interface ZodNull extends _ZodType<core.$ZodNullInternals> {\n}\nexport declare const ZodNull: core.$constructor<ZodNull>;\ndeclare function _null(params?: string | core.$ZodNullParams): ZodNull;\nexport { _null as null };\nexport interface ZodAny extends _ZodType<core.$ZodAnyInternals> {\n}\nexport declare const ZodAny: core.$constructor<ZodAny>;\nexport declare function any(): ZodAny;\nexport interface ZodUnknown extends _ZodType<core.$ZodUnknownInternals> {\n}\nexport declare const ZodUnknown: core.$constructor<ZodUnknown>;\nexport declare function unknown(): ZodUnknown;\nexport interface ZodNever extends _ZodType<core.$ZodNeverInternals> {\n}\nexport declare const ZodNever: core.$constructor<ZodNever>;\nexport declare function never(params?: string | core.$ZodNeverParams): ZodNever;\nexport interface ZodVoid extends _ZodType<core.$ZodVoidInternals> {\n}\nexport declare const ZodVoid: core.$constructor<ZodVoid>;\ndeclare function _void(params?: string | core.$ZodVoidParams): ZodVoid;\nexport { _void as void };\nexport interface _ZodDate<T extends core.$ZodDateInternals = core.$ZodDateInternals> extends _ZodType<T> {\n    min(value: number | Date, params?: string | core.$ZodCheckGreaterThanParams): this;\n    max(value: number | Date, params?: string | core.$ZodCheckLessThanParams): this;\n    /** @deprecated Not recommended. */\n    minDate: Date | null;\n    /** @deprecated Not recommended. */\n    maxDate: Date | null;\n}\nexport interface ZodDate extends _ZodDate<core.$ZodDateInternals<Date>> {\n}\nexport declare const ZodDate: core.$constructor<ZodDate>;\nexport declare function date(params?: string | core.$ZodDateParams): ZodDate;\nexport interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodArrayInternals<T>>, core.$ZodArray<T> {\n    element: T;\n    min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;\n    nonempty(params?: string | core.$ZodCheckMinLengthParams): this;\n    max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;\n    length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;\n    unwrap(): T;\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n}\nexport declare const ZodArray: core.$constructor<ZodArray>;\nexport declare function array<T extends core.SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;\nexport declare function keyof<T extends ZodObject>(schema: T): ZodEnum<util.KeysEnum<T[\"_zod\"][\"output\"]>>;\nexport type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShape> = {\n    [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];\n};\nexport interface ZodObject<\n/** @ts-ignore Cast variance */\nout Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$strip> extends _ZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    shape: Shape;\n    keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;\n    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */\n    catchall<T extends core.SomeType>(schema: T): ZodObject<Shape, core.$catchall<T>>;\n    /** @deprecated Use `z.looseObject()` or `.loose()` instead. */\n    passthrough(): ZodObject<Shape, core.$loose>;\n    /** Consider `z.looseObject(A.shape)` instead */\n    loose(): ZodObject<Shape, core.$loose>;\n    /** Consider `z.strictObject(A.shape)` instead */\n    strict(): ZodObject<Shape, core.$strict>;\n    /** This is the default behavior. This method call is likely unnecessary. */\n    strip(): ZodObject<Shape, core.$strip>;\n    extend<U extends core.$ZodLooseShape>(shape: U): ZodObject<util.Extend<Shape, U>, Config>;\n    safeExtend<U extends core.$ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, core.SomeType>>): ZodObject<util.Extend<Shape, U>, Config>;\n    /**\n     * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.\n     */\n    merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U[\"shape\"]>, U[\"_zod\"][\"config\"]>;\n    pick<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;\n    omit<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;\n    partial(): ZodObject<{\n        [k in keyof Shape]: ZodOptional<Shape[k]>;\n    }, Config>;\n    partial<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{\n        [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k];\n    }, Config>;\n    required(): ZodObject<{\n        [k in keyof Shape]: ZodNonOptional<Shape[k]>;\n    }, Config>;\n    required<M extends util.Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{\n        [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k];\n    }, Config>;\n}\nexport declare const ZodObject: core.$constructor<ZodObject>;\nexport declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<util.Writeable<T>, core.$strip>;\nexport declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$strict>;\nexport declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$loose>;\nexport interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$ZodType[]> extends _ZodType<core.$ZodUnionInternals<T>>, core.$ZodUnion<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    options: T;\n}\nexport declare const ZodUnion: core.$constructor<ZodUnion>;\nexport declare function union<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodUnion<T>;\nexport interface ZodXor<T extends readonly core.SomeType[] = readonly core.$ZodType[]> extends _ZodType<core.$ZodXorInternals<T>>, core.$ZodXor<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    options: T;\n}\nexport declare const ZodXor: core.$constructor<ZodXor>;\n/** Creates an exclusive union (XOR) where exactly one option must match.\n * Unlike regular unions that succeed when any option matches, xor fails if\n * zero or more than one option matches the input. */\nexport declare function xor<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$ZodXorParams): ZodXor<T>;\nexport interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[], Disc extends string = string> extends ZodUnion<Options>, core.$ZodDiscriminatedUnion<Options, Disc> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;\n    def: core.$ZodDiscriminatedUnionDef<Options, Disc>;\n}\nexport declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;\nexport declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;\nexport interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodIntersectionInternals<A, B>>, core.$ZodIntersection<A, B> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n}\nexport declare const ZodIntersection: core.$constructor<ZodIntersection>;\nexport declare function intersection<T extends core.SomeType, U extends core.SomeType>(left: T, right: U): ZodIntersection<T, U>;\nexport interface ZodTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends core.SomeType | null = core.$ZodType | null> extends _ZodType<core.$ZodTupleInternals<T, Rest>>, core.$ZodTuple<T, Rest> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    rest<Rest extends core.SomeType = core.$ZodType>(rest: Rest): ZodTuple<T, Rest>;\n}\nexport declare const ZodTuple: core.$constructor<ZodTuple>;\nexport declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]]>(items: T, params?: string | core.$ZodTupleParams): ZodTuple<T, null>;\nexport declare function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], Rest extends core.SomeType>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodTuple<T, Rest>;\nexport declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodTuple<[], null>;\nexport interface ZodRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodRecordInternals<Key, Value>>, core.$ZodRecord<Key, Value> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    keyType: Key;\n    valueType: Value;\n}\nexport declare const ZodRecord: core.$constructor<ZodRecord>;\nexport declare function record<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key, Value>;\nexport declare function partialRecord<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key & core.$partial, Value>;\nexport declare function looseRecord<Key extends core.$ZodRecordKey, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodRecord<Key, Value>;\nexport interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodMapInternals<Key, Value>>, core.$ZodMap<Key, Value> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    keyType: Key;\n    valueType: Value;\n    min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;\n    nonempty(params?: string | core.$ZodCheckMinSizeParams): this;\n    max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;\n    size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;\n}\nexport declare const ZodMap: core.$constructor<ZodMap>;\nexport declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value>;\nexport interface ZodSet<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSetInternals<T>>, core.$ZodSet<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;\n    nonempty(params?: string | core.$ZodCheckMinSizeParams): this;\n    max(maxSize: number, params?: string | core.$ZodCheckMaxSizeParams): this;\n    size(size: number, params?: string | core.$ZodCheckSizeEqualsParams): this;\n}\nexport declare const ZodSet: core.$constructor<ZodSet>;\nexport declare function set<Value extends core.SomeType>(valueType: Value, params?: string | core.$ZodSetParams): ZodSet<Value>;\nexport interface ZodEnum<\n/** @ts-ignore Cast variance */\nout T extends util.EnumLike = util.EnumLike> extends _ZodType<core.$ZodEnumInternals<T>>, core.$ZodEnum<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    enum: T;\n    options: Array<T[keyof T]>;\n    extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Pick<T, U[number]>>>;\n    exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Omit<T, U[number]>>>;\n}\nexport declare const ZodEnum: core.$constructor<ZodEnum>;\ndeclare function _enum<const T extends readonly string[]>(values: T, params?: string | core.$ZodEnumParams): ZodEnum<util.ToEnum<T[number]>>;\ndeclare function _enum<const T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T>;\nexport { _enum as enum };\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodEnum<T>;\nexport interface ZodLiteral<T extends util.Literal = util.Literal> extends _ZodType<core.$ZodLiteralInternals<T>>, core.$ZodLiteral<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    values: Set<T>;\n    /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */\n    value: T;\n}\nexport declare const ZodLiteral: core.$constructor<ZodLiteral>;\nexport declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T[number]>;\nexport declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodLiteral<T>;\nexport interface ZodFile extends _ZodType<core.$ZodFileInternals>, core.$ZodFile {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;\n    max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this;\n    mime(types: util.MimeTypes | Array<util.MimeTypes>, params?: string | core.$ZodCheckMimeTypeParams): this;\n}\nexport declare const ZodFile: core.$constructor<ZodFile>;\nexport declare function file(params?: string | core.$ZodFileParams): ZodFile;\nexport interface ZodTransform<O = unknown, I = unknown> extends _ZodType<core.$ZodTransformInternals<O, I>>, core.$ZodTransform<O, I> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n}\nexport declare const ZodTransform: core.$constructor<ZodTransform>;\nexport declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodTransform<Awaited<O>, I>;\nexport interface ZodOptional<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodOptionalInternals<T>>, core.$ZodOptional<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodOptional: core.$constructor<ZodOptional>;\nexport declare function optional<T extends core.SomeType>(innerType: T): ZodOptional<T>;\nexport interface ZodExactOptional<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodExactOptionalInternals<T>>, core.$ZodExactOptional<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodExactOptional: core.$constructor<ZodExactOptional>;\nexport declare function exactOptional<T extends core.SomeType>(innerType: T): ZodExactOptional<T>;\nexport interface ZodNullable<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodNullableInternals<T>>, core.$ZodNullable<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodNullable: core.$constructor<ZodNullable>;\nexport declare function nullable<T extends core.SomeType>(innerType: T): ZodNullable<T>;\nexport declare function nullish<T extends core.SomeType>(innerType: T): ZodOptional<ZodNullable<T>>;\nexport interface ZodDefault<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodDefaultInternals<T>>, core.$ZodDefault<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n    /** @deprecated Use `.unwrap()` instead. */\n    removeDefault(): T;\n}\nexport declare const ZodDefault: core.$constructor<ZodDefault>;\nexport declare function _default<T extends core.SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodDefault<T>;\nexport interface ZodPrefault<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPrefaultInternals<T>>, core.$ZodPrefault<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodPrefault: core.$constructor<ZodPrefault>;\nexport declare function prefault<T extends core.SomeType>(innerType: T, defaultValue: core.input<T> | (() => core.input<T>)): ZodPrefault<T>;\nexport interface ZodNonOptional<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodNonOptionalInternals<T>>, core.$ZodNonOptional<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodNonOptional: core.$constructor<ZodNonOptional>;\nexport declare function nonoptional<T extends core.SomeType>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodNonOptional<T>;\nexport interface ZodSuccess<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSuccessInternals<T>>, core.$ZodSuccess<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodSuccess: core.$constructor<ZodSuccess>;\nexport declare function success<T extends core.SomeType>(innerType: T): ZodSuccess<T>;\nexport interface ZodCatch<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodCatchInternals<T>>, core.$ZodCatch<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n    /** @deprecated Use `.unwrap()` instead. */\n    removeCatch(): T;\n}\nexport declare const ZodCatch: core.$constructor<ZodCatch>;\ndeclare function _catch<T extends core.SomeType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodCatch<T>;\nexport { _catch as catch };\nexport interface ZodNaN extends _ZodType<core.$ZodNaNInternals>, core.$ZodNaN {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n}\nexport declare const ZodNaN: core.$constructor<ZodNaN>;\nexport declare function nan(params?: string | core.$ZodNaNParams): ZodNaN;\nexport interface ZodPipe<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPipeInternals<A, B>>, core.$ZodPipe<A, B> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    in: A;\n    out: B;\n}\nexport declare const ZodPipe: core.$constructor<ZodPipe>;\nexport declare function pipe<const A extends core.SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodPipe<A, B>;\nexport interface ZodCodec<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType> extends ZodPipe<A, B>, core.$ZodCodec<A, B> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    _zod: core.$ZodCodecInternals<A, B>;\n    def: core.$ZodCodecDef<A, B>;\n}\nexport declare const ZodCodec: core.$constructor<ZodCodec>;\nexport declare function codec<const A extends core.SomeType, B extends core.SomeType = core.$ZodType>(in_: A, out: B, params: {\n    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;\n    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;\n}): ZodCodec<A, B>;\nexport interface ZodReadonly<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodReadonlyInternals<T>>, core.$ZodReadonly<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodReadonly: core.$constructor<ZodReadonly>;\nexport declare function readonly<T extends core.SomeType>(innerType: T): ZodReadonly<T>;\nexport interface ZodTemplateLiteral<Template extends string = string> extends _ZodType<core.$ZodTemplateLiteralInternals<Template>>, core.$ZodTemplateLiteral<Template> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n}\nexport declare const ZodTemplateLiteral: core.$constructor<ZodTemplateLiteral>;\nexport declare function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodTemplateLiteral<core.$PartsToTemplateLiteral<Parts>>;\nexport interface ZodLazy<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodLazyInternals<T>>, core.$ZodLazy<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodLazy: core.$constructor<ZodLazy>;\nexport declare function lazy<T extends core.SomeType>(getter: () => T): ZodLazy<T>;\nexport interface ZodPromise<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodPromiseInternals<T>>, core.$ZodPromise<T> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    unwrap(): T;\n}\nexport declare const ZodPromise: core.$constructor<ZodPromise>;\nexport declare function promise<T extends core.SomeType>(innerType: T): ZodPromise<T>;\nexport interface ZodFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctionIn, Returns extends core.$ZodFunctionOut = core.$ZodFunctionOut> extends _ZodType<core.$ZodFunctionInternals<Args, Returns>>, core.$ZodFunction<Args, Returns> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n    _def: core.$ZodFunctionDef<Args, Returns>;\n    _input: core.$InferInnerFunctionType<Args, Returns>;\n    _output: core.$InferOuterFunctionType<Args, Returns>;\n    input<const Items extends util.TupleItems, const Rest extends core.$ZodFunctionOut = core.$ZodFunctionOut>(args: Items, rest?: Rest): ZodFunction<core.$ZodTuple<Items, Rest>, Returns>;\n    input<NewArgs extends core.$ZodFunctionIn>(args: NewArgs): ZodFunction<NewArgs, Returns>;\n    input(...args: any[]): ZodFunction<any, Returns>;\n    output<NewReturns extends core.$ZodType>(output: NewReturns): ZodFunction<Args, NewReturns>;\n}\nexport declare const ZodFunction: core.$constructor<ZodFunction>;\nexport declare function _function(): ZodFunction;\nexport declare function _function<const In extends ReadonlyArray<core.$ZodType>>(params: {\n    input: In;\n}): ZodFunction<ZodTuple<In, null>, core.$ZodFunctionOut>;\nexport declare function _function<const In extends ReadonlyArray<core.$ZodType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {\n    input: In;\n    output: Out;\n}): ZodFunction<ZodTuple<In, null>, Out>;\nexport declare function _function<const In extends core.$ZodFunctionIn = core.$ZodFunctionIn>(params: {\n    input: In;\n}): ZodFunction<In, core.$ZodFunctionOut>;\nexport declare function _function<const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {\n    output: Out;\n}): ZodFunction<core.$ZodFunctionIn, Out>;\nexport declare function _function<In extends core.$ZodFunctionIn = core.$ZodFunctionIn, Out extends core.$ZodType = core.$ZodType>(params?: {\n    input: In;\n    output: Out;\n}): ZodFunction<In, Out>;\nexport { _function as function };\nexport interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodCustomInternals<O, I>>, core.$ZodCustom<O, I> {\n    \"~standard\": ZodStandardSchemaWithJSON<this>;\n}\nexport declare const ZodCustom: core.$constructor<ZodCustom>;\nexport declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;\nexport declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;\nexport declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;\nexport declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;\nexport declare const describe: typeof core.describe;\nexport declare const meta: typeof core.meta;\ntype ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, \"type\" | \"check\" | \"checks\" | \"fn\" | \"abort\" | \"error\" | \"params\" | \"path\">;\ndeclare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodCustom<InstanceType<T>, InstanceType<T>>;\nexport { _instanceof as instanceof };\nexport declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean>;\ntype _ZodJSONSchema = ZodUnion<[\n    ZodString,\n    ZodNumber,\n    ZodBoolean,\n    ZodNull,\n    ZodArray<ZodJSONSchema>,\n    ZodRecord<ZodString, ZodJSONSchema>\n]>;\ntype _ZodJSONSchemaInternals = _ZodJSONSchema[\"_zod\"];\nexport interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {\n    output: util.JSONType;\n    input: util.JSONType;\n}\nexport interface ZodJSONSchema extends _ZodJSONSchema {\n    _zod: ZodJSONSchemaInternals;\n}\nexport declare function json(params?: string | core.$ZodCustomParams): ZodJSONSchema;\nexport declare function preprocess<A, U extends core.SomeType, B = unknown>(fn: (arg: B, ctx: core.$RefinementCtx) => A, schema: U): ZodPipe<ZodTransform<A, B>, U>;\n",
+	"file:///node_modules/zod/v4/core/api.d.ts": "import * as checks from \"./checks.js\";\nimport type * as core from \"./core.js\";\nimport type * as errors from \"./errors.js\";\nimport * as registries from \"./registries.js\";\nimport * as schemas from \"./schemas.js\";\nimport * as util from \"./util.js\";\nexport type Params<T extends schemas.$ZodType | checks.$ZodCheck, IssueTypes extends errors.$ZodIssueBase, OmitKeys extends keyof T[\"_zod\"][\"def\"] = never> = util.Flatten<Partial<util.EmptyToNever<Omit<T[\"_zod\"][\"def\"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {\n    error?: string | errors.$ZodErrorMap<IssueTypes> | undefined;\n    /** @deprecated This parameter is deprecated. Use `error` instead. */\n    message?: string | undefined;\n})>>>;\nexport type TypeParams<T extends schemas.$ZodType = schemas.$ZodType & {\n    _isst: never;\n}, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"checks\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"]>, \"type\" | \"checks\" | \"error\" | AlsoOmit>;\nexport type CheckParams<T extends checks.$ZodCheck = checks.$ZodCheck, // & { _issc: never },\nAlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"check\" | \"error\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"issc\"]>, \"check\" | \"error\" | AlsoOmit>;\nexport type StringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"] | T[\"_zod\"][\"issc\"]>, \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\" | AlsoOmit>;\nexport type CheckStringFormatParams<T extends schemas.$ZodStringFormat = schemas.$ZodStringFormat, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"issc\"]>, \"type\" | \"coerce\" | \"checks\" | \"error\" | \"check\" | \"format\" | AlsoOmit>;\nexport type CheckTypeParams<T extends schemas.$ZodType & checks.$ZodCheck = schemas.$ZodType & checks.$ZodCheck, AlsoOmit extends Exclude<keyof T[\"_zod\"][\"def\"], \"type\" | \"checks\" | \"error\" | \"check\"> = never> = Params<T, NonNullable<T[\"_zod\"][\"isst\"] | T[\"_zod\"][\"issc\"]>, \"type\" | \"checks\" | \"error\" | \"check\" | AlsoOmit>;\nexport type $ZodStringParams = TypeParams<schemas.$ZodString<string>, \"coerce\">;\nexport declare function _string<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport declare function _coercedString<T extends schemas.$ZodString>(Class: util.SchemaClass<T>, params?: string | $ZodStringParams): T;\nexport type $ZodStringFormatParams = CheckTypeParams<schemas.$ZodStringFormat, \"format\" | \"coerce\" | \"when\" | \"pattern\">;\nexport type $ZodCheckStringFormatParams = CheckParams<checks.$ZodCheckStringFormat, \"format\">;\nexport type $ZodEmailParams = StringFormatParams<schemas.$ZodEmail, \"when\">;\nexport type $ZodCheckEmailParams = CheckStringFormatParams<schemas.$ZodEmail, \"when\">;\nexport declare function _email<T extends schemas.$ZodEmail>(Class: util.SchemaClass<T>, params?: string | $ZodEmailParams | $ZodCheckEmailParams): T;\nexport type $ZodGUIDParams = StringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport type $ZodCheckGUIDParams = CheckStringFormatParams<schemas.$ZodGUID, \"pattern\" | \"when\">;\nexport declare function _guid<T extends schemas.$ZodGUID>(Class: util.SchemaClass<T>, params?: string | $ZodGUIDParams | $ZodCheckGUIDParams): T;\nexport type $ZodUUIDParams = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDParams = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuid<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDParams | $ZodCheckUUIDParams): T;\nexport type $ZodUUIDv4Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv4Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv4<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv4Params | $ZodCheckUUIDv4Params): T;\nexport type $ZodUUIDv6Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv6Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv6<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv6Params | $ZodCheckUUIDv6Params): T;\nexport type $ZodUUIDv7Params = StringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport type $ZodCheckUUIDv7Params = CheckStringFormatParams<schemas.$ZodUUID, \"pattern\" | \"when\">;\nexport declare function _uuidv7<T extends schemas.$ZodUUID>(Class: util.SchemaClass<T>, params?: string | $ZodUUIDv7Params | $ZodCheckUUIDv7Params): T;\nexport type $ZodURLParams = StringFormatParams<schemas.$ZodURL, \"when\">;\nexport type $ZodCheckURLParams = CheckStringFormatParams<schemas.$ZodURL, \"when\">;\nexport declare function _url<T extends schemas.$ZodURL>(Class: util.SchemaClass<T>, params?: string | $ZodURLParams | $ZodCheckURLParams): T;\nexport type $ZodEmojiParams = StringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport type $ZodCheckEmojiParams = CheckStringFormatParams<schemas.$ZodEmoji, \"when\">;\nexport declare function _emoji<T extends schemas.$ZodEmoji>(Class: util.SchemaClass<T>, params?: string | $ZodEmojiParams | $ZodCheckEmojiParams): T;\nexport type $ZodNanoIDParams = StringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport type $ZodCheckNanoIDParams = CheckStringFormatParams<schemas.$ZodNanoID, \"when\">;\nexport declare function _nanoid<T extends schemas.$ZodNanoID>(Class: util.SchemaClass<T>, params?: string | $ZodNanoIDParams | $ZodCheckNanoIDParams): T;\nexport type $ZodCUIDParams = StringFormatParams<schemas.$ZodCUID, \"when\">;\nexport type $ZodCheckCUIDParams = CheckStringFormatParams<schemas.$ZodCUID, \"when\">;\nexport declare function _cuid<T extends schemas.$ZodCUID>(Class: util.SchemaClass<T>, params?: string | $ZodCUIDParams | $ZodCheckCUIDParams): T;\nexport type $ZodCUID2Params = StringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport type $ZodCheckCUID2Params = CheckStringFormatParams<schemas.$ZodCUID2, \"when\">;\nexport declare function _cuid2<T extends schemas.$ZodCUID2>(Class: util.SchemaClass<T>, params?: string | $ZodCUID2Params | $ZodCheckCUID2Params): T;\nexport type $ZodULIDParams = StringFormatParams<schemas.$ZodULID, \"when\">;\nexport type $ZodCheckULIDParams = CheckStringFormatParams<schemas.$ZodULID, \"when\">;\nexport declare function _ulid<T extends schemas.$ZodULID>(Class: util.SchemaClass<T>, params?: string | $ZodULIDParams | $ZodCheckULIDParams): T;\nexport type $ZodXIDParams = StringFormatParams<schemas.$ZodXID, \"when\">;\nexport type $ZodCheckXIDParams = CheckStringFormatParams<schemas.$ZodXID, \"when\">;\nexport declare function _xid<T extends schemas.$ZodXID>(Class: util.SchemaClass<T>, params?: string | $ZodXIDParams | $ZodCheckXIDParams): T;\nexport type $ZodKSUIDParams = StringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport type $ZodCheckKSUIDParams = CheckStringFormatParams<schemas.$ZodKSUID, \"when\">;\nexport declare function _ksuid<T extends schemas.$ZodKSUID>(Class: util.SchemaClass<T>, params?: string | $ZodKSUIDParams | $ZodCheckKSUIDParams): T;\nexport type $ZodIPv4Params = StringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv4Params = CheckStringFormatParams<schemas.$ZodIPv4, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv4<T extends schemas.$ZodIPv4>(Class: util.SchemaClass<T>, params?: string | $ZodIPv4Params | $ZodCheckIPv4Params): T;\nexport type $ZodIPv6Params = StringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport type $ZodCheckIPv6Params = CheckStringFormatParams<schemas.$ZodIPv6, \"pattern\" | \"when\" | \"version\">;\nexport declare function _ipv6<T extends schemas.$ZodIPv6>(Class: util.SchemaClass<T>, params?: string | $ZodIPv6Params | $ZodCheckIPv6Params): T;\nexport type $ZodMACParams = StringFormatParams<schemas.$ZodMAC, \"pattern\" | \"when\">;\nexport type $ZodCheckMACParams = CheckStringFormatParams<schemas.$ZodMAC, \"pattern\" | \"when\">;\nexport declare function _mac<T extends schemas.$ZodMAC>(Class: util.SchemaClass<T>, params?: string | $ZodMACParams | $ZodCheckMACParams): T;\nexport type $ZodCIDRv4Params = StringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv4Params = CheckStringFormatParams<schemas.$ZodCIDRv4, \"pattern\" | \"when\">;\nexport declare function _cidrv4<T extends schemas.$ZodCIDRv4>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv4Params | $ZodCheckCIDRv4Params): T;\nexport type $ZodCIDRv6Params = StringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport type $ZodCheckCIDRv6Params = CheckStringFormatParams<schemas.$ZodCIDRv6, \"pattern\" | \"when\">;\nexport declare function _cidrv6<T extends schemas.$ZodCIDRv6>(Class: util.SchemaClass<T>, params?: string | $ZodCIDRv6Params | $ZodCheckCIDRv6Params): T;\nexport type $ZodBase64Params = StringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64Params = CheckStringFormatParams<schemas.$ZodBase64, \"pattern\" | \"when\">;\nexport declare function _base64<T extends schemas.$ZodBase64>(Class: util.SchemaClass<T>, params?: string | $ZodBase64Params | $ZodCheckBase64Params): T;\nexport type $ZodBase64URLParams = StringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport type $ZodCheckBase64URLParams = CheckStringFormatParams<schemas.$ZodBase64URL, \"pattern\" | \"when\">;\nexport declare function _base64url<T extends schemas.$ZodBase64URL>(Class: util.SchemaClass<T>, params?: string | $ZodBase64URLParams | $ZodCheckBase64URLParams): T;\nexport type $ZodE164Params = StringFormatParams<schemas.$ZodE164, \"when\">;\nexport type $ZodCheckE164Params = CheckStringFormatParams<schemas.$ZodE164, \"when\">;\nexport declare function _e164<T extends schemas.$ZodE164>(Class: util.SchemaClass<T>, params?: string | $ZodE164Params | $ZodCheckE164Params): T;\nexport type $ZodJWTParams = StringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport type $ZodCheckJWTParams = CheckStringFormatParams<schemas.$ZodJWT, \"pattern\" | \"when\">;\nexport declare function _jwt<T extends schemas.$ZodJWT>(Class: util.SchemaClass<T>, params?: string | $ZodJWTParams | $ZodCheckJWTParams): T;\nexport declare const TimePrecision: {\n    readonly Any: null;\n    readonly Minute: -1;\n    readonly Second: 0;\n    readonly Millisecond: 3;\n    readonly Microsecond: 6;\n};\nexport type $ZodISODateTimeParams = StringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateTimeParams = CheckStringFormatParams<schemas.$ZodISODateTime, \"pattern\" | \"when\">;\nexport declare function _isoDateTime<T extends schemas.$ZodISODateTime>(Class: util.SchemaClass<T>, params?: string | $ZodISODateTimeParams | $ZodCheckISODateTimeParams): T;\nexport type $ZodISODateParams = StringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport type $ZodCheckISODateParams = CheckStringFormatParams<schemas.$ZodISODate, \"pattern\" | \"when\">;\nexport declare function _isoDate<T extends schemas.$ZodISODate>(Class: util.SchemaClass<T>, params?: string | $ZodISODateParams | $ZodCheckISODateParams): T;\nexport type $ZodISOTimeParams = StringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport type $ZodCheckISOTimeParams = CheckStringFormatParams<schemas.$ZodISOTime, \"pattern\" | \"when\">;\nexport declare function _isoTime<T extends schemas.$ZodISOTime>(Class: util.SchemaClass<T>, params?: string | $ZodISOTimeParams | $ZodCheckISOTimeParams): T;\nexport type $ZodISODurationParams = StringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport type $ZodCheckISODurationParams = CheckStringFormatParams<schemas.$ZodISODuration, \"when\">;\nexport declare function _isoDuration<T extends schemas.$ZodISODuration>(Class: util.SchemaClass<T>, params?: string | $ZodISODurationParams | $ZodCheckISODurationParams): T;\nexport type $ZodNumberParams = TypeParams<schemas.$ZodNumber<number>, \"coerce\">;\nexport type $ZodNumberFormatParams = CheckTypeParams<schemas.$ZodNumberFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckNumberFormatParams = CheckParams<checks.$ZodCheckNumberFormat, \"format\" | \"when\">;\nexport declare function _number<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _coercedNumber<T extends schemas.$ZodNumber>(Class: util.SchemaClass<T>, params?: string | $ZodNumberParams): T;\nexport declare function _int<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _float64<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _int32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport declare function _uint32<T extends schemas.$ZodNumberFormat>(Class: util.SchemaClass<T>, params?: string | $ZodCheckNumberFormatParams): T;\nexport type $ZodBooleanParams = TypeParams<schemas.$ZodBoolean<boolean>, \"coerce\">;\nexport declare function _boolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport declare function _coercedBoolean<T extends schemas.$ZodBoolean>(Class: util.SchemaClass<T>, params?: string | $ZodBooleanParams): T;\nexport type $ZodBigIntParams = TypeParams<schemas.$ZodBigInt<bigint>>;\nexport type $ZodBigIntFormatParams = CheckTypeParams<schemas.$ZodBigIntFormat, \"format\" | \"coerce\">;\nexport type $ZodCheckBigIntFormatParams = CheckParams<checks.$ZodCheckBigIntFormat, \"format\" | \"when\">;\nexport declare function _bigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _coercedBigint<T extends schemas.$ZodBigInt>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntParams): T;\nexport declare function _int64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport declare function _uint64<T extends schemas.$ZodBigIntFormat>(Class: util.SchemaClass<T>, params?: string | $ZodBigIntFormatParams): T;\nexport type $ZodSymbolParams = TypeParams<schemas.$ZodSymbol>;\nexport declare function _symbol<T extends schemas.$ZodSymbol>(Class: util.SchemaClass<T>, params?: string | $ZodSymbolParams): T;\nexport type $ZodUndefinedParams = TypeParams<schemas.$ZodUndefined>;\nexport declare function _undefined<T extends schemas.$ZodUndefined>(Class: util.SchemaClass<T>, params?: string | $ZodUndefinedParams): T;\nexport type $ZodNullParams = TypeParams<schemas.$ZodNull>;\nexport declare function _null<T extends schemas.$ZodNull>(Class: util.SchemaClass<T>, params?: string | $ZodNullParams): T;\nexport type $ZodAnyParams = TypeParams<schemas.$ZodAny>;\nexport declare function _any<T extends schemas.$ZodAny>(Class: util.SchemaClass<T>): T;\nexport type $ZodUnknownParams = TypeParams<schemas.$ZodUnknown>;\nexport declare function _unknown<T extends schemas.$ZodUnknown>(Class: util.SchemaClass<T>): T;\nexport type $ZodNeverParams = TypeParams<schemas.$ZodNever>;\nexport declare function _never<T extends schemas.$ZodNever>(Class: util.SchemaClass<T>, params?: string | $ZodNeverParams): T;\nexport type $ZodVoidParams = TypeParams<schemas.$ZodVoid>;\nexport declare function _void<T extends schemas.$ZodVoid>(Class: util.SchemaClass<T>, params?: string | $ZodVoidParams): T;\nexport type $ZodDateParams = TypeParams<schemas.$ZodDate, \"coerce\">;\nexport declare function _date<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport declare function _coercedDate<T extends schemas.$ZodDate>(Class: util.SchemaClass<T>, params?: string | $ZodDateParams): T;\nexport type $ZodNaNParams = TypeParams<schemas.$ZodNaN>;\nexport declare function _nan<T extends schemas.$ZodNaN>(Class: util.SchemaClass<T>, params?: string | $ZodNaNParams): T;\nexport type $ZodCheckLessThanParams = CheckParams<checks.$ZodCheckLessThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _lt(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport declare function _lte(value: util.Numeric, params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan<util.Numeric>;\nexport { \n/** @deprecated Use `z.lte()` instead. */\n_lte as _max, };\nexport type $ZodCheckGreaterThanParams = CheckParams<checks.$ZodCheckGreaterThan, \"inclusive\" | \"value\" | \"when\">;\nexport declare function _gt(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _gte(value: util.Numeric, params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport { \n/** @deprecated Use `z.gte()` instead. */\n_gte as _min, };\nexport declare function _positive(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport declare function _negative(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonpositive(params?: string | $ZodCheckLessThanParams): checks.$ZodCheckLessThan;\nexport declare function _nonnegative(params?: string | $ZodCheckGreaterThanParams): checks.$ZodCheckGreaterThan;\nexport type $ZodCheckMultipleOfParams = CheckParams<checks.$ZodCheckMultipleOf, \"value\" | \"when\">;\nexport declare function _multipleOf(value: number | bigint, params?: string | $ZodCheckMultipleOfParams): checks.$ZodCheckMultipleOf;\nexport type $ZodCheckMaxSizeParams = CheckParams<checks.$ZodCheckMaxSize, \"maximum\" | \"when\">;\nexport declare function _maxSize(maximum: number, params?: string | $ZodCheckMaxSizeParams): checks.$ZodCheckMaxSize<util.HasSize>;\nexport type $ZodCheckMinSizeParams = CheckParams<checks.$ZodCheckMinSize, \"minimum\" | \"when\">;\nexport declare function _minSize(minimum: number, params?: string | $ZodCheckMinSizeParams): checks.$ZodCheckMinSize<util.HasSize>;\nexport type $ZodCheckSizeEqualsParams = CheckParams<checks.$ZodCheckSizeEquals, \"size\" | \"when\">;\nexport declare function _size(size: number, params?: string | $ZodCheckSizeEqualsParams): checks.$ZodCheckSizeEquals<util.HasSize>;\nexport type $ZodCheckMaxLengthParams = CheckParams<checks.$ZodCheckMaxLength, \"maximum\" | \"when\">;\nexport declare function _maxLength(maximum: number, params?: string | $ZodCheckMaxLengthParams): checks.$ZodCheckMaxLength<util.HasLength>;\nexport type $ZodCheckMinLengthParams = CheckParams<checks.$ZodCheckMinLength, \"minimum\" | \"when\">;\nexport declare function _minLength(minimum: number, params?: string | $ZodCheckMinLengthParams): checks.$ZodCheckMinLength<util.HasLength>;\nexport type $ZodCheckLengthEqualsParams = CheckParams<checks.$ZodCheckLengthEquals, \"length\" | \"when\">;\nexport declare function _length(length: number, params?: string | $ZodCheckLengthEqualsParams): checks.$ZodCheckLengthEquals<util.HasLength>;\nexport type $ZodCheckRegexParams = CheckParams<checks.$ZodCheckRegex, \"format\" | \"pattern\" | \"when\">;\nexport declare function _regex(pattern: RegExp, params?: string | $ZodCheckRegexParams): checks.$ZodCheckRegex;\nexport type $ZodCheckLowerCaseParams = CheckParams<checks.$ZodCheckLowerCase, \"format\" | \"when\">;\nexport declare function _lowercase(params?: string | $ZodCheckLowerCaseParams): checks.$ZodCheckLowerCase;\nexport type $ZodCheckUpperCaseParams = CheckParams<checks.$ZodCheckUpperCase, \"format\" | \"when\">;\nexport declare function _uppercase(params?: string | $ZodCheckUpperCaseParams): checks.$ZodCheckUpperCase;\nexport type $ZodCheckIncludesParams = CheckParams<checks.$ZodCheckIncludes, \"includes\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _includes(includes: string, params?: string | $ZodCheckIncludesParams): checks.$ZodCheckIncludes;\nexport type $ZodCheckStartsWithParams = CheckParams<checks.$ZodCheckStartsWith, \"prefix\" | \"format\" | \"when\" | \"pattern\">;\nexport declare function _startsWith(prefix: string, params?: string | $ZodCheckStartsWithParams): checks.$ZodCheckStartsWith;\nexport type $ZodCheckEndsWithParams = CheckParams<checks.$ZodCheckEndsWith, \"suffix\" | \"format\" | \"pattern\" | \"when\">;\nexport declare function _endsWith(suffix: string, params?: string | $ZodCheckEndsWithParams): checks.$ZodCheckEndsWith;\nexport type $ZodCheckPropertyParams = CheckParams<checks.$ZodCheckProperty, \"property\" | \"schema\" | \"when\">;\nexport declare function _property<K extends string, T extends schemas.$ZodType>(property: K, schema: T, params?: string | $ZodCheckPropertyParams): checks.$ZodCheckProperty<{\n    [k in K]: core.output<T>;\n}>;\nexport type $ZodCheckMimeTypeParams = CheckParams<checks.$ZodCheckMimeType, \"mime\" | \"when\">;\nexport declare function _mime(types: util.MimeTypes[], params?: string | $ZodCheckMimeTypeParams): checks.$ZodCheckMimeType;\nexport declare function _overwrite<T>(tx: (input: T) => T): checks.$ZodCheckOverwrite<T>;\nexport declare function _normalize(form?: \"NFC\" | \"NFD\" | \"NFKC\" | \"NFKD\" | (string & {})): checks.$ZodCheckOverwrite<string>;\nexport declare function _trim(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toLowerCase(): checks.$ZodCheckOverwrite<string>;\nexport declare function _toUpperCase(): checks.$ZodCheckOverwrite<string>;\nexport declare function _slugify(): checks.$ZodCheckOverwrite<string>;\nexport type $ZodArrayParams = TypeParams<schemas.$ZodArray, \"element\">;\nexport declare function _array<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodArray>, element: T, params?: string | $ZodArrayParams): schemas.$ZodArray<T>;\nexport type $ZodObjectParams = TypeParams<schemas.$ZodObject, \"shape\" | \"catchall\">;\nexport type $ZodUnionParams = TypeParams<schemas.$ZodUnion, \"options\">;\nexport declare function _union<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodUnion>, options: T, params?: string | $ZodUnionParams): schemas.$ZodUnion<T>;\nexport type $ZodXorParams = TypeParams<schemas.$ZodXor, \"options\">;\nexport declare function _xor<const T extends readonly schemas.$ZodObject[]>(Class: util.SchemaClass<schemas.$ZodXor>, options: T, params?: string | $ZodXorParams): schemas.$ZodXor<T>;\nexport interface $ZodTypeDiscriminableInternals extends schemas.$ZodTypeInternals {\n    propValues: util.PropValues;\n}\nexport interface $ZodTypeDiscriminable extends schemas.$ZodType {\n    _zod: $ZodTypeDiscriminableInternals;\n}\nexport type $ZodDiscriminatedUnionParams = TypeParams<schemas.$ZodDiscriminatedUnion, \"options\" | \"discriminator\">;\nexport declare function _discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(Class: util.SchemaClass<schemas.$ZodDiscriminatedUnion>, discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): schemas.$ZodDiscriminatedUnion<Types, Disc>;\nexport type $ZodIntersectionParams = TypeParams<schemas.$ZodIntersection, \"left\" | \"right\">;\nexport declare function _intersection<T extends schemas.$ZodObject, U extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodIntersection>, left: T, right: U): schemas.$ZodIntersection<T, U>;\nexport type $ZodTupleParams = TypeParams<schemas.$ZodTuple, \"items\" | \"rest\">;\nexport declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]]>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, null>;\nexport declare function _tuple<T extends readonly [schemas.$ZodType, ...schemas.$ZodType[]], Rest extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodTuple>, items: T, rest: Rest, params?: string | $ZodTupleParams): schemas.$ZodTuple<T, Rest>;\nexport type $ZodRecordParams = TypeParams<schemas.$ZodRecord, \"keyType\" | \"valueType\">;\nexport declare function _record<Key extends schemas.$ZodRecordKey, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodRecord>, keyType: Key, valueType: Value, params?: string | $ZodRecordParams): schemas.$ZodRecord<Key, Value>;\nexport type $ZodMapParams = TypeParams<schemas.$ZodMap, \"keyType\" | \"valueType\">;\nexport declare function _map<Key extends schemas.$ZodObject, Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodMap>, keyType: Key, valueType: Value, params?: string | $ZodMapParams): schemas.$ZodMap<Key, Value>;\nexport type $ZodSetParams = TypeParams<schemas.$ZodSet, \"valueType\">;\nexport declare function _set<Value extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSet>, valueType: Value, params?: string | $ZodSetParams): schemas.$ZodSet<Value>;\nexport type $ZodEnumParams = TypeParams<schemas.$ZodEnum, \"entries\">;\nexport declare function _enum<const T extends string[]>(Class: util.SchemaClass<schemas.$ZodEnum>, values: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<util.ToEnum<T[number]>>;\nexport declare function _enum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport declare function _nativeEnum<T extends util.EnumLike>(Class: util.SchemaClass<schemas.$ZodEnum>, entries: T, params?: string | $ZodEnumParams): schemas.$ZodEnum<T>;\nexport type $ZodLiteralParams = TypeParams<schemas.$ZodLiteral, \"values\">;\nexport declare function _literal<const T extends Array<util.Literal>>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T[number]>;\nexport declare function _literal<const T extends util.Literal>(Class: util.SchemaClass<schemas.$ZodLiteral>, value: T, params?: string | $ZodLiteralParams): schemas.$ZodLiteral<T>;\nexport type $ZodFileParams = TypeParams<schemas.$ZodFile>;\nexport declare function _file(Class: util.SchemaClass<schemas.$ZodFile>, params?: string | $ZodFileParams): schemas.$ZodFile;\nexport type $ZodTransformParams = TypeParams<schemas.$ZodTransform, \"transform\">;\nexport declare function _transform<I = unknown, O = I>(Class: util.SchemaClass<schemas.$ZodTransform>, fn: (input: I, ctx?: schemas.ParsePayload) => O): schemas.$ZodTransform<Awaited<O>, I>;\nexport type $ZodOptionalParams = TypeParams<schemas.$ZodOptional, \"innerType\">;\nexport declare function _optional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodOptional>, innerType: T): schemas.$ZodOptional<T>;\nexport type $ZodNullableParams = TypeParams<schemas.$ZodNullable, \"innerType\">;\nexport declare function _nullable<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNullable>, innerType: T): schemas.$ZodNullable<T>;\nexport type $ZodDefaultParams = TypeParams<schemas.$ZodDefault, \"innerType\" | \"defaultValue\">;\nexport declare function _default<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodDefault>, innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): schemas.$ZodDefault<T>;\nexport type $ZodNonOptionalParams = TypeParams<schemas.$ZodNonOptional, \"innerType\">;\nexport declare function _nonoptional<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodNonOptional>, innerType: T, params?: string | $ZodNonOptionalParams): schemas.$ZodNonOptional<T>;\nexport type $ZodSuccessParams = TypeParams<schemas.$ZodSuccess, \"innerType\">;\nexport declare function _success<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodSuccess>, innerType: T): schemas.$ZodSuccess<T>;\nexport type $ZodCatchParams = TypeParams<schemas.$ZodCatch, \"innerType\" | \"catchValue\">;\nexport declare function _catch<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodCatch>, innerType: T, catchValue: core.output<T> | ((ctx: schemas.$ZodCatchCtx) => core.output<T>)): schemas.$ZodCatch<T>;\nexport type $ZodPipeParams = TypeParams<schemas.$ZodPipe, \"in\" | \"out\">;\nexport declare function _pipe<const A extends schemas.$ZodType, B extends schemas.$ZodType<unknown, core.output<A>> = schemas.$ZodType<unknown, core.output<A>>>(Class: util.SchemaClass<schemas.$ZodPipe>, in_: A, out: B | schemas.$ZodType<unknown, core.output<A>>): schemas.$ZodPipe<A, B>;\nexport type $ZodReadonlyParams = TypeParams<schemas.$ZodReadonly, \"innerType\">;\nexport declare function _readonly<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodReadonly>, innerType: T): schemas.$ZodReadonly<T>;\nexport type $ZodTemplateLiteralParams = TypeParams<schemas.$ZodTemplateLiteral, \"parts\">;\nexport declare function _templateLiteral<const Parts extends schemas.$ZodTemplateLiteralPart[]>(Class: util.SchemaClass<schemas.$ZodTemplateLiteral>, parts: Parts, params?: string | $ZodTemplateLiteralParams): schemas.$ZodTemplateLiteral<schemas.$PartsToTemplateLiteral<Parts>>;\nexport type $ZodLazyParams = TypeParams<schemas.$ZodLazy, \"getter\">;\nexport declare function _lazy<T extends schemas.$ZodType>(Class: util.SchemaClass<schemas.$ZodLazy>, getter: () => T): schemas.$ZodLazy<T>;\nexport type $ZodPromiseParams = TypeParams<schemas.$ZodPromise, \"innerType\">;\nexport declare function _promise<T extends schemas.$ZodObject>(Class: util.SchemaClass<schemas.$ZodPromise>, innerType: T): schemas.$ZodPromise<T>;\nexport type $ZodCustomParams = CheckTypeParams<schemas.$ZodCustom, \"fn\">;\nexport declare function _custom<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport declare function _refine<O = unknown, I = O>(Class: util.SchemaClass<schemas.$ZodCustom>, fn: (data: O) => unknown, _params: string | $ZodCustomParams | undefined): schemas.$ZodCustom<O, I>;\nexport type $ZodSuperRefineIssue<T extends errors.$ZodIssueBase = errors.$ZodIssue> = T extends any ? RawIssue<T> : never;\ntype RawIssue<T extends errors.$ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, \"message\" | \"path\"> & {\n    /** The schema or check that originated this issue. */\n    readonly inst?: schemas.$ZodType | checks.$ZodCheck;\n    /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */\n    readonly continue?: boolean | undefined;\n} & Record<string, unknown>> : never;\nexport interface $RefinementCtx<T = unknown> extends schemas.ParsePayload<T> {\n    addIssue(arg: string | $ZodSuperRefineIssue): void;\n}\nexport declare function _superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>): checks.$ZodCheck<T>;\nexport declare function _check<O = unknown>(fn: schemas.CheckFn<O>, params?: string | $ZodCustomParams): checks.$ZodCheck<O>;\nexport declare function describe<T>(description: string): checks.$ZodCheck<T>;\nexport declare function meta<T>(metadata: registries.GlobalMeta): checks.$ZodCheck<T>;\nexport interface $ZodStringBoolParams extends TypeParams {\n    truthy?: string[];\n    falsy?: string[];\n    /**\n     * Options: `\"sensitive\"`, `\"insensitive\"`\n     *\n     * @default `\"insensitive\"`\n     */\n    case?: \"sensitive\" | \"insensitive\" | undefined;\n}\nexport declare function _stringbool(Classes: {\n    Codec?: typeof schemas.$ZodCodec;\n    Boolean?: typeof schemas.$ZodBoolean;\n    String?: typeof schemas.$ZodString;\n}, _params?: string | $ZodStringBoolParams): schemas.$ZodCodec<schemas.$ZodString, schemas.$ZodBoolean>;\nexport declare function _stringFormat<Format extends string>(Class: typeof schemas.$ZodCustomStringFormat, format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): schemas.$ZodCustomStringFormat<Format>;\n",
+	"file:///node_modules/zod/v4/core/checks.d.ts": "import * as core from \"./core.js\";\nimport type * as errors from \"./errors.js\";\nimport type * as schemas from \"./schemas.js\";\nimport * as util from \"./util.js\";\nexport interface $ZodCheckDef {\n    check: string;\n    error?: errors.$ZodErrorMap<never> | undefined;\n    /** If true, no later checks will be executed if this check fails. Default `false`. */\n    abort?: boolean | undefined;\n    /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */\n    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;\n}\nexport interface $ZodCheckInternals<T> {\n    def: $ZodCheckDef;\n    /** The set of issues this check might throw. */\n    issc?: errors.$ZodIssueBase;\n    check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;\n    onattach: ((schema: schemas.$ZodType) => void)[];\n}\nexport interface $ZodCheck<in T = never> {\n    _zod: $ZodCheckInternals<T>;\n}\nexport declare const $ZodCheck: core.$constructor<$ZodCheck<any>>;\nexport interface $ZodCheckLessThanDef extends $ZodCheckDef {\n    check: \"less_than\";\n    value: util.Numeric;\n    inclusive: boolean;\n}\nexport interface $ZodCheckLessThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {\n    def: $ZodCheckLessThanDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckLessThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {\n    _zod: $ZodCheckLessThanInternals<T>;\n}\nexport declare const $ZodCheckLessThan: core.$constructor<$ZodCheckLessThan>;\nexport interface $ZodCheckGreaterThanDef extends $ZodCheckDef {\n    check: \"greater_than\";\n    value: util.Numeric;\n    inclusive: boolean;\n}\nexport interface $ZodCheckGreaterThanInternals<T extends util.Numeric = util.Numeric> extends $ZodCheckInternals<T> {\n    def: $ZodCheckGreaterThanDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckGreaterThan<T extends util.Numeric = util.Numeric> extends $ZodCheck<T> {\n    _zod: $ZodCheckGreaterThanInternals<T>;\n}\nexport declare const $ZodCheckGreaterThan: core.$constructor<$ZodCheckGreaterThan>;\nexport interface $ZodCheckMultipleOfDef<T extends number | bigint = number | bigint> extends $ZodCheckDef {\n    check: \"multiple_of\";\n    value: T;\n}\nexport interface $ZodCheckMultipleOfInternals<T extends number | bigint = number | bigint> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMultipleOfDef<T>;\n    issc: errors.$ZodIssueNotMultipleOf;\n}\nexport interface $ZodCheckMultipleOf<T extends number | bigint = number | bigint> extends $ZodCheck<T> {\n    _zod: $ZodCheckMultipleOfInternals<T>;\n}\nexport declare const $ZodCheckMultipleOf: core.$constructor<$ZodCheckMultipleOf<number | bigint>>;\nexport type $ZodNumberFormats = \"int32\" | \"uint32\" | \"float32\" | \"float64\" | \"safeint\";\nexport interface $ZodCheckNumberFormatDef extends $ZodCheckDef {\n    check: \"number_format\";\n    format: $ZodNumberFormats;\n}\nexport interface $ZodCheckNumberFormatInternals extends $ZodCheckInternals<number> {\n    def: $ZodCheckNumberFormatDef;\n    issc: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<\"number\"> | errors.$ZodIssueTooSmall<\"number\">;\n}\nexport interface $ZodCheckNumberFormat extends $ZodCheck<number> {\n    _zod: $ZodCheckNumberFormatInternals;\n}\nexport declare const $ZodCheckNumberFormat: core.$constructor<$ZodCheckNumberFormat>;\nexport type $ZodBigIntFormats = \"int64\" | \"uint64\";\nexport interface $ZodCheckBigIntFormatDef extends $ZodCheckDef {\n    check: \"bigint_format\";\n    format: $ZodBigIntFormats | undefined;\n}\nexport interface $ZodCheckBigIntFormatInternals extends $ZodCheckInternals<bigint> {\n    def: $ZodCheckBigIntFormatDef;\n    issc: errors.$ZodIssueTooBig<\"bigint\"> | errors.$ZodIssueTooSmall<\"bigint\">;\n}\nexport interface $ZodCheckBigIntFormat extends $ZodCheck<bigint> {\n    _zod: $ZodCheckBigIntFormatInternals;\n}\nexport declare const $ZodCheckBigIntFormat: core.$constructor<$ZodCheckBigIntFormat>;\nexport interface $ZodCheckMaxSizeDef extends $ZodCheckDef {\n    check: \"max_size\";\n    maximum: number;\n}\nexport interface $ZodCheckMaxSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMaxSizeDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckMaxSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckMaxSizeInternals<T>;\n}\nexport declare const $ZodCheckMaxSize: core.$constructor<$ZodCheckMaxSize>;\nexport interface $ZodCheckMinSizeDef extends $ZodCheckDef {\n    check: \"min_size\";\n    minimum: number;\n}\nexport interface $ZodCheckMinSizeInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMinSizeDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckMinSize<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckMinSizeInternals<T>;\n}\nexport declare const $ZodCheckMinSize: core.$constructor<$ZodCheckMinSize>;\nexport interface $ZodCheckSizeEqualsDef extends $ZodCheckDef {\n    check: \"size_equals\";\n    size: number;\n}\nexport interface $ZodCheckSizeEqualsInternals<T extends util.HasSize = util.HasSize> extends $ZodCheckInternals<T> {\n    def: $ZodCheckSizeEqualsDef;\n    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckSizeEquals<T extends util.HasSize = util.HasSize> extends $ZodCheck<T> {\n    _zod: $ZodCheckSizeEqualsInternals<T>;\n}\nexport declare const $ZodCheckSizeEquals: core.$constructor<$ZodCheckSizeEquals>;\nexport interface $ZodCheckMaxLengthDef extends $ZodCheckDef {\n    check: \"max_length\";\n    maximum: number;\n}\nexport interface $ZodCheckMaxLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMaxLengthDef;\n    issc: errors.$ZodIssueTooBig<T>;\n}\nexport interface $ZodCheckMaxLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckMaxLengthInternals<T>;\n}\nexport declare const $ZodCheckMaxLength: core.$constructor<$ZodCheckMaxLength>;\nexport interface $ZodCheckMinLengthDef extends $ZodCheckDef {\n    check: \"min_length\";\n    minimum: number;\n}\nexport interface $ZodCheckMinLengthInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMinLengthDef;\n    issc: errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckMinLength<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckMinLengthInternals<T>;\n}\nexport declare const $ZodCheckMinLength: core.$constructor<$ZodCheckMinLength>;\nexport interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {\n    check: \"length_equals\";\n    length: number;\n}\nexport interface $ZodCheckLengthEqualsInternals<T extends util.HasLength = util.HasLength> extends $ZodCheckInternals<T> {\n    def: $ZodCheckLengthEqualsDef;\n    issc: errors.$ZodIssueTooBig<T> | errors.$ZodIssueTooSmall<T>;\n}\nexport interface $ZodCheckLengthEquals<T extends util.HasLength = util.HasLength> extends $ZodCheck<T> {\n    _zod: $ZodCheckLengthEqualsInternals<T>;\n}\nexport declare const $ZodCheckLengthEquals: core.$constructor<$ZodCheckLengthEquals>;\nexport type $ZodStringFormats = \"email\" | \"url\" | \"emoji\" | \"uuid\" | \"guid\" | \"nanoid\" | \"cuid\" | \"cuid2\" | \"ulid\" | \"xid\" | \"ksuid\" | \"datetime\" | \"date\" | \"time\" | \"duration\" | \"ipv4\" | \"ipv6\" | \"cidrv4\" | \"cidrv6\" | \"base64\" | \"base64url\" | \"json_string\" | \"e164\" | \"lowercase\" | \"uppercase\" | \"regex\" | \"jwt\" | \"starts_with\" | \"ends_with\" | \"includes\";\nexport interface $ZodCheckStringFormatDef<Format extends string = string> extends $ZodCheckDef {\n    check: \"string_format\";\n    format: Format;\n    pattern?: RegExp | undefined;\n}\nexport interface $ZodCheckStringFormatInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckStringFormatDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckStringFormat extends $ZodCheck<string> {\n    _zod: $ZodCheckStringFormatInternals;\n}\nexport declare const $ZodCheckStringFormat: core.$constructor<$ZodCheckStringFormat>;\nexport interface $ZodCheckRegexDef extends $ZodCheckStringFormatDef {\n    format: \"regex\";\n    pattern: RegExp;\n}\nexport interface $ZodCheckRegexInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckRegexDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckRegex extends $ZodCheck<string> {\n    _zod: $ZodCheckRegexInternals;\n}\nexport declare const $ZodCheckRegex: core.$constructor<$ZodCheckRegex>;\nexport interface $ZodCheckLowerCaseDef extends $ZodCheckStringFormatDef<\"lowercase\"> {\n}\nexport interface $ZodCheckLowerCaseInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckLowerCaseDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckLowerCase extends $ZodCheck<string> {\n    _zod: $ZodCheckLowerCaseInternals;\n}\nexport declare const $ZodCheckLowerCase: core.$constructor<$ZodCheckLowerCase>;\nexport interface $ZodCheckUpperCaseDef extends $ZodCheckStringFormatDef<\"uppercase\"> {\n}\nexport interface $ZodCheckUpperCaseInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckUpperCaseDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckUpperCase extends $ZodCheck<string> {\n    _zod: $ZodCheckUpperCaseInternals;\n}\nexport declare const $ZodCheckUpperCase: core.$constructor<$ZodCheckUpperCase>;\nexport interface $ZodCheckIncludesDef extends $ZodCheckStringFormatDef<\"includes\"> {\n    includes: string;\n    position?: number | undefined;\n}\nexport interface $ZodCheckIncludesInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckIncludesDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckIncludes extends $ZodCheck<string> {\n    _zod: $ZodCheckIncludesInternals;\n}\nexport declare const $ZodCheckIncludes: core.$constructor<$ZodCheckIncludes>;\nexport interface $ZodCheckStartsWithDef extends $ZodCheckStringFormatDef<\"starts_with\"> {\n    prefix: string;\n}\nexport interface $ZodCheckStartsWithInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckStartsWithDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckStartsWith extends $ZodCheck<string> {\n    _zod: $ZodCheckStartsWithInternals;\n}\nexport declare const $ZodCheckStartsWith: core.$constructor<$ZodCheckStartsWith>;\nexport interface $ZodCheckEndsWithDef extends $ZodCheckStringFormatDef<\"ends_with\"> {\n    suffix: string;\n}\nexport interface $ZodCheckEndsWithInternals extends $ZodCheckInternals<string> {\n    def: $ZodCheckEndsWithDef;\n    issc: errors.$ZodIssueInvalidStringFormat;\n}\nexport interface $ZodCheckEndsWith extends $ZodCheckInternals<string> {\n    _zod: $ZodCheckEndsWithInternals;\n}\nexport declare const $ZodCheckEndsWith: core.$constructor<$ZodCheckEndsWith>;\nexport interface $ZodCheckPropertyDef extends $ZodCheckDef {\n    check: \"property\";\n    property: string;\n    schema: schemas.$ZodType;\n}\nexport interface $ZodCheckPropertyInternals<T extends object = object> extends $ZodCheckInternals<T> {\n    def: $ZodCheckPropertyDef;\n    issc: errors.$ZodIssue;\n}\nexport interface $ZodCheckProperty<T extends object = object> extends $ZodCheck<T> {\n    _zod: $ZodCheckPropertyInternals<T>;\n}\nexport declare const $ZodCheckProperty: core.$constructor<$ZodCheckProperty>;\nexport interface $ZodCheckMimeTypeDef extends $ZodCheckDef {\n    check: \"mime_type\";\n    mime: util.MimeTypes[];\n}\nexport interface $ZodCheckMimeTypeInternals<T extends schemas.File = schemas.File> extends $ZodCheckInternals<T> {\n    def: $ZodCheckMimeTypeDef;\n    issc: errors.$ZodIssueInvalidValue;\n}\nexport interface $ZodCheckMimeType<T extends schemas.File = schemas.File> extends $ZodCheck<T> {\n    _zod: $ZodCheckMimeTypeInternals<T>;\n}\nexport declare const $ZodCheckMimeType: core.$constructor<$ZodCheckMimeType>;\nexport interface $ZodCheckOverwriteDef<T = unknown> extends $ZodCheckDef {\n    check: \"overwrite\";\n    tx(value: T): T;\n}\nexport interface $ZodCheckOverwriteInternals<T = unknown> extends $ZodCheckInternals<T> {\n    def: $ZodCheckOverwriteDef<T>;\n    issc: never;\n}\nexport interface $ZodCheckOverwrite<T = unknown> extends $ZodCheck<T> {\n    _zod: $ZodCheckOverwriteInternals<T>;\n}\nexport declare const $ZodCheckOverwrite: core.$constructor<$ZodCheckOverwrite>;\nexport type $ZodChecks = $ZodCheckLessThan | $ZodCheckGreaterThan | $ZodCheckMultipleOf | $ZodCheckNumberFormat | $ZodCheckBigIntFormat | $ZodCheckMaxSize | $ZodCheckMinSize | $ZodCheckSizeEquals | $ZodCheckMaxLength | $ZodCheckMinLength | $ZodCheckLengthEquals | $ZodCheckStringFormat | $ZodCheckProperty | $ZodCheckMimeType | $ZodCheckOverwrite;\nexport type $ZodStringFormatChecks = $ZodCheckRegex | $ZodCheckLowerCase | $ZodCheckUpperCase | $ZodCheckIncludes | $ZodCheckStartsWith | $ZodCheckEndsWith | schemas.$ZodStringFormatTypes;\n",
+	"file:///node_modules/zod/v4/core/core.d.ts": "import type * as errors from \"./errors.js\";\nimport type * as schemas from \"./schemas.js\";\nimport type { Class } from \"./util.js\";\ntype ZodTrait = {\n    _zod: {\n        def: any;\n        [k: string]: any;\n    };\n};\nexport interface $constructor<T extends ZodTrait, D = T[\"_zod\"][\"def\"]> {\n    new (def: D): T;\n    init(inst: T, def: D): asserts inst is T;\n}\n/** A special constant with type `never` */\nexport declare const NEVER: never;\nexport declare function $constructor<T extends ZodTrait, D = T[\"_zod\"][\"def\"]>(name: string, initializer: (inst: T, def: D) => void, params?: {\n    Parent?: typeof Class;\n}): $constructor<T, D>;\nexport declare const $brand: unique symbol;\nexport type $brand<T extends string | number | symbol = string | number | symbol> = {\n    [$brand]: {\n        [k in T]: true;\n    };\n};\nexport type $ZodBranded<T extends schemas.SomeType, Brand extends string | number | symbol, Dir extends \"in\" | \"out\" | \"inout\" = \"out\"> = T & (Dir extends \"inout\" ? {\n    _zod: {\n        input: input<T> & $brand<Brand>;\n        output: output<T> & $brand<Brand>;\n    };\n} : Dir extends \"in\" ? {\n    _zod: {\n        input: input<T> & $brand<Brand>;\n    };\n} : {\n    _zod: {\n        output: output<T> & $brand<Brand>;\n    };\n});\nexport type $ZodNarrow<T extends schemas.SomeType, Out> = T & {\n    _zod: {\n        output: Out;\n    };\n};\nexport declare class $ZodAsyncError extends Error {\n    constructor();\n}\nexport declare class $ZodEncodeError extends Error {\n    constructor(name: string);\n}\nexport type input<T> = T extends {\n    _zod: {\n        input: any;\n    };\n} ? T[\"_zod\"][\"input\"] : unknown;\nexport type output<T> = T extends {\n    _zod: {\n        output: any;\n    };\n} ? T[\"_zod\"][\"output\"] : unknown;\nexport type { output as infer };\nexport interface $ZodConfig {\n    /** Custom error map. Overrides `config().localeError`. */\n    customError?: errors.$ZodErrorMap | undefined;\n    /** Localized error map. Lowest priority. */\n    localeError?: errors.$ZodErrorMap | undefined;\n    /** Disable JIT schema compilation. Useful in environments that disallow `eval`. */\n    jitless?: boolean | undefined;\n}\nexport declare const globalConfig: $ZodConfig;\nexport declare function config(newConfig?: Partial<$ZodConfig>): $ZodConfig;\n",
+	"file:///node_modules/zod/v4/core/doc.d.ts": "type ModeWriter = (doc: Doc, modes: {\n    execution: \"sync\" | \"async\";\n}) => void;\nexport declare class Doc {\n    args: string[];\n    content: string[];\n    indent: number;\n    constructor(args?: string[]);\n    indented(fn: (doc: Doc) => void): void;\n    write(fn: ModeWriter): void;\n    write(line: string): void;\n    compile(): any;\n}\nexport {};\n",
+	"file:///node_modules/zod/v4/core/errors.d.ts": "import type { $ZodCheck, $ZodStringFormats } from \"./checks.js\";\nimport { $constructor } from \"./core.js\";\nimport type { $ZodType } from \"./schemas.js\";\nimport type { StandardSchemaV1 } from \"./standard-schema.js\";\nimport * as util from \"./util.js\";\nexport interface $ZodIssueBase {\n    readonly code?: string;\n    readonly input?: unknown;\n    readonly path: PropertyKey[];\n    readonly message: string;\n}\nexport type $ZodInvalidTypeExpected = \"string\" | \"number\" | \"int\" | \"boolean\" | \"bigint\" | \"symbol\" | \"undefined\" | \"null\" | \"never\" | \"void\" | \"date\" | \"array\" | \"object\" | \"tuple\" | \"record\" | \"map\" | \"set\" | \"file\" | \"nonoptional\" | \"nan\" | \"function\" | (string & {});\nexport interface $ZodIssueInvalidType<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"invalid_type\";\n    readonly expected: $ZodInvalidTypeExpected;\n    readonly input?: Input;\n}\nexport interface $ZodIssueTooBig<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"too_big\";\n    readonly origin: \"number\" | \"int\" | \"bigint\" | \"date\" | \"string\" | \"array\" | \"set\" | \"file\" | (string & {});\n    readonly maximum: number | bigint;\n    readonly inclusive?: boolean;\n    readonly exact?: boolean;\n    readonly input?: Input;\n}\nexport interface $ZodIssueTooSmall<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"too_small\";\n    readonly origin: \"number\" | \"int\" | \"bigint\" | \"date\" | \"string\" | \"array\" | \"set\" | \"file\" | (string & {});\n    readonly minimum: number | bigint;\n    /** True if the allowable range includes the minimum */\n    readonly inclusive?: boolean;\n    /** True if the allowed value is fixed (e.g.` z.length(5)`), not a range (`z.minLength(5)`) */\n    readonly exact?: boolean;\n    readonly input?: Input;\n}\nexport interface $ZodIssueInvalidStringFormat extends $ZodIssueBase {\n    readonly code: \"invalid_format\";\n    readonly format: $ZodStringFormats | (string & {});\n    readonly pattern?: string;\n    readonly input?: string;\n}\nexport interface $ZodIssueNotMultipleOf<Input extends number | bigint = number | bigint> extends $ZodIssueBase {\n    readonly code: \"not_multiple_of\";\n    readonly divisor: number;\n    readonly input?: Input;\n}\nexport interface $ZodIssueUnrecognizedKeys extends $ZodIssueBase {\n    readonly code: \"unrecognized_keys\";\n    readonly keys: string[];\n    readonly input?: Record<string, unknown>;\n}\ninterface $ZodIssueInvalidUnionNoMatch extends $ZodIssueBase {\n    readonly code: \"invalid_union\";\n    readonly errors: $ZodIssue[][];\n    readonly input?: unknown;\n    readonly discriminator?: string | undefined;\n    readonly inclusive?: true;\n}\ninterface $ZodIssueInvalidUnionMultipleMatch extends $ZodIssueBase {\n    readonly code: \"invalid_union\";\n    readonly errors: [];\n    readonly input?: unknown;\n    readonly discriminator?: string | undefined;\n    readonly inclusive: false;\n}\nexport type $ZodIssueInvalidUnion = $ZodIssueInvalidUnionNoMatch | $ZodIssueInvalidUnionMultipleMatch;\nexport interface $ZodIssueInvalidKey<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"invalid_key\";\n    readonly origin: \"map\" | \"record\";\n    readonly issues: $ZodIssue[];\n    readonly input?: Input;\n}\nexport interface $ZodIssueInvalidElement<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"invalid_element\";\n    readonly origin: \"map\" | \"set\";\n    readonly key: unknown;\n    readonly issues: $ZodIssue[];\n    readonly input?: Input;\n}\nexport interface $ZodIssueInvalidValue<Input = unknown> extends $ZodIssueBase {\n    readonly code: \"invalid_value\";\n    readonly values: util.Primitive[];\n    readonly input?: Input;\n}\nexport interface $ZodIssueCustom extends $ZodIssueBase {\n    readonly code: \"custom\";\n    readonly params?: Record<string, any> | undefined;\n    readonly input?: unknown;\n}\nexport interface $ZodIssueStringCommonFormats extends $ZodIssueInvalidStringFormat {\n    format: Exclude<$ZodStringFormats, \"regex\" | \"jwt\" | \"starts_with\" | \"ends_with\" | \"includes\">;\n}\nexport interface $ZodIssueStringInvalidRegex extends $ZodIssueInvalidStringFormat {\n    format: \"regex\";\n    pattern: string;\n}\nexport interface $ZodIssueStringInvalidJWT extends $ZodIssueInvalidStringFormat {\n    format: \"jwt\";\n    algorithm?: string;\n}\nexport interface $ZodIssueStringStartsWith extends $ZodIssueInvalidStringFormat {\n    format: \"starts_with\";\n    prefix: string;\n}\nexport interface $ZodIssueStringEndsWith extends $ZodIssueInvalidStringFormat {\n    format: \"ends_with\";\n    suffix: string;\n}\nexport interface $ZodIssueStringIncludes extends $ZodIssueInvalidStringFormat {\n    format: \"includes\";\n    includes: string;\n}\nexport type $ZodStringFormatIssues = $ZodIssueStringCommonFormats | $ZodIssueStringInvalidRegex | $ZodIssueStringInvalidJWT | $ZodIssueStringStartsWith | $ZodIssueStringEndsWith | $ZodIssueStringIncludes;\nexport type $ZodIssue = $ZodIssueInvalidType | $ZodIssueTooBig | $ZodIssueTooSmall | $ZodIssueInvalidStringFormat | $ZodIssueNotMultipleOf | $ZodIssueUnrecognizedKeys | $ZodIssueInvalidUnion | $ZodIssueInvalidKey | $ZodIssueInvalidElement | $ZodIssueInvalidValue | $ZodIssueCustom;\nexport type $ZodIssueCode = $ZodIssue[\"code\"];\nexport type $ZodInternalIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;\ntype RawIssue<T extends $ZodIssueBase> = T extends any ? util.Flatten<util.MakePartial<T, \"message\" | \"path\"> & {\n    /** The input data */\n    readonly input: unknown;\n    /** The schema or check that originated this issue. */\n    readonly inst?: $ZodType | $ZodCheck;\n    /** If `true`, Zod will continue executing checks/refinements after this issue. */\n    readonly continue?: boolean | undefined;\n} & Record<string, unknown>> : never;\nexport type $ZodRawIssue<T extends $ZodIssueBase = $ZodIssue> = $ZodInternalIssue<T>;\nexport interface $ZodErrorMap<T extends $ZodIssueBase = $ZodIssue> {\n    (issue: $ZodRawIssue<T>): {\n        message: string;\n    } | string | undefined | null;\n}\nexport interface $ZodError<T = unknown> extends Error {\n    type: T;\n    issues: $ZodIssue[];\n    _zod: {\n        output: T;\n        def: $ZodIssue[];\n    };\n    stack?: string;\n    name: string;\n}\nexport declare const $ZodError: $constructor<$ZodError>;\ninterface $ZodRealError<T = any> extends $ZodError<T> {\n}\nexport declare const $ZodRealError: $constructor<$ZodRealError>;\nexport type $ZodFlattenedError<T, U = string> = _FlattenedError<T, U>;\ntype _FlattenedError<T, U = string> = {\n    formErrors: U[];\n    fieldErrors: {\n        [P in keyof T]?: U[];\n    };\n};\nexport declare function flattenError<T>(error: $ZodError<T>): _FlattenedError<T>;\nexport declare function flattenError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): _FlattenedError<T, U>;\ntype _ZodFormattedError<T, U = string> = T extends [any, ...any[]] ? {\n    [K in keyof T]?: $ZodFormattedError<T[K], U>;\n} : T extends any[] ? {\n    [k: number]: $ZodFormattedError<T[number], U>;\n} : T extends object ? util.Flatten<{\n    [K in keyof T]?: $ZodFormattedError<T[K], U>;\n}> : any;\nexport type $ZodFormattedError<T, U = string> = {\n    _errors: U[];\n} & util.Flatten<_ZodFormattedError<T, U>>;\nexport declare function formatError<T>(error: $ZodError<T>): $ZodFormattedError<T>;\nexport declare function formatError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;\nexport type $ZodErrorTree<T, U = string> = T extends util.Primitive ? {\n    errors: U[];\n} : T extends [any, ...any[]] ? {\n    errors: U[];\n    items?: {\n        [K in keyof T]?: $ZodErrorTree<T[K], U>;\n    };\n} : T extends any[] ? {\n    errors: U[];\n    items?: Array<$ZodErrorTree<T[number], U>>;\n} : T extends object ? {\n    errors: U[];\n    properties?: {\n        [K in keyof T]?: $ZodErrorTree<T[K], U>;\n    };\n} : {\n    errors: U[];\n};\nexport declare function treeifyError<T>(error: $ZodError<T>): $ZodErrorTree<T>;\nexport declare function treeifyError<T, U>(error: $ZodError<T>, mapper?: (issue: $ZodIssue) => U): $ZodErrorTree<T, U>;\n/** Format a ZodError as a human-readable string in the following form.\n *\n * From\n *\n * ```ts\n * ZodError {\n *   issues: [\n *     {\n *       expected: 'string',\n *       code: 'invalid_type',\n *       path: [ 'username' ],\n *       message: 'Invalid input: expected string'\n *     },\n *     {\n *       expected: 'number',\n *       code: 'invalid_type',\n *       path: [ 'favoriteNumbers', 1 ],\n *       message: 'Invalid input: expected number'\n *     }\n *   ];\n * }\n * ```\n *\n * to\n *\n * ```\n * username\n *   ✖ Expected number, received string at \"username\n * favoriteNumbers[0]\n *   ✖ Invalid input: expected number\n * ```\n */\nexport declare function toDotPath(_path: readonly (string | number | symbol | StandardSchemaV1.PathSegment)[]): string;\nexport declare function prettifyError(error: StandardSchemaV1.FailureResult): string;\nexport {};\n",
+	"file:///node_modules/zod/v4/core/index.d.ts": "export * from \"./core.js\";\nexport * from \"./parse.js\";\nexport * from \"./errors.js\";\nexport * from \"./schemas.js\";\nexport * from \"./checks.js\";\nexport * from \"./versions.js\";\nexport * as util from \"./util.js\";\nexport * as regexes from \"./regexes.js\";\nexport * as locales from \"../locales/index.js\";\nexport * from \"./registries.js\";\nexport * from \"./doc.js\";\nexport * from \"./api.js\";\nexport * from \"./to-json-schema.js\";\nexport { toJSONSchema } from \"./json-schema-processors.js\";\nexport { JSONSchemaGenerator } from \"./json-schema-generator.js\";\nexport * as JSONSchema from \"./json-schema.js\";\n",
+	"file:///node_modules/zod/v4/core/json-schema-generator.d.ts": "import type * as JSONSchema from \"./json-schema.js\";\nimport type { $ZodRegistry } from \"./registries.js\";\nimport type * as schemas from \"./schemas.js\";\nimport { type JSONSchemaGeneratorParams, type ProcessParams, type Seen } from \"./to-json-schema.js\";\n/**\n * Parameters for the emit method of JSONSchemaGenerator.\n * @deprecated Use toJSONSchema function instead\n */\nexport type EmitParams = Pick<JSONSchemaGeneratorParams, \"cycles\" | \"reused\" | \"external\">;\n/**\n * Parameters for JSONSchemaGenerator constructor.\n * @deprecated Use toJSONSchema function instead\n */\ntype JSONSchemaGeneratorConstructorParams = Pick<JSONSchemaGeneratorParams, \"metadata\" | \"target\" | \"unrepresentable\" | \"override\" | \"io\">;\n/**\n * Legacy class-based interface for JSON Schema generation.\n * This class wraps the new functional implementation to provide backward compatibility.\n *\n * @deprecated Use the `toJSONSchema` function instead for new code.\n *\n * @example\n * ```typescript\n * // Legacy usage (still supported)\n * const gen = new JSONSchemaGenerator({ target: \"draft-07\" });\n * gen.process(schema);\n * const result = gen.emit(schema);\n *\n * // Preferred modern usage\n * const result = toJSONSchema(schema, { target: \"draft-07\" });\n * ```\n */\nexport declare class JSONSchemaGenerator {\n    private ctx;\n    /** @deprecated Access via ctx instead */\n    get metadataRegistry(): $ZodRegistry<Record<string, any>>;\n    /** @deprecated Access via ctx instead */\n    get target(): ({} & string) | \"draft-2020-12\" | \"draft-07\" | \"openapi-3.0\" | \"draft-04\";\n    /** @deprecated Access via ctx instead */\n    get unrepresentable(): \"any\" | \"throw\";\n    /** @deprecated Access via ctx instead */\n    get override(): (ctx: {\n        zodSchema: schemas.$ZodType;\n        jsonSchema: JSONSchema.BaseSchema;\n        path: (string | number)[];\n    }) => void;\n    /** @deprecated Access via ctx instead */\n    get io(): \"input\" | \"output\";\n    /** @deprecated Access via ctx instead */\n    get counter(): number;\n    set counter(value: number);\n    /** @deprecated Access via ctx instead */\n    get seen(): Map<schemas.$ZodType, Seen>;\n    constructor(params?: JSONSchemaGeneratorConstructorParams);\n    /**\n     * Process a schema to prepare it for JSON Schema generation.\n     * This must be called before emit().\n     */\n    process(schema: schemas.$ZodType, _params?: ProcessParams): JSONSchema.BaseSchema;\n    /**\n     * Emit the final JSON Schema after processing.\n     * Must call process() first.\n     */\n    emit(schema: schemas.$ZodType, _params?: EmitParams): JSONSchema.BaseSchema;\n}\nexport {};\n",
+	"file:///node_modules/zod/v4/core/json-schema-processors.d.ts": "import type { $ZodRegistry } from \"./registries.js\";\nimport type * as schemas from \"./schemas.js\";\nimport { type Processor, type RegistryToJSONSchemaParams, type ToJSONSchemaParams, type ZodStandardJSONSchemaPayload } from \"./to-json-schema.js\";\nexport declare const stringProcessor: Processor<schemas.$ZodString>;\nexport declare const numberProcessor: Processor<schemas.$ZodNumber>;\nexport declare const booleanProcessor: Processor<schemas.$ZodBoolean>;\nexport declare const bigintProcessor: Processor<schemas.$ZodBigInt>;\nexport declare const symbolProcessor: Processor<schemas.$ZodSymbol>;\nexport declare const nullProcessor: Processor<schemas.$ZodNull>;\nexport declare const undefinedProcessor: Processor<schemas.$ZodUndefined>;\nexport declare const voidProcessor: Processor<schemas.$ZodVoid>;\nexport declare const neverProcessor: Processor<schemas.$ZodNever>;\nexport declare const anyProcessor: Processor<schemas.$ZodAny>;\nexport declare const unknownProcessor: Processor<schemas.$ZodUnknown>;\nexport declare const dateProcessor: Processor<schemas.$ZodDate>;\nexport declare const enumProcessor: Processor<schemas.$ZodEnum>;\nexport declare const literalProcessor: Processor<schemas.$ZodLiteral>;\nexport declare const nanProcessor: Processor<schemas.$ZodNaN>;\nexport declare const templateLiteralProcessor: Processor<schemas.$ZodTemplateLiteral>;\nexport declare const fileProcessor: Processor<schemas.$ZodFile>;\nexport declare const successProcessor: Processor<schemas.$ZodSuccess>;\nexport declare const customProcessor: Processor<schemas.$ZodCustom>;\nexport declare const functionProcessor: Processor<schemas.$ZodFunction>;\nexport declare const transformProcessor: Processor<schemas.$ZodTransform>;\nexport declare const mapProcessor: Processor<schemas.$ZodMap>;\nexport declare const setProcessor: Processor<schemas.$ZodSet>;\nexport declare const arrayProcessor: Processor<schemas.$ZodArray>;\nexport declare const objectProcessor: Processor<schemas.$ZodObject>;\nexport declare const unionProcessor: Processor<schemas.$ZodUnion>;\nexport declare const intersectionProcessor: Processor<schemas.$ZodIntersection>;\nexport declare const tupleProcessor: Processor<schemas.$ZodTuple>;\nexport declare const recordProcessor: Processor<schemas.$ZodRecord>;\nexport declare const nullableProcessor: Processor<schemas.$ZodNullable>;\nexport declare const nonoptionalProcessor: Processor<schemas.$ZodNonOptional>;\nexport declare const defaultProcessor: Processor<schemas.$ZodDefault>;\nexport declare const prefaultProcessor: Processor<schemas.$ZodPrefault>;\nexport declare const catchProcessor: Processor<schemas.$ZodCatch>;\nexport declare const pipeProcessor: Processor<schemas.$ZodPipe>;\nexport declare const readonlyProcessor: Processor<schemas.$ZodReadonly>;\nexport declare const promiseProcessor: Processor<schemas.$ZodPromise>;\nexport declare const optionalProcessor: Processor<schemas.$ZodOptional>;\nexport declare const lazyProcessor: Processor<schemas.$ZodLazy>;\nexport declare const allProcessors: Record<string, Processor<any>>;\nexport declare function toJSONSchema<T extends schemas.$ZodType>(schema: T, params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<T>;\nexport declare function toJSONSchema(registry: $ZodRegistry<{\n    id?: string | undefined;\n}>, params?: RegistryToJSONSchemaParams): {\n    schemas: Record<string, ZodStandardJSONSchemaPayload<schemas.$ZodType>>;\n};\n",
+	"file:///node_modules/zod/v4/core/json-schema.d.ts": "export type Schema = ObjectSchema | ArraySchema | StringSchema | NumberSchema | IntegerSchema | BooleanSchema | NullSchema;\nexport type _JSONSchema = boolean | JSONSchema;\nexport type JSONSchema = {\n    [k: string]: unknown;\n    $schema?: \"https://json-schema.org/draft/2020-12/schema\" | \"http://json-schema.org/draft-07/schema#\" | \"http://json-schema.org/draft-04/schema#\";\n    $id?: string;\n    $anchor?: string;\n    $ref?: string;\n    $dynamicRef?: string;\n    $dynamicAnchor?: string;\n    $vocabulary?: Record<string, boolean>;\n    $comment?: string;\n    $defs?: Record<string, JSONSchema>;\n    type?: \"object\" | \"array\" | \"string\" | \"number\" | \"boolean\" | \"null\" | \"integer\";\n    additionalItems?: _JSONSchema;\n    unevaluatedItems?: _JSONSchema;\n    prefixItems?: _JSONSchema[];\n    items?: _JSONSchema | _JSONSchema[];\n    contains?: _JSONSchema;\n    additionalProperties?: _JSONSchema;\n    unevaluatedProperties?: _JSONSchema;\n    properties?: Record<string, _JSONSchema>;\n    patternProperties?: Record<string, _JSONSchema>;\n    dependentSchemas?: Record<string, _JSONSchema>;\n    propertyNames?: _JSONSchema;\n    if?: _JSONSchema;\n    then?: _JSONSchema;\n    else?: _JSONSchema;\n    allOf?: JSONSchema[];\n    anyOf?: JSONSchema[];\n    oneOf?: JSONSchema[];\n    not?: _JSONSchema;\n    multipleOf?: number;\n    maximum?: number;\n    exclusiveMaximum?: number | boolean;\n    minimum?: number;\n    exclusiveMinimum?: number | boolean;\n    maxLength?: number;\n    minLength?: number;\n    pattern?: string;\n    maxItems?: number;\n    minItems?: number;\n    uniqueItems?: boolean;\n    maxContains?: number;\n    minContains?: number;\n    maxProperties?: number;\n    minProperties?: number;\n    required?: string[];\n    dependentRequired?: Record<string, string[]>;\n    enum?: Array<string | number | boolean | null>;\n    const?: string | number | boolean | null;\n    id?: string;\n    title?: string;\n    description?: string;\n    default?: unknown;\n    deprecated?: boolean;\n    readOnly?: boolean;\n    writeOnly?: boolean;\n    nullable?: boolean;\n    examples?: unknown[];\n    format?: string;\n    contentMediaType?: string;\n    contentEncoding?: string;\n    contentSchema?: JSONSchema;\n    _prefault?: unknown;\n};\nexport type BaseSchema = JSONSchema;\nexport interface ObjectSchema extends JSONSchema {\n    type: \"object\";\n}\nexport interface ArraySchema extends JSONSchema {\n    type: \"array\";\n}\nexport interface StringSchema extends JSONSchema {\n    type: \"string\";\n}\nexport interface NumberSchema extends JSONSchema {\n    type: \"number\";\n}\nexport interface IntegerSchema extends JSONSchema {\n    type: \"integer\";\n}\nexport interface BooleanSchema extends JSONSchema {\n    type: \"boolean\";\n}\nexport interface NullSchema extends JSONSchema {\n    type: \"null\";\n}\n",
+	"file:///node_modules/zod/v4/core/parse.d.ts": "import * as core from \"./core.js\";\nimport * as errors from \"./errors.js\";\nimport type * as schemas from \"./schemas.js\";\nimport * as util from \"./util.js\";\nexport type $ZodErrorClass = {\n    new (issues: errors.$ZodIssue[]): errors.$ZodError;\n};\nexport type $Parse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {\n    callee?: util.AnyFunc;\n    Err?: $ZodErrorClass;\n}) => core.output<T>;\nexport declare const _parse: (_Err: $ZodErrorClass) => $Parse;\nexport declare const parse: $Parse;\nexport type $ParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>, _params?: {\n    callee?: util.AnyFunc;\n    Err?: $ZodErrorClass;\n}) => Promise<core.output<T>>;\nexport declare const _parseAsync: (_Err: $ZodErrorClass) => $ParseAsync;\nexport declare const parseAsync: $ParseAsync;\nexport type $SafeParse = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;\nexport declare const _safeParse: (_Err: $ZodErrorClass) => $SafeParse;\nexport declare const safeParse: $SafeParse;\nexport type $SafeParseAsync = <T extends schemas.$ZodType>(schema: T, value: unknown, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;\nexport declare const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync;\nexport declare const safeParseAsync: $SafeParseAsync;\nexport type $Encode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.input<T>;\nexport declare const _encode: (_Err: $ZodErrorClass) => $Encode;\nexport declare const encode: $Encode;\nexport type $Decode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => core.output<T>;\nexport declare const _decode: (_Err: $ZodErrorClass) => $Decode;\nexport declare const decode: $Decode;\nexport type $EncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.input<T>>;\nexport declare const _encodeAsync: (_Err: $ZodErrorClass) => $EncodeAsync;\nexport declare const encodeAsync: $EncodeAsync;\nexport type $DecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<core.output<T>>;\nexport declare const _decodeAsync: (_Err: $ZodErrorClass) => $DecodeAsync;\nexport declare const decodeAsync: $DecodeAsync;\nexport type $SafeEncode = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.input<T>>;\nexport declare const _safeEncode: (_Err: $ZodErrorClass) => $SafeEncode;\nexport declare const safeEncode: $SafeEncode;\nexport type $SafeDecode = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => util.SafeParseResult<core.output<T>>;\nexport declare const _safeDecode: (_Err: $ZodErrorClass) => $SafeDecode;\nexport declare const safeDecode: $SafeDecode;\nexport type $SafeEncodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.output<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.input<T>>>;\nexport declare const _safeEncodeAsync: (_Err: $ZodErrorClass) => $SafeEncodeAsync;\nexport declare const safeEncodeAsync: $SafeEncodeAsync;\nexport type $SafeDecodeAsync = <T extends schemas.$ZodType>(schema: T, value: core.input<T>, _ctx?: schemas.ParseContext<errors.$ZodIssue>) => Promise<util.SafeParseResult<core.output<T>>>;\nexport declare const _safeDecodeAsync: (_Err: $ZodErrorClass) => $SafeDecodeAsync;\nexport declare const safeDecodeAsync: $SafeDecodeAsync;\n",
+	"file:///node_modules/zod/v4/core/regexes.d.ts": "export declare const cuid: RegExp;\nexport declare const cuid2: RegExp;\nexport declare const ulid: RegExp;\nexport declare const xid: RegExp;\nexport declare const ksuid: RegExp;\nexport declare const nanoid: RegExp;\n/** ISO 8601-1 duration regex. Does not support the 8601-2 extensions like negative durations or fractional/negative components. */\nexport declare const duration: RegExp;\n/** Implements ISO 8601-2 extensions like explicit +- prefixes, mixing weeks with other units, and fractional/negative components. */\nexport declare const extendedDuration: RegExp;\n/** A regex for any UUID-like identifier: 8-4-4-4-12 hex pattern */\nexport declare const guid: RegExp;\n/** Returns a regex for validating an RFC 9562/4122 UUID.\n *\n * @param version Optionally specify a version 1-8. If no version is specified, all versions are supported. */\nexport declare const uuid: (version?: number | undefined) => RegExp;\nexport declare const uuid4: RegExp;\nexport declare const uuid6: RegExp;\nexport declare const uuid7: RegExp;\n/** Practical email validation */\nexport declare const email: RegExp;\n/** Equivalent to the HTML5 input[type=email] validation implemented by browsers. Source: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/email */\nexport declare const html5Email: RegExp;\n/** The classic emailregex.com regex for RFC 5322-compliant emails */\nexport declare const rfc5322Email: RegExp;\n/** A loose regex that allows Unicode characters, enforces length limits, and that's about it. */\nexport declare const unicodeEmail: RegExp;\nexport declare const idnEmail: RegExp;\nexport declare const browserEmail: RegExp;\nexport declare function emoji(): RegExp;\nexport declare const ipv4: RegExp;\nexport declare const ipv6: RegExp;\nexport declare const mac: (delimiter?: string) => RegExp;\nexport declare const cidrv4: RegExp;\nexport declare const cidrv6: RegExp;\nexport declare const base64: RegExp;\nexport declare const base64url: RegExp;\nexport declare const hostname: RegExp;\nexport declare const domain: RegExp;\nexport declare const e164: RegExp;\nexport declare const date: RegExp;\nexport declare function time(args: {\n    precision?: number | null;\n}): RegExp;\nexport declare function datetime(args: {\n    precision?: number | null;\n    offset?: boolean;\n    local?: boolean;\n}): RegExp;\nexport declare const string: (params?: {\n    minimum?: number | undefined;\n    maximum?: number | undefined;\n}) => RegExp;\nexport declare const bigint: RegExp;\nexport declare const integer: RegExp;\nexport declare const number: RegExp;\nexport declare const boolean: RegExp;\ndeclare const _null: RegExp;\nexport { _null as null };\ndeclare const _undefined: RegExp;\nexport { _undefined as undefined };\nexport declare const lowercase: RegExp;\nexport declare const uppercase: RegExp;\nexport declare const hex: RegExp;\nexport declare const md5_hex: RegExp;\nexport declare const md5_base64: RegExp;\nexport declare const md5_base64url: RegExp;\nexport declare const sha1_hex: RegExp;\nexport declare const sha1_base64: RegExp;\nexport declare const sha1_base64url: RegExp;\nexport declare const sha256_hex: RegExp;\nexport declare const sha256_base64: RegExp;\nexport declare const sha256_base64url: RegExp;\nexport declare const sha384_hex: RegExp;\nexport declare const sha384_base64: RegExp;\nexport declare const sha384_base64url: RegExp;\nexport declare const sha512_hex: RegExp;\nexport declare const sha512_base64: RegExp;\nexport declare const sha512_base64url: RegExp;\n",
+	"file:///node_modules/zod/v4/core/registries.d.ts": "import type * as core from \"./core.js\";\nimport type { $ZodType } from \"./schemas.js\";\nexport declare const $output: unique symbol;\nexport type $output = typeof $output;\nexport declare const $input: unique symbol;\nexport type $input = typeof $input;\nexport type $replace<Meta, S extends $ZodType> = Meta extends $output ? core.output<S> : Meta extends $input ? core.input<S> : Meta extends (infer M)[] ? $replace<M, S>[] : Meta extends (...args: infer P) => infer R ? (...args: {\n    [K in keyof P]: $replace<P[K], S>;\n}) => $replace<R, S> : Meta extends object ? {\n    [K in keyof Meta]: $replace<Meta[K], S>;\n} : Meta;\ntype MetadataType = object | undefined;\nexport declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {\n    _meta: Meta;\n    _schema: Schema;\n    _map: WeakMap<Schema, $replace<Meta, Schema>>;\n    _idmap: Map<string, Schema>;\n    add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;\n    clear(): this;\n    remove(schema: Schema): this;\n    get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;\n    has(schema: Schema): boolean;\n}\nexport interface JSONSchemaMeta {\n    id?: string | undefined;\n    title?: string | undefined;\n    description?: string | undefined;\n    deprecated?: boolean | undefined;\n    [k: string]: unknown;\n}\nexport interface GlobalMeta extends JSONSchemaMeta {\n}\nexport declare function registry<T extends MetadataType = MetadataType, S extends $ZodType = $ZodType>(): $ZodRegistry<T, S>;\nexport declare const globalRegistry: $ZodRegistry<GlobalMeta>;\nexport {};\n",
+	"file:///node_modules/zod/v4/core/schemas.d.ts": "import * as checks from \"./checks.js\";\nimport * as core from \"./core.js\";\nimport type * as errors from \"./errors.js\";\nimport type * as JSONSchema from \"./json-schema.js\";\nimport type { StandardSchemaV1 } from \"./standard-schema.js\";\nimport type { ProcessParams, ToJSONSchemaContext } from \"./to-json-schema.js\";\nimport * as util from \"./util.js\";\nimport { version } from \"./versions.js\";\nexport interface ParseContext<T extends errors.$ZodIssueBase = never> {\n    /** Customize error messages. */\n    readonly error?: errors.$ZodErrorMap<T>;\n    /** Include the `input` field in issue objects. Default `false`. */\n    readonly reportInput?: boolean;\n    /** Skip eval-based fast path. Default `false`. */\n    readonly jitless?: boolean;\n}\n/** @internal */\nexport interface ParseContextInternal<T extends errors.$ZodIssueBase = never> extends ParseContext<T> {\n    readonly async?: boolean | undefined;\n    readonly direction?: \"forward\" | \"backward\";\n    readonly skipChecks?: boolean;\n}\nexport interface ParsePayload<T = unknown> {\n    value: T;\n    issues: errors.$ZodRawIssue[];\n    /** A may to mark a whole payload as aborted. Used in codecs/pipes. */\n    aborted?: boolean;\n}\nexport type CheckFn<T> = (input: ParsePayload<T>) => util.MaybeAsync<void>;\nexport interface $ZodTypeDef {\n    type: \"string\" | \"number\" | \"int\" | \"boolean\" | \"bigint\" | \"symbol\" | \"null\" | \"undefined\" | \"void\" | \"never\" | \"any\" | \"unknown\" | \"date\" | \"object\" | \"record\" | \"file\" | \"array\" | \"tuple\" | \"union\" | \"intersection\" | \"map\" | \"set\" | \"enum\" | \"literal\" | \"nullable\" | \"optional\" | \"nonoptional\" | \"success\" | \"transform\" | \"default\" | \"prefault\" | \"catch\" | \"nan\" | \"pipe\" | \"readonly\" | \"template_literal\" | \"promise\" | \"lazy\" | \"function\" | \"custom\";\n    error?: errors.$ZodErrorMap<never> | undefined;\n    checks?: checks.$ZodCheck<never>[];\n}\nexport interface _$ZodTypeInternals {\n    /** The `@zod/core` version of this schema */\n    version: typeof version;\n    /** Schema definition. */\n    def: $ZodTypeDef;\n    /** @internal Randomly generated ID for this schema. */\n    /** @internal List of deferred initializers. */\n    deferred: util.AnyFunc[] | undefined;\n    /** @internal Parses input and runs all checks (refinements). */\n    run(payload: ParsePayload<any>, ctx: ParseContextInternal): util.MaybeAsync<ParsePayload>;\n    /** @internal Parses input, doesn't run checks. */\n    parse(payload: ParsePayload<any>, ctx: ParseContextInternal): util.MaybeAsync<ParsePayload>;\n    /** @internal  Stores identifiers for the set of traits implemented by this schema. */\n    traits: Set<string>;\n    /** @internal Indicates that a schema output type should be considered optional inside objects.\n     * @default Required\n     */\n    /** @internal */\n    optin?: \"optional\" | undefined;\n    /** @internal */\n    optout?: \"optional\" | undefined;\n    /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().\n     *\n     * Defined on: enum, const, literal, null, undefined\n     * Passthrough: optional, nullable, branded, default, catch, pipe\n     * Todo: unions?\n     */\n    values?: util.PrimitiveSet | undefined;\n    /** Default value bubbled up from  */\n    /** @internal A set of literal discriminators used for the fast path in discriminated unions. */\n    propValues?: util.PropValues | undefined;\n    /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */\n    pattern: RegExp | undefined;\n    /** @internal The constructor function of this schema. */\n    constr: new (def: any) => $ZodType;\n    /** @internal A catchall object for bag metadata related to this schema. Commonly modified by checks using `onattach`. */\n    bag: Record<string, unknown>;\n    /** @internal The set of issues this schema might throw during type checking. */\n    isst: errors.$ZodIssueBase;\n    /** @internal Subject to change, not a public API. */\n    processJSONSchema?: ((ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams) => void) | undefined;\n    /** An optional method used to override `toJSONSchema` logic. */\n    toJSONSchema?: () => unknown;\n    /** @internal The parent of this schema. Only set during certain clone operations. */\n    parent?: $ZodType | undefined;\n}\n/** @internal */\nexport interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {\n    /** @internal The inferred output type */\n    output: O;\n    /** @internal The inferred input type */\n    input: I;\n}\nexport type $ZodStandardSchema<T> = StandardSchemaV1.Props<core.input<T>, core.output<T>>;\nexport type SomeType = {\n    _zod: _$ZodTypeInternals;\n};\nexport interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> {\n    _zod: Internals;\n    \"~standard\": $ZodStandardSchema<this>;\n}\nexport interface _$ZodType<T extends $ZodTypeInternals = $ZodTypeInternals> extends $ZodType<T[\"output\"], T[\"input\"], T> {\n}\nexport declare const $ZodType: core.$constructor<$ZodType>;\nexport { clone } from \"./util.js\";\nexport interface $ZodStringDef extends $ZodTypeDef {\n    type: \"string\";\n    coerce?: boolean;\n    checks?: checks.$ZodCheck<string>[];\n}\nexport interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, Input> {\n    def: $ZodStringDef;\n    /** @deprecated Internal API, use with caution (not deprecated) */\n    pattern: RegExp;\n    /** @deprecated Internal API, use with caution (not deprecated) */\n    isst: errors.$ZodIssueInvalidType;\n    bag: util.LoosePartial<{\n        minimum: number;\n        maximum: number;\n        patterns: Set<RegExp>;\n        format: string;\n        contentEncoding: string;\n    }>;\n}\nexport interface $ZodString<Input = unknown> extends _$ZodType<$ZodStringInternals<Input>> {\n}\nexport declare const $ZodString: core.$constructor<$ZodString>;\nexport interface $ZodStringFormatDef<Format extends string = string> extends $ZodStringDef, checks.$ZodCheckStringFormatDef<Format> {\n}\nexport interface $ZodStringFormatInternals<Format extends string = string> extends $ZodStringInternals<string>, checks.$ZodCheckStringFormatInternals {\n    def: $ZodStringFormatDef<Format>;\n}\nexport interface $ZodStringFormat<Format extends string = string> extends $ZodType {\n    _zod: $ZodStringFormatInternals<Format>;\n}\nexport declare const $ZodStringFormat: core.$constructor<$ZodStringFormat>;\nexport interface $ZodGUIDDef extends $ZodStringFormatDef<\"guid\"> {\n}\nexport interface $ZodGUIDInternals extends $ZodStringFormatInternals<\"guid\"> {\n}\nexport interface $ZodGUID extends $ZodType {\n    _zod: $ZodGUIDInternals;\n}\nexport declare const $ZodGUID: core.$constructor<$ZodGUID>;\nexport interface $ZodUUIDDef extends $ZodStringFormatDef<\"uuid\"> {\n    version?: \"v1\" | \"v2\" | \"v3\" | \"v4\" | \"v5\" | \"v6\" | \"v7\" | \"v8\";\n}\nexport interface $ZodUUIDInternals extends $ZodStringFormatInternals<\"uuid\"> {\n    def: $ZodUUIDDef;\n}\nexport interface $ZodUUID extends $ZodType {\n    _zod: $ZodUUIDInternals;\n}\nexport declare const $ZodUUID: core.$constructor<$ZodUUID>;\nexport interface $ZodEmailDef extends $ZodStringFormatDef<\"email\"> {\n}\nexport interface $ZodEmailInternals extends $ZodStringFormatInternals<\"email\"> {\n}\nexport interface $ZodEmail extends $ZodType {\n    _zod: $ZodEmailInternals;\n}\nexport declare const $ZodEmail: core.$constructor<$ZodEmail>;\nexport interface $ZodURLDef extends $ZodStringFormatDef<\"url\"> {\n    hostname?: RegExp | undefined;\n    protocol?: RegExp | undefined;\n    normalize?: boolean | undefined;\n}\nexport interface $ZodURLInternals extends $ZodStringFormatInternals<\"url\"> {\n    def: $ZodURLDef;\n}\nexport interface $ZodURL extends $ZodType {\n    _zod: $ZodURLInternals;\n}\nexport declare const $ZodURL: core.$constructor<$ZodURL>;\nexport interface $ZodEmojiDef extends $ZodStringFormatDef<\"emoji\"> {\n}\nexport interface $ZodEmojiInternals extends $ZodStringFormatInternals<\"emoji\"> {\n}\nexport interface $ZodEmoji extends $ZodType {\n    _zod: $ZodEmojiInternals;\n}\nexport declare const $ZodEmoji: core.$constructor<$ZodEmoji>;\nexport interface $ZodNanoIDDef extends $ZodStringFormatDef<\"nanoid\"> {\n}\nexport interface $ZodNanoIDInternals extends $ZodStringFormatInternals<\"nanoid\"> {\n}\nexport interface $ZodNanoID extends $ZodType {\n    _zod: $ZodNanoIDInternals;\n}\nexport declare const $ZodNanoID: core.$constructor<$ZodNanoID>;\nexport interface $ZodCUIDDef extends $ZodStringFormatDef<\"cuid\"> {\n}\nexport interface $ZodCUIDInternals extends $ZodStringFormatInternals<\"cuid\"> {\n}\nexport interface $ZodCUID extends $ZodType {\n    _zod: $ZodCUIDInternals;\n}\nexport declare const $ZodCUID: core.$constructor<$ZodCUID>;\nexport interface $ZodCUID2Def extends $ZodStringFormatDef<\"cuid2\"> {\n}\nexport interface $ZodCUID2Internals extends $ZodStringFormatInternals<\"cuid2\"> {\n}\nexport interface $ZodCUID2 extends $ZodType {\n    _zod: $ZodCUID2Internals;\n}\nexport declare const $ZodCUID2: core.$constructor<$ZodCUID2>;\nexport interface $ZodULIDDef extends $ZodStringFormatDef<\"ulid\"> {\n}\nexport interface $ZodULIDInternals extends $ZodStringFormatInternals<\"ulid\"> {\n}\nexport interface $ZodULID extends $ZodType {\n    _zod: $ZodULIDInternals;\n}\nexport declare const $ZodULID: core.$constructor<$ZodULID>;\nexport interface $ZodXIDDef extends $ZodStringFormatDef<\"xid\"> {\n}\nexport interface $ZodXIDInternals extends $ZodStringFormatInternals<\"xid\"> {\n}\nexport interface $ZodXID extends $ZodType {\n    _zod: $ZodXIDInternals;\n}\nexport declare const $ZodXID: core.$constructor<$ZodXID>;\nexport interface $ZodKSUIDDef extends $ZodStringFormatDef<\"ksuid\"> {\n}\nexport interface $ZodKSUIDInternals extends $ZodStringFormatInternals<\"ksuid\"> {\n}\nexport interface $ZodKSUID extends $ZodType {\n    _zod: $ZodKSUIDInternals;\n}\nexport declare const $ZodKSUID: core.$constructor<$ZodKSUID>;\nexport interface $ZodISODateTimeDef extends $ZodStringFormatDef<\"datetime\"> {\n    precision: number | null;\n    offset: boolean;\n    local: boolean;\n}\nexport interface $ZodISODateTimeInternals extends $ZodStringFormatInternals {\n    def: $ZodISODateTimeDef;\n}\nexport interface $ZodISODateTime extends $ZodType {\n    _zod: $ZodISODateTimeInternals;\n}\nexport declare const $ZodISODateTime: core.$constructor<$ZodISODateTime>;\nexport interface $ZodISODateDef extends $ZodStringFormatDef<\"date\"> {\n}\nexport interface $ZodISODateInternals extends $ZodStringFormatInternals<\"date\"> {\n}\nexport interface $ZodISODate extends $ZodType {\n    _zod: $ZodISODateInternals;\n}\nexport declare const $ZodISODate: core.$constructor<$ZodISODate>;\nexport interface $ZodISOTimeDef extends $ZodStringFormatDef<\"time\"> {\n    precision?: number | null;\n}\nexport interface $ZodISOTimeInternals extends $ZodStringFormatInternals<\"time\"> {\n    def: $ZodISOTimeDef;\n}\nexport interface $ZodISOTime extends $ZodType {\n    _zod: $ZodISOTimeInternals;\n}\nexport declare const $ZodISOTime: core.$constructor<$ZodISOTime>;\nexport interface $ZodISODurationDef extends $ZodStringFormatDef<\"duration\"> {\n}\nexport interface $ZodISODurationInternals extends $ZodStringFormatInternals<\"duration\"> {\n}\nexport interface $ZodISODuration extends $ZodType {\n    _zod: $ZodISODurationInternals;\n}\nexport declare const $ZodISODuration: core.$constructor<$ZodISODuration>;\nexport interface $ZodIPv4Def extends $ZodStringFormatDef<\"ipv4\"> {\n    version?: \"v4\";\n}\nexport interface $ZodIPv4Internals extends $ZodStringFormatInternals<\"ipv4\"> {\n    def: $ZodIPv4Def;\n}\nexport interface $ZodIPv4 extends $ZodType {\n    _zod: $ZodIPv4Internals;\n}\nexport declare const $ZodIPv4: core.$constructor<$ZodIPv4>;\nexport interface $ZodIPv6Def extends $ZodStringFormatDef<\"ipv6\"> {\n    version?: \"v6\";\n}\nexport interface $ZodIPv6Internals extends $ZodStringFormatInternals<\"ipv6\"> {\n    def: $ZodIPv6Def;\n}\nexport interface $ZodIPv6 extends $ZodType {\n    _zod: $ZodIPv6Internals;\n}\nexport declare const $ZodIPv6: core.$constructor<$ZodIPv6>;\nexport interface $ZodMACDef extends $ZodStringFormatDef<\"mac\"> {\n    delimiter?: string;\n}\nexport interface $ZodMACInternals extends $ZodStringFormatInternals<\"mac\"> {\n    def: $ZodMACDef;\n}\nexport interface $ZodMAC extends $ZodType {\n    _zod: $ZodMACInternals;\n}\nexport declare const $ZodMAC: core.$constructor<$ZodMAC>;\nexport interface $ZodCIDRv4Def extends $ZodStringFormatDef<\"cidrv4\"> {\n    version?: \"v4\";\n}\nexport interface $ZodCIDRv4Internals extends $ZodStringFormatInternals<\"cidrv4\"> {\n    def: $ZodCIDRv4Def;\n}\nexport interface $ZodCIDRv4 extends $ZodType {\n    _zod: $ZodCIDRv4Internals;\n}\nexport declare const $ZodCIDRv4: core.$constructor<$ZodCIDRv4>;\nexport interface $ZodCIDRv6Def extends $ZodStringFormatDef<\"cidrv6\"> {\n    version?: \"v6\";\n}\nexport interface $ZodCIDRv6Internals extends $ZodStringFormatInternals<\"cidrv6\"> {\n    def: $ZodCIDRv6Def;\n}\nexport interface $ZodCIDRv6 extends $ZodType {\n    _zod: $ZodCIDRv6Internals;\n}\nexport declare const $ZodCIDRv6: core.$constructor<$ZodCIDRv6>;\nexport declare function isValidBase64(data: string): boolean;\nexport interface $ZodBase64Def extends $ZodStringFormatDef<\"base64\"> {\n}\nexport interface $ZodBase64Internals extends $ZodStringFormatInternals<\"base64\"> {\n}\nexport interface $ZodBase64 extends $ZodType {\n    _zod: $ZodBase64Internals;\n}\nexport declare const $ZodBase64: core.$constructor<$ZodBase64>;\nexport declare function isValidBase64URL(data: string): boolean;\nexport interface $ZodBase64URLDef extends $ZodStringFormatDef<\"base64url\"> {\n}\nexport interface $ZodBase64URLInternals extends $ZodStringFormatInternals<\"base64url\"> {\n}\nexport interface $ZodBase64URL extends $ZodType {\n    _zod: $ZodBase64URLInternals;\n}\nexport declare const $ZodBase64URL: core.$constructor<$ZodBase64URL>;\nexport interface $ZodE164Def extends $ZodStringFormatDef<\"e164\"> {\n}\nexport interface $ZodE164Internals extends $ZodStringFormatInternals<\"e164\"> {\n}\nexport interface $ZodE164 extends $ZodType {\n    _zod: $ZodE164Internals;\n}\nexport declare const $ZodE164: core.$constructor<$ZodE164>;\nexport declare function isValidJWT(token: string, algorithm?: util.JWTAlgorithm | null): boolean;\nexport interface $ZodJWTDef extends $ZodStringFormatDef<\"jwt\"> {\n    alg?: util.JWTAlgorithm | undefined;\n}\nexport interface $ZodJWTInternals extends $ZodStringFormatInternals<\"jwt\"> {\n    def: $ZodJWTDef;\n}\nexport interface $ZodJWT extends $ZodType {\n    _zod: $ZodJWTInternals;\n}\nexport declare const $ZodJWT: core.$constructor<$ZodJWT>;\nexport interface $ZodCustomStringFormatDef<Format extends string = string> extends $ZodStringFormatDef<Format> {\n    fn: (val: string) => unknown;\n}\nexport interface $ZodCustomStringFormatInternals<Format extends string = string> extends $ZodStringFormatInternals<Format> {\n    def: $ZodCustomStringFormatDef<Format>;\n}\nexport interface $ZodCustomStringFormat<Format extends string = string> extends $ZodStringFormat<Format> {\n    _zod: $ZodCustomStringFormatInternals<Format>;\n}\nexport declare const $ZodCustomStringFormat: core.$constructor<$ZodCustomStringFormat>;\nexport interface $ZodNumberDef extends $ZodTypeDef {\n    type: \"number\";\n    coerce?: boolean;\n}\nexport interface $ZodNumberInternals<Input = unknown> extends $ZodTypeInternals<number, Input> {\n    def: $ZodNumberDef;\n    /** @deprecated Internal API, use with caution (not deprecated) */\n    pattern: RegExp;\n    /** @deprecated Internal API, use with caution (not deprecated) */\n    isst: errors.$ZodIssueInvalidType;\n    bag: util.LoosePartial<{\n        minimum: number;\n        maximum: number;\n        exclusiveMinimum: number;\n        exclusiveMaximum: number;\n        format: string;\n        pattern: RegExp;\n    }>;\n}\nexport interface $ZodNumber<Input = unknown> extends $ZodType {\n    _zod: $ZodNumberInternals<Input>;\n}\nexport declare const $ZodNumber: core.$constructor<$ZodNumber>;\nexport interface $ZodNumberFormatDef extends $ZodNumberDef, checks.$ZodCheckNumberFormatDef {\n}\nexport interface $ZodNumberFormatInternals extends $ZodNumberInternals<number>, checks.$ZodCheckNumberFormatInternals {\n    def: $ZodNumberFormatDef;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodNumberFormat extends $ZodType {\n    _zod: $ZodNumberFormatInternals;\n}\nexport declare const $ZodNumberFormat: core.$constructor<$ZodNumberFormat>;\nexport interface $ZodBooleanDef extends $ZodTypeDef {\n    type: \"boolean\";\n    coerce?: boolean;\n    checks?: checks.$ZodCheck<boolean>[];\n}\nexport interface $ZodBooleanInternals<T = unknown> extends $ZodTypeInternals<boolean, T> {\n    pattern: RegExp;\n    def: $ZodBooleanDef;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodBoolean<T = unknown> extends $ZodType {\n    _zod: $ZodBooleanInternals<T>;\n}\nexport declare const $ZodBoolean: core.$constructor<$ZodBoolean>;\nexport interface $ZodBigIntDef extends $ZodTypeDef {\n    type: \"bigint\";\n    coerce?: boolean;\n}\nexport interface $ZodBigIntInternals<T = unknown> extends $ZodTypeInternals<bigint, T> {\n    pattern: RegExp;\n    /** @internal Internal API, use with caution */\n    def: $ZodBigIntDef;\n    isst: errors.$ZodIssueInvalidType;\n    bag: util.LoosePartial<{\n        minimum: bigint;\n        maximum: bigint;\n        format: string;\n    }>;\n}\nexport interface $ZodBigInt<T = unknown> extends $ZodType {\n    _zod: $ZodBigIntInternals<T>;\n}\nexport declare const $ZodBigInt: core.$constructor<$ZodBigInt>;\nexport interface $ZodBigIntFormatDef extends $ZodBigIntDef, checks.$ZodCheckBigIntFormatDef {\n    check: \"bigint_format\";\n}\nexport interface $ZodBigIntFormatInternals extends $ZodBigIntInternals<bigint>, checks.$ZodCheckBigIntFormatInternals {\n    def: $ZodBigIntFormatDef;\n}\nexport interface $ZodBigIntFormat extends $ZodType {\n    _zod: $ZodBigIntFormatInternals;\n}\nexport declare const $ZodBigIntFormat: core.$constructor<$ZodBigIntFormat>;\nexport interface $ZodSymbolDef extends $ZodTypeDef {\n    type: \"symbol\";\n}\nexport interface $ZodSymbolInternals extends $ZodTypeInternals<symbol, symbol> {\n    def: $ZodSymbolDef;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodSymbol extends $ZodType {\n    _zod: $ZodSymbolInternals;\n}\nexport declare const $ZodSymbol: core.$constructor<$ZodSymbol>;\nexport interface $ZodUndefinedDef extends $ZodTypeDef {\n    type: \"undefined\";\n}\nexport interface $ZodUndefinedInternals extends $ZodTypeInternals<undefined, undefined> {\n    pattern: RegExp;\n    def: $ZodUndefinedDef;\n    values: util.PrimitiveSet;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodUndefined extends $ZodType {\n    _zod: $ZodUndefinedInternals;\n}\nexport declare const $ZodUndefined: core.$constructor<$ZodUndefined>;\nexport interface $ZodNullDef extends $ZodTypeDef {\n    type: \"null\";\n}\nexport interface $ZodNullInternals extends $ZodTypeInternals<null, null> {\n    pattern: RegExp;\n    def: $ZodNullDef;\n    values: util.PrimitiveSet;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodNull extends $ZodType {\n    _zod: $ZodNullInternals;\n}\nexport declare const $ZodNull: core.$constructor<$ZodNull>;\nexport interface $ZodAnyDef extends $ZodTypeDef {\n    type: \"any\";\n}\nexport interface $ZodAnyInternals extends $ZodTypeInternals<any, any> {\n    def: $ZodAnyDef;\n    isst: never;\n}\nexport interface $ZodAny extends $ZodType {\n    _zod: $ZodAnyInternals;\n}\nexport declare const $ZodAny: core.$constructor<$ZodAny>;\nexport interface $ZodUnknownDef extends $ZodTypeDef {\n    type: \"unknown\";\n}\nexport interface $ZodUnknownInternals extends $ZodTypeInternals<unknown, unknown> {\n    def: $ZodUnknownDef;\n    isst: never;\n}\nexport interface $ZodUnknown extends $ZodType {\n    _zod: $ZodUnknownInternals;\n}\nexport declare const $ZodUnknown: core.$constructor<$ZodUnknown>;\nexport interface $ZodNeverDef extends $ZodTypeDef {\n    type: \"never\";\n}\nexport interface $ZodNeverInternals extends $ZodTypeInternals<never, never> {\n    def: $ZodNeverDef;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodNever extends $ZodType {\n    _zod: $ZodNeverInternals;\n}\nexport declare const $ZodNever: core.$constructor<$ZodNever>;\nexport interface $ZodVoidDef extends $ZodTypeDef {\n    type: \"void\";\n}\nexport interface $ZodVoidInternals extends $ZodTypeInternals<void, void> {\n    def: $ZodVoidDef;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodVoid extends $ZodType {\n    _zod: $ZodVoidInternals;\n}\nexport declare const $ZodVoid: core.$constructor<$ZodVoid>;\nexport interface $ZodDateDef extends $ZodTypeDef {\n    type: \"date\";\n    coerce?: boolean;\n}\nexport interface $ZodDateInternals<T = unknown> extends $ZodTypeInternals<Date, T> {\n    def: $ZodDateDef;\n    isst: errors.$ZodIssueInvalidType;\n    bag: util.LoosePartial<{\n        minimum: Date;\n        maximum: Date;\n        format: string;\n    }>;\n}\nexport interface $ZodDate<T = unknown> extends $ZodType {\n    _zod: $ZodDateInternals<T>;\n}\nexport declare const $ZodDate: core.$constructor<$ZodDate>;\nexport interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"array\";\n    element: T;\n}\nexport interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {\n    def: $ZodArrayDef<T>;\n    isst: errors.$ZodIssueInvalidType;\n    output: core.output<T>[];\n    input: core.input<T>[];\n}\nexport interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {\n}\nexport declare const $ZodArray: core.$constructor<$ZodArray>;\ntype OptionalOutSchema = {\n    _zod: {\n        optout: \"optional\";\n    };\n};\ntype OptionalInSchema = {\n    _zod: {\n        optin: \"optional\";\n    };\n};\nexport type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, core.output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{\n    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k][\"_zod\"][\"output\"];\n} & {\n    -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k][\"_zod\"][\"output\"];\n} & Extra>;\nexport type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, core.input<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{\n    -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k][\"_zod\"][\"input\"];\n} & {\n    -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k][\"_zod\"][\"input\"];\n} & Extra>;\nexport type $ZodObjectConfig = {\n    out: Record<string, unknown>;\n    in: Record<string, unknown>;\n};\nexport type $loose = {\n    out: Record<string, unknown>;\n    in: Record<string, unknown>;\n};\nexport type $strict = {\n    out: {};\n    in: {};\n};\nexport type $strip = {\n    out: {};\n    in: {};\n};\nexport type $catchall<T extends SomeType> = {\n    out: {\n        [k: string]: core.output<T>;\n    };\n    in: {\n        [k: string]: core.input<T>;\n    };\n};\nexport type $ZodShape = Readonly<{\n    [k: string]: $ZodType;\n}>;\nexport interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef {\n    type: \"object\";\n    shape: Shape;\n    catchall?: $ZodType | undefined;\n}\nexport interface $ZodObjectInternals<\n/** @ts-ignore Cast variance */\nout Shape extends $ZodShape = $ZodShape, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {\n    def: $ZodObjectDef<Shape>;\n    config: Config;\n    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;\n    propValues: util.PropValues;\n    output: $InferObjectOutput<Shape, Config[\"out\"]>;\n    input: $InferObjectInput<Shape, Config[\"in\"]>;\n    optin?: \"optional\" | undefined;\n    optout?: \"optional\" | undefined;\n}\nexport type $ZodLooseShape = Record<string, any>;\nexport interface $ZodObject<\n/** @ts-ignore Cast variance */\nout Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {\n}\nexport declare const $ZodObject: core.$constructor<$ZodObject>;\nexport declare const $ZodObjectJIT: core.$constructor<$ZodObject>;\nexport type $InferUnionOutput<T extends SomeType> = T extends any ? core.output<T> : never;\nexport type $InferUnionInput<T extends SomeType> = T extends any ? core.input<T> : never;\nexport interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {\n    type: \"union\";\n    options: Options;\n    inclusive?: boolean;\n}\ntype IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;\ntype IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;\nexport interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {\n    def: $ZodUnionDef<T>;\n    isst: errors.$ZodIssueInvalidUnion;\n    pattern: T[number][\"_zod\"][\"pattern\"];\n    values: T[number][\"_zod\"][\"values\"];\n    output: $InferUnionOutput<T[number]>;\n    input: $InferUnionInput<T[number]>;\n    optin: IsOptionalIn<T[number]> extends false ? \"optional\" | undefined : \"optional\";\n    optout: IsOptionalOut<T[number]> extends false ? \"optional\" | undefined : \"optional\";\n}\nexport interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {\n    _zod: $ZodUnionInternals<T>;\n}\nexport declare const $ZodUnion: core.$constructor<$ZodUnion>;\nexport interface $ZodXorInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<T> {\n}\nexport interface $ZodXor<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodXorInternals<T>> {\n    _zod: $ZodXorInternals<T>;\n}\nexport declare const $ZodXor: core.$constructor<$ZodXor>;\nexport interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionDef<Options> {\n    discriminator: Disc;\n    unionFallback?: boolean;\n}\nexport interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodUnionInternals<Options> {\n    def: $ZodDiscriminatedUnionDef<Options, Disc>;\n    propValues: util.PropValues;\n}\nexport interface $ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends $ZodType {\n    _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;\n}\nexport declare const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion>;\nexport interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"intersection\";\n    left: Left;\n    right: Right;\n}\nexport interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _$ZodTypeInternals {\n    def: $ZodIntersectionDef<A, B>;\n    isst: never;\n    optin: A[\"_zod\"][\"optin\"] | B[\"_zod\"][\"optin\"];\n    optout: A[\"_zod\"][\"optout\"] | B[\"_zod\"][\"optout\"];\n    output: core.output<A> & core.output<B>;\n    input: core.input<A> & core.input<B>;\n}\nexport interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodIntersectionInternals<A, B>;\n}\nexport declare const $ZodIntersection: core.$constructor<$ZodIntersection>;\nexport interface $ZodTupleDef<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {\n    type: \"tuple\";\n    items: T;\n    rest: Rest;\n}\nexport type $InferTupleInputType<T extends util.TupleItems, Rest extends SomeType | null> = [\n    ...TupleInputTypeWithOptionals<T>,\n    ...(Rest extends SomeType ? core.input<Rest>[] : [])\n];\ntype TupleInputTypeNoOptionals<T extends util.TupleItems> = {\n    [k in keyof T]: core.input<T[k]>;\n};\ntype TupleInputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [\n    ...infer Prefix extends SomeType[],\n    infer Tail extends SomeType\n] ? Tail[\"_zod\"][\"optin\"] extends \"optional\" ? [...TupleInputTypeWithOptionals<Prefix>, core.input<Tail>?] : TupleInputTypeNoOptionals<T> : [];\nexport type $InferTupleOutputType<T extends util.TupleItems, Rest extends SomeType | null> = [\n    ...TupleOutputTypeWithOptionals<T>,\n    ...(Rest extends SomeType ? core.output<Rest>[] : [])\n];\ntype TupleOutputTypeNoOptionals<T extends util.TupleItems> = {\n    [k in keyof T]: core.output<T[k]>;\n};\ntype TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [\n    ...infer Prefix extends SomeType[],\n    infer Tail extends SomeType\n] ? Tail[\"_zod\"][\"optout\"] extends \"optional\" ? [...TupleOutputTypeWithOptionals<Prefix>, core.output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];\nexport interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _$ZodTypeInternals {\n    def: $ZodTupleDef<T, Rest>;\n    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;\n    output: $InferTupleOutputType<T, Rest>;\n    input: $InferTupleInputType<T, Rest>;\n}\nexport interface $ZodTuple<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {\n    _zod: $ZodTupleInternals<T, Rest>;\n}\nexport declare const $ZodTuple: core.$constructor<$ZodTuple>;\nexport type $ZodRecordKey = $ZodType<string | number | symbol, unknown>;\nexport interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"record\";\n    keyType: Key;\n    valueType: Value;\n    /** @default \"strict\" - errors on keys not matching keyType. \"loose\" passes through non-matching keys unchanged. */\n    mode?: \"strict\" | \"loose\";\n}\nexport type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;\nexport type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.input<Key> & PropertyKey, core.input<Value>>> : Record<core.input<Key> & PropertyKey, core.input<Value>>;\nexport interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {\n    def: $ZodRecordDef<Key, Value>;\n    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;\n    optin?: \"optional\" | undefined;\n    optout?: \"optional\" | undefined;\n}\nexport type $partial = {\n    \"~~partial\": true;\n};\nexport interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodRecordInternals<Key, Value>;\n}\nexport declare const $ZodRecord: core.$constructor<$ZodRecord>;\nexport interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"map\";\n    keyType: Key;\n    valueType: Value;\n}\nexport interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<core.output<Key>, core.output<Value>>, Map<core.input<Key>, core.input<Value>>> {\n    def: $ZodMapDef<Key, Value>;\n    isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey | errors.$ZodIssueInvalidElement<unknown>;\n    optin?: \"optional\" | undefined;\n    optout?: \"optional\" | undefined;\n}\nexport interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodMapInternals<Key, Value>;\n}\nexport declare const $ZodMap: core.$constructor<$ZodMap>;\nexport interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"set\";\n    valueType: T;\n}\nexport interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<core.output<T>>, Set<core.input<T>>> {\n    def: $ZodSetDef<T>;\n    isst: errors.$ZodIssueInvalidType;\n    optin?: \"optional\" | undefined;\n    optout?: \"optional\" | undefined;\n}\nexport interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodSetInternals<T>;\n}\nexport declare const $ZodSet: core.$constructor<$ZodSet>;\nexport type $InferEnumOutput<T extends util.EnumLike> = T[keyof T] & {};\nexport type $InferEnumInput<T extends util.EnumLike> = T[keyof T] & {};\nexport interface $ZodEnumDef<T extends util.EnumLike = util.EnumLike> extends $ZodTypeDef {\n    type: \"enum\";\n    entries: T;\n}\nexport interface $ZodEnumInternals<\n/** @ts-ignore Cast variance */\nout T extends util.EnumLike = util.EnumLike> extends $ZodTypeInternals<$InferEnumOutput<T>, $InferEnumInput<T>> {\n    def: $ZodEnumDef<T>;\n    /** @deprecated Internal API, use with caution (not deprecated) */\n    values: util.PrimitiveSet;\n    /** @deprecated Internal API, use with caution (not deprecated) */\n    pattern: RegExp;\n    isst: errors.$ZodIssueInvalidValue;\n}\nexport interface $ZodEnum<T extends util.EnumLike = util.EnumLike> extends $ZodType {\n    _zod: $ZodEnumInternals<T>;\n}\nexport declare const $ZodEnum: core.$constructor<$ZodEnum>;\nexport interface $ZodLiteralDef<T extends util.Literal> extends $ZodTypeDef {\n    type: \"literal\";\n    values: T[];\n}\nexport interface $ZodLiteralInternals<T extends util.Literal = util.Literal> extends $ZodTypeInternals<T, T> {\n    def: $ZodLiteralDef<T>;\n    values: Set<T>;\n    pattern: RegExp;\n    isst: errors.$ZodIssueInvalidValue;\n}\nexport interface $ZodLiteral<T extends util.Literal = util.Literal> extends $ZodType {\n    _zod: $ZodLiteralInternals<T>;\n}\nexport declare const $ZodLiteral: core.$constructor<$ZodLiteral>;\ntype _File = typeof globalThis extends {\n    File: infer F extends new (...args: any[]) => any;\n} ? InstanceType<F> : {};\n/** Do not reference this directly. */\nexport interface File extends _File {\n    readonly type: string;\n    readonly size: number;\n}\nexport interface $ZodFileDef extends $ZodTypeDef {\n    type: \"file\";\n}\nexport interface $ZodFileInternals extends $ZodTypeInternals<File, File> {\n    def: $ZodFileDef;\n    isst: errors.$ZodIssueInvalidType;\n    bag: util.LoosePartial<{\n        minimum: number;\n        maximum: number;\n        mime: util.MimeTypes[];\n    }>;\n}\nexport interface $ZodFile extends $ZodType {\n    _zod: $ZodFileInternals;\n}\nexport declare const $ZodFile: core.$constructor<$ZodFile>;\nexport interface $ZodTransformDef extends $ZodTypeDef {\n    type: \"transform\";\n    transform: (input: unknown, payload: ParsePayload<unknown>) => util.MaybeAsync<unknown>;\n}\nexport interface $ZodTransformInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I> {\n    def: $ZodTransformDef;\n    isst: never;\n}\nexport interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {\n    _zod: $ZodTransformInternals<O, I>;\n}\nexport declare const $ZodTransform: core.$constructor<$ZodTransform>;\nexport interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"optional\";\n    innerType: T;\n}\nexport interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T> | undefined, core.input<T> | undefined> {\n    def: $ZodOptionalDef<T>;\n    optin: \"optional\";\n    optout: \"optional\";\n    isst: never;\n    values: T[\"_zod\"][\"values\"];\n    pattern: T[\"_zod\"][\"pattern\"];\n}\nexport interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodOptionalInternals<T>;\n}\nexport declare const $ZodOptional: core.$constructor<$ZodOptional>;\nexport interface $ZodExactOptionalDef<T extends SomeType = $ZodType> extends $ZodOptionalDef<T> {\n}\nexport interface $ZodExactOptionalInternals<T extends SomeType = $ZodType> extends $ZodOptionalInternals<T> {\n    def: $ZodExactOptionalDef<T>;\n    output: core.output<T>;\n    input: core.input<T>;\n}\nexport interface $ZodExactOptional<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodExactOptionalInternals<T>;\n}\nexport declare const $ZodExactOptional: core.$constructor<$ZodExactOptional>;\nexport interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"nullable\";\n    innerType: T;\n}\nexport interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T> | null, core.input<T> | null> {\n    def: $ZodNullableDef<T>;\n    optin: T[\"_zod\"][\"optin\"];\n    optout: T[\"_zod\"][\"optout\"];\n    isst: never;\n    values: T[\"_zod\"][\"values\"];\n    pattern: T[\"_zod\"][\"pattern\"];\n}\nexport interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodNullableInternals<T>;\n}\nexport declare const $ZodNullable: core.$constructor<$ZodNullable>;\nexport interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"default\";\n    innerType: T;\n    /** The default value. May be a getter. */\n    defaultValue: util.NoUndefined<core.output<T>>;\n}\nexport interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {\n    def: $ZodDefaultDef<T>;\n    optin: \"optional\";\n    optout?: \"optional\" | undefined;\n    isst: never;\n    values: T[\"_zod\"][\"values\"];\n}\nexport interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodDefaultInternals<T>;\n}\nexport declare const $ZodDefault: core.$constructor<$ZodDefault>;\nexport interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"prefault\";\n    innerType: T;\n    /** The default value. May be a getter. */\n    defaultValue: core.input<T>;\n}\nexport interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {\n    def: $ZodPrefaultDef<T>;\n    optin: \"optional\";\n    optout?: \"optional\" | undefined;\n    isst: never;\n    values: T[\"_zod\"][\"values\"];\n}\nexport interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodPrefaultInternals<T>;\n}\nexport declare const $ZodPrefault: core.$constructor<$ZodPrefault>;\nexport interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"nonoptional\";\n    innerType: T;\n}\nexport interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, util.NoUndefined<core.input<T>>> {\n    def: $ZodNonOptionalDef<T>;\n    isst: errors.$ZodIssueInvalidType;\n    values: T[\"_zod\"][\"values\"];\n    optin: \"optional\" | undefined;\n    optout: \"optional\" | undefined;\n}\nexport interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodNonOptionalInternals<T>;\n}\nexport declare const $ZodNonOptional: core.$constructor<$ZodNonOptional>;\nexport interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"success\";\n    innerType: T;\n}\nexport interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, core.input<T>> {\n    def: $ZodSuccessDef<T>;\n    isst: never;\n    optin: T[\"_zod\"][\"optin\"];\n    optout: \"optional\" | undefined;\n}\nexport interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodSuccessInternals<T>;\n}\nexport declare const $ZodSuccess: core.$constructor<$ZodSuccess>;\nexport interface $ZodCatchCtx extends ParsePayload {\n    /** @deprecated Use `ctx.issues` */\n    error: {\n        issues: errors.$ZodIssue[];\n    };\n    /** @deprecated Use `ctx.value` */\n    input: unknown;\n}\nexport interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"catch\";\n    innerType: T;\n    catchValue: (ctx: $ZodCatchCtx) => unknown;\n}\nexport interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T>> {\n    def: $ZodCatchDef<T>;\n    optin: T[\"_zod\"][\"optin\"];\n    optout: T[\"_zod\"][\"optout\"];\n    isst: never;\n    values: T[\"_zod\"][\"values\"];\n}\nexport interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodCatchInternals<T>;\n}\nexport declare const $ZodCatch: core.$constructor<$ZodCatch>;\nexport interface $ZodNaNDef extends $ZodTypeDef {\n    type: \"nan\";\n}\nexport interface $ZodNaNInternals extends $ZodTypeInternals<number, number> {\n    def: $ZodNaNDef;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodNaN extends $ZodType {\n    _zod: $ZodNaNInternals;\n}\nexport declare const $ZodNaN: core.$constructor<$ZodNaN>;\nexport interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"pipe\";\n    in: A;\n    out: B;\n    /** Only defined inside $ZodCodec instances. */\n    transform?: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;\n    /** Only defined inside $ZodCodec instances. */\n    reverseTransform?: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;\n}\nexport interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<B>, core.input<A>> {\n    def: $ZodPipeDef<A, B>;\n    isst: never;\n    values: A[\"_zod\"][\"values\"];\n    optin: A[\"_zod\"][\"optin\"];\n    optout: B[\"_zod\"][\"optout\"];\n    propValues: A[\"_zod\"][\"propValues\"];\n}\nexport interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodPipeInternals<A, B>;\n}\nexport declare const $ZodPipe: core.$constructor<$ZodPipe>;\nexport interface $ZodCodecDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodPipeDef<A, B> {\n    transform: (value: core.output<A>, payload: ParsePayload<core.output<A>>) => util.MaybeAsync<core.input<B>>;\n    reverseTransform: (value: core.input<B>, payload: ParsePayload<core.input<B>>) => util.MaybeAsync<core.output<A>>;\n}\nexport interface $ZodCodecInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<B>, core.input<A>> {\n    def: $ZodCodecDef<A, B>;\n    isst: never;\n    values: A[\"_zod\"][\"values\"];\n    optin: A[\"_zod\"][\"optin\"];\n    optout: B[\"_zod\"][\"optout\"];\n    propValues: A[\"_zod\"][\"propValues\"];\n}\nexport interface $ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodCodecInternals<A, B>;\n}\nexport declare const $ZodCodec: core.$constructor<$ZodCodec>;\nexport interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"readonly\";\n    innerType: T;\n}\nexport interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.MakeReadonly<core.output<T>>, util.MakeReadonly<core.input<T>>> {\n    def: $ZodReadonlyDef<T>;\n    optin: T[\"_zod\"][\"optin\"];\n    optout: T[\"_zod\"][\"optout\"];\n    isst: never;\n    propValues: T[\"_zod\"][\"propValues\"];\n    values: T[\"_zod\"][\"values\"];\n}\nexport interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodReadonlyInternals<T>;\n}\nexport declare const $ZodReadonly: core.$constructor<$ZodReadonly>;\nexport interface $ZodTemplateLiteralDef extends $ZodTypeDef {\n    type: \"template_literal\";\n    parts: $ZodTemplateLiteralPart[];\n    format?: string | undefined;\n}\nexport interface $ZodTemplateLiteralInternals<Template extends string = string> extends $ZodTypeInternals<Template, Template> {\n    pattern: RegExp;\n    def: $ZodTemplateLiteralDef;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodTemplateLiteral<Template extends string = string> extends $ZodType {\n    _zod: $ZodTemplateLiteralInternals<Template>;\n}\ntype LiteralPart = Exclude<util.Literal, symbol>;\ninterface SchemaPartInternals extends $ZodTypeInternals<LiteralPart, LiteralPart> {\n    pattern: RegExp;\n}\ninterface SchemaPart extends $ZodType {\n    _zod: SchemaPartInternals;\n}\nexport type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;\ntype UndefinedToEmptyString<T> = T extends undefined ? \"\" : T;\ntype AppendToTemplateLiteral<Template extends string, Suffix extends LiteralPart | $ZodType> = Suffix extends LiteralPart ? `${Template}${UndefinedToEmptyString<Suffix>}` : Suffix extends $ZodType ? `${Template}${core.output<Suffix> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;\nexport type ConcatenateTupleOfStrings<T extends string[]> = T extends [\n    infer First extends string,\n    ...infer Rest extends string[]\n] ? Rest extends string[] ? First extends \"\" ? ConcatenateTupleOfStrings<Rest> : `${First}${ConcatenateTupleOfStrings<Rest>}` : never : \"\";\nexport type ConvertPartsToStringTuple<Parts extends $ZodTemplateLiteralPart[]> = {\n    [K in keyof Parts]: Parts[K] extends LiteralPart ? `${UndefinedToEmptyString<Parts[K]>}` : Parts[K] extends $ZodType ? `${core.output<Parts[K]> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;\n};\nexport type ToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = ConcatenateTupleOfStrings<ConvertPartsToStringTuple<Parts>>;\nexport type $PartsToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = [] extends Parts ? `` : Parts extends [...infer Rest, infer Last extends $ZodTemplateLiteralPart] ? Rest extends $ZodTemplateLiteralPart[] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never : never;\nexport declare const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral>;\nexport type $ZodFunctionArgs = $ZodType<unknown[], unknown[]>;\nexport type $ZodFunctionIn = $ZodFunctionArgs;\nexport type $ZodFunctionOut = $ZodType;\nexport type $InferInnerFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => core.input<Returns>;\nexport type $InferInnerFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.output<Args>) => util.MaybeAsync<core.input<Returns>>;\nexport type $InferOuterFunctionType<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => core.output<Returns>;\nexport type $InferOuterFunctionTypeAsync<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> = (...args: $ZodFunctionIn extends Args ? never[] : core.input<Args>) => Promise<core.output<Returns>>;\nexport interface $ZodFunctionDef<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodTypeDef {\n    type: \"function\";\n    input: In;\n    output: Out;\n}\nexport interface $ZodFunctionInternals<Args extends $ZodFunctionIn, Returns extends $ZodFunctionOut> extends $ZodTypeInternals<$InferOuterFunctionType<Args, Returns>, $InferInnerFunctionType<Args, Returns>> {\n    def: $ZodFunctionDef<Args, Returns>;\n    isst: errors.$ZodIssueInvalidType;\n}\nexport interface $ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends $ZodType<any, any, $ZodFunctionInternals<Args, Returns>> {\n    /** @deprecated */\n    _def: $ZodFunctionDef<Args, Returns>;\n    _input: $InferInnerFunctionType<Args, Returns>;\n    _output: $InferOuterFunctionType<Args, Returns>;\n    implement<F extends $InferInnerFunctionType<Args, Returns>>(func: F): (...args: Parameters<this[\"_output\"]>) => ReturnType<F> extends ReturnType<this[\"_output\"]> ? ReturnType<F> : ReturnType<this[\"_output\"]>;\n    implementAsync<F extends $InferInnerFunctionTypeAsync<Args, Returns>>(func: F): F extends $InferOuterFunctionTypeAsync<Args, Returns> ? F : $InferOuterFunctionTypeAsync<Args, Returns>;\n    input<const Items extends util.TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): $ZodFunction<$ZodTuple<Items, Rest>, Returns>;\n    input<NewArgs extends $ZodFunctionIn>(args: NewArgs): $ZodFunction<NewArgs, Returns>;\n    input(...args: any[]): $ZodFunction<any, Returns>;\n    output<NewReturns extends $ZodType>(output: NewReturns): $ZodFunction<Args, NewReturns>;\n}\nexport interface $ZodFunctionParams<I extends $ZodFunctionIn, O extends $ZodType> {\n    input?: I;\n    output?: O;\n}\nexport declare const $ZodFunction: core.$constructor<$ZodFunction>;\nexport interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"promise\";\n    innerType: T;\n}\nexport interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Promise<core.output<T>>, util.MaybeAsync<core.input<T>>> {\n    def: $ZodPromiseDef<T>;\n    isst: never;\n}\nexport interface $ZodPromise<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodPromiseInternals<T>;\n}\nexport declare const $ZodPromise: core.$constructor<$ZodPromise>;\nexport interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {\n    type: \"lazy\";\n    getter: () => T;\n}\nexport interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T>> {\n    def: $ZodLazyDef<T>;\n    isst: never;\n    /** Auto-cached way to retrieve the inner schema */\n    innerType: T;\n    pattern: T[\"_zod\"][\"pattern\"];\n    propValues: T[\"_zod\"][\"propValues\"];\n    optin: T[\"_zod\"][\"optin\"];\n    optout: T[\"_zod\"][\"optout\"];\n}\nexport interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {\n    _zod: $ZodLazyInternals<T>;\n}\nexport declare const $ZodLazy: core.$constructor<$ZodLazy>;\nexport interface $ZodCustomDef<O = unknown> extends $ZodTypeDef, checks.$ZodCheckDef {\n    type: \"custom\";\n    check: \"custom\";\n    path?: PropertyKey[] | undefined;\n    error?: errors.$ZodErrorMap | undefined;\n    params?: Record<string, any> | undefined;\n    fn: (arg: O) => unknown;\n}\nexport interface $ZodCustomInternals<O = unknown, I = unknown> extends $ZodTypeInternals<O, I>, checks.$ZodCheckInternals<O> {\n    def: $ZodCustomDef;\n    issc: errors.$ZodIssue;\n    isst: never;\n    bag: util.LoosePartial<{\n        Class: typeof util.Class;\n    }>;\n}\nexport interface $ZodCustom<O = unknown, I = unknown> extends $ZodType {\n    _zod: $ZodCustomInternals<O, I>;\n}\nexport declare const $ZodCustom: core.$constructor<$ZodCustom>;\nexport type $ZodTypes = $ZodString | $ZodNumber | $ZodBigInt | $ZodBoolean | $ZodDate | $ZodSymbol | $ZodUndefined | $ZodNullable | $ZodNull | $ZodAny | $ZodUnknown | $ZodNever | $ZodVoid | $ZodArray | $ZodObject | $ZodUnion | $ZodIntersection | $ZodTuple | $ZodRecord | $ZodMap | $ZodSet | $ZodLiteral | $ZodEnum | $ZodFunction | $ZodPromise | $ZodLazy | $ZodOptional | $ZodDefault | $ZodPrefault | $ZodTemplateLiteral | $ZodCustom | $ZodTransform | $ZodNonOptional | $ZodReadonly | $ZodNaN | $ZodPipe | $ZodSuccess | $ZodCatch | $ZodFile;\nexport type $ZodStringFormatTypes = $ZodGUID | $ZodUUID | $ZodEmail | $ZodURL | $ZodEmoji | $ZodNanoID | $ZodCUID | $ZodCUID2 | $ZodULID | $ZodXID | $ZodKSUID | $ZodISODateTime | $ZodISODate | $ZodISOTime | $ZodISODuration | $ZodIPv4 | $ZodIPv6 | $ZodMAC | $ZodCIDRv4 | $ZodCIDRv6 | $ZodBase64 | $ZodBase64URL | $ZodE164 | $ZodJWT | $ZodCustomStringFormat<\"hex\"> | $ZodCustomStringFormat<util.HashFormat> | $ZodCustomStringFormat<\"hostname\">;\n",
+	"file:///node_modules/zod/v4/core/standard-schema.d.ts": "/** The Standard interface. */\nexport interface StandardTypedV1<Input = unknown, Output = Input> {\n    /** The Standard properties. */\n    readonly \"~standard\": StandardTypedV1.Props<Input, Output>;\n}\nexport declare namespace StandardTypedV1 {\n    /** The Standard properties interface. */\n    interface Props<Input = unknown, Output = Input> {\n        /** The version number of the standard. */\n        readonly version: 1;\n        /** The vendor name of the schema library. */\n        readonly vendor: string;\n        /** Inferred types associated with the schema. */\n        readonly types?: Types<Input, Output> | undefined;\n    }\n    /** The Standard types interface. */\n    interface Types<Input = unknown, Output = Input> {\n        /** The input type of the schema. */\n        readonly input: Input;\n        /** The output type of the schema. */\n        readonly output: Output;\n    }\n    /** Infers the input type of a Standard. */\n    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema[\"~standard\"][\"types\"]>[\"input\"];\n    /** Infers the output type of a Standard. */\n    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema[\"~standard\"][\"types\"]>[\"output\"];\n}\n/** The Standard Schema interface. */\nexport interface StandardSchemaV1<Input = unknown, Output = Input> {\n    /** The Standard Schema properties. */\n    readonly \"~standard\": StandardSchemaV1.Props<Input, Output>;\n}\nexport declare namespace StandardSchemaV1 {\n    /** The Standard Schema properties interface. */\n    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {\n        /** Validates unknown input values. */\n        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;\n    }\n    /** The result interface of the validate function. */\n    type Result<Output> = SuccessResult<Output> | FailureResult;\n    /** The result interface if validation succeeds. */\n    interface SuccessResult<Output> {\n        /** The typed output value. */\n        readonly value: Output;\n        /** The absence of issues indicates success. */\n        readonly issues?: undefined;\n    }\n    interface Options {\n        /** Implicit support for additional vendor-specific parameters, if needed. */\n        readonly libraryOptions?: Record<string, unknown> | undefined;\n    }\n    /** The result interface if validation fails. */\n    interface FailureResult {\n        /** The issues of failed validation. */\n        readonly issues: ReadonlyArray<Issue>;\n    }\n    /** The issue interface of the failure output. */\n    interface Issue {\n        /** The error message of the issue. */\n        readonly message: string;\n        /** The path of the issue, if any. */\n        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;\n    }\n    /** The path segment interface of the issue. */\n    interface PathSegment {\n        /** The key representing a path segment. */\n        readonly key: PropertyKey;\n    }\n    /** The Standard types interface. */\n    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {\n    }\n    /** Infers the input type of a Standard. */\n    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;\n    /** Infers the output type of a Standard. */\n    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;\n}\n/** The Standard JSON Schema interface. */\nexport interface StandardJSONSchemaV1<Input = unknown, Output = Input> {\n    /** The Standard JSON Schema properties. */\n    readonly \"~standard\": StandardJSONSchemaV1.Props<Input, Output>;\n}\nexport declare namespace StandardJSONSchemaV1 {\n    /** The Standard JSON Schema properties interface. */\n    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {\n        /** Methods for generating the input/output JSON Schema. */\n        readonly jsonSchema: Converter;\n    }\n    /** The Standard JSON Schema converter interface. */\n    interface Converter {\n        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */\n        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;\n        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */\n        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;\n    }\n    /** The target version of the generated JSON Schema.\n     *\n     * It is *strongly recommended* that implementers support `\"draft-2020-12\"` and `\"draft-07\"`, as they are both in wide use.\n     *\n     * The `\"openapi-3.0\"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `\"draft-04\"`.\n     *\n     * All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.\n     */\n    type Target = \"draft-2020-12\" | \"draft-07\" | \"openapi-3.0\" | ({} & string);\n    /** The options for the input/output methods. */\n    interface Options {\n        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */\n        readonly target: Target;\n        /** Implicit support for additional vendor-specific parameters, if needed. */\n        readonly libraryOptions?: Record<string, unknown> | undefined;\n    }\n    /** The Standard types interface. */\n    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {\n    }\n    /** Infers the input type of a Standard. */\n    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;\n    /** Infers the output type of a Standard. */\n    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;\n}\nexport interface StandardSchemaWithJSONProps<Input = unknown, Output = Input> extends StandardSchemaV1.Props<Input, Output>, StandardJSONSchemaV1.Props<Input, Output> {\n}\n/**\n * An interface that combines StandardJSONSchema and StandardSchema.\n */\nexport interface StandardSchemaWithJSON<Input = unknown, Output = Input> {\n    \"~standard\": StandardSchemaWithJSONProps<Input, Output>;\n}\n",
+	"file:///node_modules/zod/v4/core/to-json-schema.d.ts": "import type * as core from \"../core/index.js\";\nimport type * as JSONSchema from \"./json-schema.js\";\nimport { type $ZodRegistry } from \"./registries.js\";\nimport type * as schemas from \"./schemas.js\";\nimport type { StandardJSONSchemaV1, StandardSchemaWithJSONProps } from \"./standard-schema.js\";\nexport type Processor<T extends schemas.$ZodType = schemas.$ZodType> = (schema: T, ctx: ToJSONSchemaContext, json: JSONSchema.BaseSchema, params: ProcessParams) => void;\nexport interface JSONSchemaGeneratorParams {\n    processors: Record<string, Processor>;\n    /** A registry used to look up metadata for each schema. Any schema with an `id` property will be extracted as a $def.\n     *  @default globalRegistry */\n    metadata?: $ZodRegistry<Record<string, any>>;\n    /** The JSON Schema version to target.\n     * - `\"draft-2020-12\"` — Default. JSON Schema Draft 2020-12\n     * - `\"draft-07\"` — JSON Schema Draft 7\n     * - `\"draft-04\"` — JSON Schema Draft 4\n     * - `\"openapi-3.0\"` — OpenAPI 3.0 Schema Object */\n    target?: \"draft-04\" | \"draft-07\" | \"draft-2020-12\" | \"openapi-3.0\" | ({} & string) | undefined;\n    /** How to handle unrepresentable types.\n     * - `\"throw\"` — Default. Unrepresentable types throw an error\n     * - `\"any\"` — Unrepresentable types become `{}` */\n    unrepresentable?: \"throw\" | \"any\";\n    /** Arbitrary custom logic that can be used to modify the generated JSON Schema. */\n    override?: (ctx: {\n        zodSchema: schemas.$ZodTypes;\n        jsonSchema: JSONSchema.BaseSchema;\n        path: (string | number)[];\n    }) => void;\n    /** Whether to extract the `\"input\"` or `\"output\"` type. Relevant to transforms, defaults, coerced primitives, etc.\n     * - `\"output\"` — Default. Convert the output schema.\n     * - `\"input\"` — Convert the input schema. */\n    io?: \"input\" | \"output\";\n    cycles?: \"ref\" | \"throw\";\n    reused?: \"ref\" | \"inline\";\n    external?: {\n        registry: $ZodRegistry<{\n            id?: string | undefined;\n        }>;\n        uri?: ((id: string) => string) | undefined;\n        defs: Record<string, JSONSchema.BaseSchema>;\n    } | undefined;\n}\n/**\n * Parameters for the toJSONSchema function.\n */\nexport type ToJSONSchemaParams = Omit<JSONSchemaGeneratorParams, \"processors\" | \"external\">;\n/**\n * Parameters for the toJSONSchema function when passing a registry.\n */\nexport interface RegistryToJSONSchemaParams extends ToJSONSchemaParams {\n    uri?: (id: string) => string;\n}\nexport interface ProcessParams {\n    schemaPath: schemas.$ZodType[];\n    path: (string | number)[];\n}\nexport interface Seen {\n    /** JSON Schema result for this Zod schema */\n    schema: JSONSchema.BaseSchema;\n    /** A cached version of the schema that doesn't get overwritten during ref resolution */\n    def?: JSONSchema.BaseSchema;\n    defId?: string | undefined;\n    /** Number of times this schema was encountered during traversal */\n    count: number;\n    /** Cycle path */\n    cycle?: (string | number)[] | undefined;\n    isParent?: boolean | undefined;\n    /** Schema to inherit JSON Schema properties from (set by processor for wrappers) */\n    ref?: schemas.$ZodType | null;\n    /** JSON Schema property path for this schema */\n    path?: (string | number)[] | undefined;\n}\nexport interface ToJSONSchemaContext {\n    processors: Record<string, Processor>;\n    metadataRegistry: $ZodRegistry<Record<string, any>>;\n    target: \"draft-04\" | \"draft-07\" | \"draft-2020-12\" | \"openapi-3.0\" | ({} & string);\n    unrepresentable: \"throw\" | \"any\";\n    override: (ctx: {\n        zodSchema: schemas.$ZodType;\n        jsonSchema: JSONSchema.BaseSchema;\n        path: (string | number)[];\n    }) => void;\n    io: \"input\" | \"output\";\n    counter: number;\n    seen: Map<schemas.$ZodType, Seen>;\n    cycles: \"ref\" | \"throw\";\n    reused: \"ref\" | \"inline\";\n    external?: {\n        registry: $ZodRegistry<{\n            id?: string | undefined;\n        }>;\n        uri?: ((id: string) => string) | undefined;\n        defs: Record<string, JSONSchema.BaseSchema>;\n    } | undefined;\n}\nexport declare function initializeContext(params: JSONSchemaGeneratorParams): ToJSONSchemaContext;\nexport declare function process<T extends schemas.$ZodType>(schema: T, ctx: ToJSONSchemaContext, _params?: ProcessParams): JSONSchema.BaseSchema;\nexport declare function extractDefs<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): void;\nexport declare function finalize<T extends schemas.$ZodType>(ctx: ToJSONSchemaContext, schema: T): ZodStandardJSONSchemaPayload<T>;\nexport type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<core.input<T>, core.output<T>>;\nexport interface ZodStandardJSONSchemaPayload<T> extends JSONSchema.BaseSchema {\n    \"~standard\": ZodStandardSchemaWithJSON<T>;\n}\n/**\n * Creates a toJSONSchema method for a schema instance.\n * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.\n */\nexport declare const createToJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, processors?: Record<string, Processor>) => (params?: ToJSONSchemaParams) => ZodStandardJSONSchemaPayload<T>;\n/**\n * Creates a toJSONSchema method for a schema instance.\n * This encapsulates the logic of initializing context, processing, extracting defs, and finalizing.\n */\ntype StandardJSONSchemaMethodParams = Parameters<StandardJSONSchemaV1[\"~standard\"][\"jsonSchema\"][\"input\"]>[0];\nexport declare const createStandardJSONSchemaMethod: <T extends schemas.$ZodType>(schema: T, io: \"input\" | \"output\", processors?: Record<string, Processor>) => (params?: StandardJSONSchemaMethodParams) => JSONSchema.BaseSchema;\nexport {};\n",
+	"file:///node_modules/zod/v4/core/util.d.ts": "import type * as checks from \"./checks.js\";\nimport type { $ZodConfig } from \"./core.js\";\nimport type * as errors from \"./errors.js\";\nimport type * as schemas from \"./schemas.js\";\nexport type JSONType = string | number | boolean | null | JSONType[] | {\n    [key: string]: JSONType;\n};\nexport type JWTAlgorithm = \"HS256\" | \"HS384\" | \"HS512\" | \"RS256\" | \"RS384\" | \"RS512\" | \"ES256\" | \"ES384\" | \"ES512\" | \"PS256\" | \"PS384\" | \"PS512\" | \"EdDSA\" | (string & {});\nexport type HashAlgorithm = \"md5\" | \"sha1\" | \"sha256\" | \"sha384\" | \"sha512\";\nexport type HashEncoding = \"hex\" | \"base64\" | \"base64url\";\nexport type HashFormat = `${HashAlgorithm}_${HashEncoding}`;\nexport type IPVersion = \"v4\" | \"v6\";\nexport type MimeTypes = \"application/json\" | \"application/xml\" | \"application/x-www-form-urlencoded\" | \"application/javascript\" | \"application/pdf\" | \"application/zip\" | \"application/vnd.ms-excel\" | \"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\" | \"application/msword\" | \"application/vnd.openxmlformats-officedocument.wordprocessingml.document\" | \"application/vnd.ms-powerpoint\" | \"application/vnd.openxmlformats-officedocument.presentationml.presentation\" | \"application/octet-stream\" | \"application/graphql\" | \"text/html\" | \"text/plain\" | \"text/css\" | \"text/javascript\" | \"text/csv\" | \"image/png\" | \"image/jpeg\" | \"image/gif\" | \"image/svg+xml\" | \"image/webp\" | \"audio/mpeg\" | \"audio/ogg\" | \"audio/wav\" | \"audio/webm\" | \"video/mp4\" | \"video/webm\" | \"video/ogg\" | \"font/woff\" | \"font/woff2\" | \"font/ttf\" | \"font/otf\" | \"multipart/form-data\" | (string & {});\nexport type ParsedTypes = \"string\" | \"number\" | \"bigint\" | \"boolean\" | \"symbol\" | \"undefined\" | \"object\" | \"function\" | \"file\" | \"date\" | \"array\" | \"map\" | \"set\" | \"nan\" | \"null\" | \"promise\";\nexport type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? true : false;\nexport type AssertNotEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2 ? false : true;\nexport type AssertExtends<T, U> = T extends U ? T : never;\nexport type IsAny<T> = 0 extends 1 & T ? true : false;\nexport type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;\nexport type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;\nexport type MakePartial<T, K extends keyof T> = Omit<T, K> & InexactPartial<Pick<T, K>>;\nexport type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;\nexport type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;\nexport type NoUndefined<T> = T extends undefined ? never : T;\nexport type Whatever = {} | undefined | null;\nexport type LoosePartial<T extends object> = InexactPartial<T> & {\n    [k: string]: unknown;\n};\nexport type Mask<Keys extends PropertyKey> = {\n    [K in Keys]?: true;\n};\nexport type Writeable<T> = {\n    -readonly [P in keyof T]: T[P];\n} & {};\nexport type InexactPartial<T> = {\n    [P in keyof T]?: T[P] | undefined;\n};\nexport type EmptyObject = Record<string, never>;\nexport type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {\n    readonly [Symbol.toStringTag]: string;\n} | Date | Error | Generator | Promise<unknown> | RegExp;\nexport 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>;\nexport type SomeObject = Record<PropertyKey, any>;\nexport type Identity<T> = T;\nexport type Flatten<T> = Identity<{\n    [k in keyof T]: T[k];\n}>;\nexport type Mapped<T> = {\n    [k in keyof T]: T[k];\n};\nexport type Prettify<T> = {\n    [K in keyof T]: T[K];\n} & {};\nexport type NoNeverKeys<T> = {\n    [k in keyof T]: [T[k]] extends [never] ? never : k;\n}[keyof T];\nexport type NoNever<T> = Identity<{\n    [k in NoNeverKeys<T>]: k extends keyof T ? T[k] : never;\n}>;\nexport type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A & keyof B extends never ? A & B : {\n    [K in keyof A as K extends keyof B ? never : K]: A[K];\n} & {\n    [K in keyof B]: B[K];\n}>;\nexport type TupleItems = ReadonlyArray<schemas.SomeType>;\nexport type AnyFunc = (...args: any[]) => any;\nexport type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;\nexport type MaybeAsync<T> = T | Promise<T>;\nexport type KeyOf<T> = keyof OmitIndexSignature<T>;\nexport type OmitIndexSignature<T> = {\n    [K in keyof T as string extends K ? never : K extends string ? K : never]: T[K];\n};\nexport type ExtractIndexSignature<T> = {\n    [K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];\n};\nexport type Keys<T extends object> = keyof OmitIndexSignature<T>;\nexport type SchemaClass<T extends schemas.SomeType> = {\n    new (def: T[\"_zod\"][\"def\"]): T;\n};\nexport type EnumValue = string | number;\nexport type EnumLike = Readonly<Record<string, EnumValue>>;\nexport type ToEnum<T extends EnumValue> = Flatten<{\n    [k in T]: k;\n}>;\nexport type KeysEnum<T extends object> = ToEnum<Exclude<keyof T, symbol>>;\nexport type KeysArray<T extends object> = Flatten<(keyof T & string)[]>;\nexport type Literal = string | number | bigint | boolean | null | undefined;\nexport type LiteralArray = Array<Literal>;\nexport type Primitive = string | number | symbol | bigint | boolean | null | undefined;\nexport type PrimitiveArray = Array<Primitive>;\nexport type HasSize = {\n    size: number;\n};\nexport type HasLength = {\n    length: number;\n};\nexport type Numeric = number | bigint | Date;\nexport type SafeParseResult<T> = SafeParseSuccess<T> | SafeParseError<T>;\nexport type SafeParseSuccess<T> = {\n    success: true;\n    data: T;\n    error?: never;\n};\nexport type SafeParseError<T> = {\n    success: false;\n    data?: never;\n    error: errors.$ZodError<T>;\n};\nexport type PropValues = Record<string, Set<Primitive>>;\nexport type PrimitiveSet = Set<Primitive>;\nexport declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;\nexport declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;\nexport declare function assertIs<T>(_arg: T): void;\nexport declare function assertNever(_x: never): never;\nexport declare function assert<T>(_: any): asserts _ is T;\nexport declare function getEnumValues(entries: EnumLike): EnumValue[];\nexport declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;\nexport declare function jsonStringifyReplacer(_: string, value: any): any;\nexport declare function cached<T>(getter: () => T): {\n    value: T;\n};\nexport declare function nullish(input: any): boolean;\nexport declare function cleanRegex(source: string): string;\nexport declare function floatSafeRemainder(val: number, step: number): number;\nexport declare function defineLazy<T, K extends keyof T>(object: T, key: K, getter: () => T[K]): void;\nexport declare function objectClone(obj: object): any;\nexport declare function assignProp<T extends object, K extends PropertyKey>(target: T, prop: K, value: K extends keyof T ? T[K] : any): void;\nexport declare function mergeDefs(...defs: Record<string, any>[]): any;\nexport declare function cloneDef(schema: schemas.$ZodType): any;\nexport declare function getElementAtPath(obj: any, path: (string | number)[] | null | undefined): any;\nexport declare function promiseAllObject<T extends object>(promisesObj: T): Promise<{\n    [k in keyof T]: Awaited<T[k]>;\n}>;\nexport declare function randomString(length?: number): string;\nexport declare function esc(str: string): string;\nexport declare function slugify(input: string): string;\nexport declare const captureStackTrace: (targetObject: object, constructorOpt?: Function) => void;\nexport declare function isObject(data: any): data is Record<PropertyKey, unknown>;\nexport declare const allowsEval: {\n    value: boolean;\n};\nexport declare function isPlainObject(o: any): o is Record<PropertyKey, unknown>;\nexport declare function shallowClone(o: any): any;\nexport declare function numKeys(data: any): number;\nexport declare const getParsedType: (data: any) => ParsedTypes;\nexport declare const propertyKeyTypes: Set<string>;\nexport declare const primitiveTypes: Set<string>;\nexport declare function escapeRegex(str: string): string;\nexport declare function clone<T extends schemas.$ZodType>(inst: T, def?: T[\"_zod\"][\"def\"], params?: {\n    parent: boolean;\n}): T;\nexport type EmptyToNever<T> = keyof T extends never ? never : T;\nexport type Normalize<T> = T extends undefined ? never : T extends Record<any, any> ? Flatten<{\n    [k in keyof Omit<T, \"error\" | \"message\">]: T[k];\n} & (\"error\" extends keyof T ? {\n    error?: Exclude<T[\"error\"], string>;\n} : unknown)> : never;\nexport declare function normalizeParams<T>(_params: T): Normalize<T>;\nexport declare function createTransparentProxy<T extends object>(getter: () => T): T;\nexport declare function stringifyPrimitive(value: any): string;\nexport declare function optionalKeys(shape: schemas.$ZodShape): string[];\nexport type CleanKey<T extends PropertyKey> = T extends `?${infer K}` ? K : T extends `${infer K}?` ? K : T;\nexport type ToCleanMap<T extends schemas.$ZodLooseShape> = {\n    [k in keyof T]: k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k;\n};\nexport type FromCleanMap<T extends schemas.$ZodLooseShape> = {\n    [k in keyof T as k extends `?${infer K}` ? K : k extends `${infer K}?` ? K : k]: k;\n};\nexport declare const NUMBER_FORMAT_RANGES: Record<checks.$ZodNumberFormats, [number, number]>;\nexport declare const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, bigint]>;\nexport declare function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any;\nexport declare function omit(schema: schemas.$ZodObject, mask: object): any;\nexport declare function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;\nexport declare function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any;\nexport declare function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any;\nexport declare function partial(Class: SchemaClass<schemas.$ZodOptional> | null, schema: schemas.$ZodObject, mask: object | undefined): any;\nexport declare function required(Class: SchemaClass<schemas.$ZodNonOptional>, schema: schemas.$ZodObject, mask: object | undefined): any;\nexport type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;\nexport declare function aborted(x: schemas.ParsePayload, startIndex?: number): boolean;\nexport declare function prefixIssues(path: PropertyKey, issues: errors.$ZodRawIssue[]): errors.$ZodRawIssue[];\nexport declare function unwrapMessage(message: string | {\n    message: string;\n} | undefined | null): string | undefined;\nexport declare function finalizeIssue(iss: errors.$ZodRawIssue, ctx: schemas.ParseContextInternal | undefined, config: $ZodConfig): errors.$ZodIssue;\nexport declare function getSizableOrigin(input: any): \"set\" | \"map\" | \"file\" | \"unknown\";\nexport declare function getLengthableOrigin(input: any): \"array\" | \"string\" | \"unknown\";\nexport declare function parsedType(data: unknown): errors.$ZodInvalidTypeExpected;\nexport declare function issue(_iss: string, input: any, inst: any): errors.$ZodRawIssue;\nexport declare function issue(_iss: errors.$ZodRawIssue): errors.$ZodRawIssue;\nexport declare function cleanEnum(obj: Record<string, EnumValue>): EnumValue[];\nexport declare function base64ToUint8Array(base64: string): InstanceType<typeof Uint8Array>;\nexport declare function uint8ArrayToBase64(bytes: Uint8Array): string;\nexport declare function base64urlToUint8Array(base64url: string): InstanceType<typeof Uint8Array>;\nexport declare function uint8ArrayToBase64url(bytes: Uint8Array): string;\nexport declare function hexToUint8Array(hex: string): InstanceType<typeof Uint8Array>;\nexport declare function uint8ArrayToHex(bytes: Uint8Array): string;\nexport declare abstract class Class {\n    constructor(..._args: any[]);\n}\n",
+	"file:///node_modules/zod/v4/core/versions.d.ts": "export declare const version: {\n    readonly major: 4;\n    readonly minor: 3;\n    readonly patch: number;\n};\n",
+	"file:///node_modules/zod/v4/index.d.ts": "import z4 from \"./classic/index.js\";\nexport * from \"./classic/index.js\";\nexport default z4;\n",
+	"file:///node_modules/zod/v4/locales/ar.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/az.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/be.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/bg.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ca.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/cs.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/da.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/de.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/en.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/eo.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/es.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/fa.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/fi.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/fr-CA.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/fr.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/he.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/hu.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/hy.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/id.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/index.d.ts": "export { default as ar } from \"./ar.js\";\nexport { default as az } from \"./az.js\";\nexport { default as be } from \"./be.js\";\nexport { default as bg } from \"./bg.js\";\nexport { default as ca } from \"./ca.js\";\nexport { default as cs } from \"./cs.js\";\nexport { default as da } from \"./da.js\";\nexport { default as de } from \"./de.js\";\nexport { default as en } from \"./en.js\";\nexport { default as eo } from \"./eo.js\";\nexport { default as es } from \"./es.js\";\nexport { default as fa } from \"./fa.js\";\nexport { default as fi } from \"./fi.js\";\nexport { default as fr } from \"./fr.js\";\nexport { default as frCA } from \"./fr-CA.js\";\nexport { default as he } from \"./he.js\";\nexport { default as hu } from \"./hu.js\";\nexport { default as hy } from \"./hy.js\";\nexport { default as id } from \"./id.js\";\nexport { default as is } from \"./is.js\";\nexport { default as it } from \"./it.js\";\nexport { default as ja } from \"./ja.js\";\nexport { default as ka } from \"./ka.js\";\nexport { default as kh } from \"./kh.js\";\nexport { default as km } from \"./km.js\";\nexport { default as ko } from \"./ko.js\";\nexport { default as lt } from \"./lt.js\";\nexport { default as mk } from \"./mk.js\";\nexport { default as ms } from \"./ms.js\";\nexport { default as nl } from \"./nl.js\";\nexport { default as no } from \"./no.js\";\nexport { default as ota } from \"./ota.js\";\nexport { default as ps } from \"./ps.js\";\nexport { default as pl } from \"./pl.js\";\nexport { default as pt } from \"./pt.js\";\nexport { default as ru } from \"./ru.js\";\nexport { default as sl } from \"./sl.js\";\nexport { default as sv } from \"./sv.js\";\nexport { default as ta } from \"./ta.js\";\nexport { default as th } from \"./th.js\";\nexport { default as tr } from \"./tr.js\";\nexport { default as ua } from \"./ua.js\";\nexport { default as uk } from \"./uk.js\";\nexport { default as ur } from \"./ur.js\";\nexport { default as uz } from \"./uz.js\";\nexport { default as vi } from \"./vi.js\";\nexport { default as zhCN } from \"./zh-CN.js\";\nexport { default as zhTW } from \"./zh-TW.js\";\nexport { default as yo } from \"./yo.js\";\n",
+	"file:///node_modules/zod/v4/locales/is.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/it.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ja.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ka.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/kh.d.ts": "import type * as errors from \"../core/errors.js\";\n/** @deprecated Use `km` instead. */\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/km.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ko.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/lt.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/mk.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ms.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/nl.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/no.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ota.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/pl.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ps.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/pt.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ru.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/sl.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/sv.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ta.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/th.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/tr.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ua.d.ts": "import type * as errors from \"../core/errors.js\";\n/** @deprecated Use `uk` instead. */\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/uk.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/ur.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/uz.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/vi.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/yo.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/zh-CN.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/locales/zh-TW.d.ts": "import type * as errors from \"../core/errors.js\";\nexport default function (): {\n    localeError: errors.$ZodErrorMap;\n};\n",
+	"file:///node_modules/zod/v4/mini/checks.d.ts": "export { _lt as lt, _lte as lte, _lte as maximum, _gt as gt, _gte as gte, _gte as minimum, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, } from \"../core/index.js\";\n",
+	"file:///node_modules/zod/v4/mini/coerce.d.ts": "import * as core from \"../core/index.js\";\nimport * as schemas from \"./schemas.js\";\nexport declare function string<T = unknown>(params?: string | core.$ZodStringParams): schemas.ZodMiniString<T>;\nexport declare function number<T = unknown>(params?: string | core.$ZodNumberParams): schemas.ZodMiniNumber<T>;\nexport declare function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): schemas.ZodMiniBoolean<T>;\nexport declare function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): schemas.ZodMiniBigInt<T>;\nexport declare function date<T = unknown>(params?: string | core.$ZodDateParams): schemas.ZodMiniDate<T>;\n",
+	"file:///node_modules/zod/v4/mini/external.d.ts": "export * as core from \"../core/index.js\";\nexport * from \"./parse.js\";\nexport * from \"./schemas.js\";\nexport * from \"./checks.js\";\nexport type { infer, output, input } from \"../core/index.js\";\nexport { globalRegistry, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from \"../core/index.js\";\nexport { toJSONSchema } from \"../core/json-schema-processors.js\";\nexport * as locales from \"../locales/index.js\";\n/** A special constant with type `never` */\nexport * as iso from \"./iso.js\";\nexport { ZodMiniISODateTime, ZodMiniISODate, ZodMiniISOTime, ZodMiniISODuration, } from \"./iso.js\";\nexport * as coerce from \"./coerce.js\";\n",
+	"file:///node_modules/zod/v4/mini/index.d.ts": "import * as z from \"./external.js\";\nexport * from \"./external.js\";\nexport { z };\n",
+	"file:///node_modules/zod/v4/mini/iso.d.ts": "import * as core from \"../core/index.js\";\nimport * as schemas from \"./schemas.js\";\nexport interface ZodMiniISODateTime extends schemas.ZodMiniStringFormat<\"datetime\"> {\n    _zod: core.$ZodISODateTimeInternals;\n}\nexport declare const ZodMiniISODateTime: core.$constructor<ZodMiniISODateTime>;\nexport declare function datetime(params?: string | core.$ZodISODateTimeParams): ZodMiniISODateTime;\nexport interface ZodMiniISODate extends schemas.ZodMiniStringFormat<\"date\"> {\n    _zod: core.$ZodISODateInternals;\n}\nexport declare const ZodMiniISODate: core.$constructor<ZodMiniISODate>;\nexport declare function date(params?: string | core.$ZodISODateParams): ZodMiniISODate;\nexport interface ZodMiniISOTime extends schemas.ZodMiniStringFormat<\"time\"> {\n    _zod: core.$ZodISOTimeInternals;\n}\nexport declare const ZodMiniISOTime: core.$constructor<ZodMiniISOTime>;\nexport declare function time(params?: string | core.$ZodISOTimeParams): ZodMiniISOTime;\nexport interface ZodMiniISODuration extends schemas.ZodMiniStringFormat<\"duration\"> {\n    _zod: core.$ZodISODurationInternals;\n}\nexport declare const ZodMiniISODuration: core.$constructor<ZodMiniISODuration>;\nexport declare function duration(params?: string | core.$ZodISODurationParams): ZodMiniISODuration;\n",
+	"file:///node_modules/zod/v4/mini/parse.d.ts": "export { parse, safeParse, parseAsync, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync, } from \"../core/index.js\";\n",
+	"file:///node_modules/zod/v4/mini/schemas.d.ts": "import * as core from \"../core/index.js\";\nimport * as util from \"../core/util.js\";\ntype SomeType = core.SomeType;\nexport interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {\n    type: Internals[\"def\"][\"type\"];\n    check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;\n    with(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;\n    clone(def?: Internals[\"def\"], params?: {\n        parent: boolean;\n    }): this;\n    register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R[\"_schema\"] ? undefined extends R[\"_meta\"] ? [core.$replace<R[\"_meta\"], this>?] : [core.$replace<R[\"_meta\"], this>] : [\"Incompatible schema\"]): this;\n    brand<T extends PropertyKey = PropertyKey, Dir extends \"in\" | \"out\" | \"inout\" = \"out\">(value?: T): PropertyKey extends T ? this : core.$ZodBranded<this, T, Dir>;\n    def: Internals[\"def\"];\n    parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;\n    safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): util.SafeParseResult<core.output<this>>;\n    parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;\n    safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<util.SafeParseResult<core.output<this>>>;\n    apply<T>(fn: (schema: this) => T): T;\n}\ninterface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<any, any, Internals> {\n}\nexport declare const ZodMiniType: core.$constructor<ZodMiniType>;\nexport interface _ZodMiniString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>> extends _ZodMiniType<T>, core.$ZodString<T[\"input\"]> {\n    _zod: T;\n}\nexport interface ZodMiniString<Input = unknown> extends _ZodMiniString<core.$ZodStringInternals<Input>>, core.$ZodString<Input> {\n}\nexport declare const ZodMiniString: core.$constructor<ZodMiniString>;\nexport declare function string(params?: string | core.$ZodStringParams): ZodMiniString<string>;\nexport interface ZodMiniStringFormat<Format extends string = string> extends _ZodMiniString<core.$ZodStringFormatInternals<Format>>, core.$ZodStringFormat<Format> {\n}\nexport declare const ZodMiniStringFormat: core.$constructor<ZodMiniStringFormat>;\nexport interface ZodMiniEmail extends _ZodMiniString<core.$ZodEmailInternals> {\n}\nexport declare const ZodMiniEmail: core.$constructor<ZodMiniEmail>;\nexport declare function email(params?: string | core.$ZodEmailParams): ZodMiniEmail;\nexport interface ZodMiniGUID extends _ZodMiniString<core.$ZodGUIDInternals> {\n}\nexport declare const ZodMiniGUID: core.$constructor<ZodMiniGUID>;\nexport declare function guid(params?: string | core.$ZodGUIDParams): ZodMiniGUID;\nexport interface ZodMiniUUID extends _ZodMiniString<core.$ZodUUIDInternals> {\n}\nexport declare const ZodMiniUUID: core.$constructor<ZodMiniUUID>;\nexport declare function uuid(params?: string | core.$ZodUUIDParams): ZodMiniUUID;\nexport declare function uuidv4(params?: string | core.$ZodUUIDv4Params): ZodMiniUUID;\nexport declare function uuidv6(params?: string | core.$ZodUUIDv6Params): ZodMiniUUID;\nexport declare function uuidv7(params?: string | core.$ZodUUIDv7Params): ZodMiniUUID;\nexport interface ZodMiniURL extends _ZodMiniString<core.$ZodURLInternals> {\n}\nexport declare const ZodMiniURL: core.$constructor<ZodMiniURL>;\nexport declare function url(params?: string | core.$ZodURLParams): ZodMiniURL;\nexport declare function httpUrl(params?: string | Omit<core.$ZodURLParams, \"protocol\" | \"hostname\">): ZodMiniURL;\nexport interface ZodMiniEmoji extends _ZodMiniString<core.$ZodEmojiInternals> {\n}\nexport declare const ZodMiniEmoji: core.$constructor<ZodMiniEmoji>;\nexport declare function emoji(params?: string | core.$ZodEmojiParams): ZodMiniEmoji;\nexport interface ZodMiniNanoID extends _ZodMiniString<core.$ZodNanoIDInternals> {\n}\nexport declare const ZodMiniNanoID: core.$constructor<ZodMiniNanoID>;\nexport declare function nanoid(params?: string | core.$ZodNanoIDParams): ZodMiniNanoID;\nexport interface ZodMiniCUID extends _ZodMiniString<core.$ZodCUIDInternals> {\n}\nexport declare const ZodMiniCUID: core.$constructor<ZodMiniCUID>;\nexport declare function cuid(params?: string | core.$ZodCUIDParams): ZodMiniCUID;\nexport interface ZodMiniCUID2 extends _ZodMiniString<core.$ZodCUID2Internals> {\n}\nexport declare const ZodMiniCUID2: core.$constructor<ZodMiniCUID2>;\nexport declare function cuid2(params?: string | core.$ZodCUID2Params): ZodMiniCUID2;\nexport interface ZodMiniULID extends _ZodMiniString<core.$ZodULIDInternals> {\n}\nexport declare const ZodMiniULID: core.$constructor<ZodMiniULID>;\nexport declare function ulid(params?: string | core.$ZodULIDParams): ZodMiniULID;\nexport interface ZodMiniXID extends _ZodMiniString<core.$ZodXIDInternals> {\n}\nexport declare const ZodMiniXID: core.$constructor<ZodMiniXID>;\nexport declare function xid(params?: string | core.$ZodXIDParams): ZodMiniXID;\nexport interface ZodMiniKSUID extends _ZodMiniString<core.$ZodKSUIDInternals> {\n}\nexport declare const ZodMiniKSUID: core.$constructor<ZodMiniKSUID>;\nexport declare function ksuid(params?: string | core.$ZodKSUIDParams): ZodMiniKSUID;\nexport interface ZodMiniIPv4 extends _ZodMiniString<core.$ZodIPv4Internals> {\n}\nexport declare const ZodMiniIPv4: core.$constructor<ZodMiniIPv4>;\nexport declare function ipv4(params?: string | core.$ZodIPv4Params): ZodMiniIPv4;\nexport interface ZodMiniIPv6 extends _ZodMiniString<core.$ZodIPv6Internals> {\n}\nexport declare const ZodMiniIPv6: core.$constructor<ZodMiniIPv6>;\nexport declare function ipv6(params?: string | core.$ZodIPv6Params): ZodMiniIPv6;\nexport interface ZodMiniCIDRv4 extends _ZodMiniString<core.$ZodCIDRv4Internals> {\n}\nexport declare const ZodMiniCIDRv4: core.$constructor<ZodMiniCIDRv4>;\nexport declare function cidrv4(params?: string | core.$ZodCIDRv4Params): ZodMiniCIDRv4;\nexport interface ZodMiniCIDRv6 extends _ZodMiniString<core.$ZodCIDRv6Internals> {\n}\nexport declare const ZodMiniCIDRv6: core.$constructor<ZodMiniCIDRv6>;\nexport declare function cidrv6(params?: string | core.$ZodCIDRv6Params): ZodMiniCIDRv6;\nexport interface ZodMiniMAC extends _ZodMiniString<core.$ZodMACInternals> {\n}\nexport declare const ZodMiniMAC: core.$constructor<ZodMiniMAC>;\nexport declare function mac(params?: string | core.$ZodMACParams): ZodMiniMAC;\nexport interface ZodMiniBase64 extends _ZodMiniString<core.$ZodBase64Internals> {\n}\nexport declare const ZodMiniBase64: core.$constructor<ZodMiniBase64>;\nexport declare function base64(params?: string | core.$ZodBase64Params): ZodMiniBase64;\nexport interface ZodMiniBase64URL extends _ZodMiniString<core.$ZodBase64URLInternals> {\n}\nexport declare const ZodMiniBase64URL: core.$constructor<ZodMiniBase64URL>;\nexport declare function base64url(params?: string | core.$ZodBase64URLParams): ZodMiniBase64URL;\nexport interface ZodMiniE164 extends _ZodMiniString<core.$ZodE164Internals> {\n}\nexport declare const ZodMiniE164: core.$constructor<ZodMiniE164>;\nexport declare function e164(params?: string | core.$ZodE164Params): ZodMiniE164;\nexport interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {\n}\nexport declare const ZodMiniJWT: core.$constructor<ZodMiniJWT>;\nexport declare function jwt(params?: string | core.$ZodJWTParams): ZodMiniJWT;\nexport interface ZodMiniCustomStringFormat<Format extends string = string> extends ZodMiniStringFormat<Format>, core.$ZodCustomStringFormat<Format> {\n    _zod: core.$ZodCustomStringFormatInternals<Format>;\n}\nexport declare const ZodMiniCustomStringFormat: core.$constructor<ZodMiniCustomStringFormat>;\nexport declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp, _params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<Format>;\nexport declare function hostname(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<\"hostname\">;\nexport declare function hex(_params?: string | core.$ZodStringFormatParams): ZodMiniCustomStringFormat<\"hex\">;\nexport declare function hash<Alg extends util.HashAlgorithm, Enc extends util.HashEncoding = \"hex\">(alg: Alg, params?: {\n    enc?: Enc;\n} & core.$ZodStringFormatParams): ZodMiniCustomStringFormat<`${Alg}_${Enc}`>;\ninterface _ZodMiniNumber<T extends core.$ZodNumberInternals<unknown> = core.$ZodNumberInternals<unknown>> extends _ZodMiniType<T>, core.$ZodNumber<T[\"input\"]> {\n    _zod: T;\n}\nexport interface ZodMiniNumber<Input = unknown> extends _ZodMiniNumber<core.$ZodNumberInternals<Input>>, core.$ZodNumber<Input> {\n}\nexport declare const ZodMiniNumber: core.$constructor<ZodMiniNumber>;\nexport declare function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<number>;\nexport interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {\n}\nexport declare const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat>;\nexport declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;\nexport declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;\nexport declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;\nexport declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;\nexport declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;\nexport interface ZodMiniBoolean<T = unknown> extends _ZodMiniType<core.$ZodBooleanInternals<T>> {\n}\nexport declare const ZodMiniBoolean: core.$constructor<ZodMiniBoolean>;\nexport declare function boolean(params?: string | core.$ZodBooleanParams): ZodMiniBoolean<boolean>;\nexport interface ZodMiniBigInt<T = unknown> extends _ZodMiniType<core.$ZodBigIntInternals<T>>, core.$ZodBigInt<T> {\n}\nexport declare const ZodMiniBigInt: core.$constructor<ZodMiniBigInt>;\nexport declare function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<bigint>;\nexport interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {\n}\nexport declare const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat>;\nexport declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;\nexport declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;\nexport interface ZodMiniSymbol extends _ZodMiniType<core.$ZodSymbolInternals> {\n}\nexport declare const ZodMiniSymbol: core.$constructor<ZodMiniSymbol>;\nexport declare function symbol(params?: string | core.$ZodSymbolParams): ZodMiniSymbol;\nexport interface ZodMiniUndefined extends _ZodMiniType<core.$ZodUndefinedInternals> {\n}\nexport declare const ZodMiniUndefined: core.$constructor<ZodMiniUndefined>;\ndeclare function _undefined(params?: string | core.$ZodUndefinedParams): ZodMiniUndefined;\nexport { _undefined as undefined };\nexport interface ZodMiniNull extends _ZodMiniType<core.$ZodNullInternals> {\n}\nexport declare const ZodMiniNull: core.$constructor<ZodMiniNull>;\ndeclare function _null(params?: string | core.$ZodNullParams): ZodMiniNull;\nexport { _null as null };\nexport interface ZodMiniAny extends _ZodMiniType<core.$ZodAnyInternals> {\n}\nexport declare const ZodMiniAny: core.$constructor<ZodMiniAny>;\nexport declare function any(): ZodMiniAny;\nexport interface ZodMiniUnknown extends _ZodMiniType<core.$ZodUnknownInternals> {\n}\nexport declare const ZodMiniUnknown: core.$constructor<ZodMiniUnknown>;\nexport declare function unknown(): ZodMiniUnknown;\nexport interface ZodMiniNever extends _ZodMiniType<core.$ZodNeverInternals> {\n}\nexport declare const ZodMiniNever: core.$constructor<ZodMiniNever>;\nexport declare function never(params?: string | core.$ZodNeverParams): ZodMiniNever;\nexport interface ZodMiniVoid extends _ZodMiniType<core.$ZodVoidInternals> {\n}\nexport declare const ZodMiniVoid: core.$constructor<ZodMiniVoid>;\ndeclare function _void(params?: string | core.$ZodVoidParams): ZodMiniVoid;\nexport { _void as void };\nexport interface ZodMiniDate<T = unknown> extends _ZodMiniType<core.$ZodDateInternals<T>> {\n}\nexport declare const ZodMiniDate: core.$constructor<ZodMiniDate>;\nexport declare function date(params?: string | core.$ZodDateParams): ZodMiniDate<Date>;\nexport interface ZodMiniArray<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodArrayInternals<T>>, core.$ZodArray<T> {\n}\nexport declare const ZodMiniArray: core.$constructor<ZodMiniArray>;\nexport declare function array<T extends SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodMiniArray<T>;\nexport declare function keyof<T extends ZodMiniObject>(schema: T): ZodMiniEnum<util.KeysEnum<T[\"shape\"]>>;\nexport interface ZodMiniObject<\n/** @ts-ignore Cast variance */\nout Shape extends core.$ZodShape = core.$ZodShape, out Config extends core.$ZodObjectConfig = core.$strip> extends ZodMiniType<any, any, core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {\n    shape: Shape;\n}\nexport declare const ZodMiniObject: core.$constructor<ZodMiniObject>;\nexport declare function object<T extends core.$ZodLooseShape = Record<never, SomeType>>(shape?: T, params?: string | core.$ZodObjectParams): ZodMiniObject<T, core.$strip>;\nexport declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodMiniObject<T, core.$strict>;\nexport declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodMiniObject<T, core.$loose>;\nexport declare function extend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(schema: T, shape: U): ZodMiniObject<util.Extend<T[\"shape\"], U>, T[\"_zod\"][\"config\"]>;\nexport type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLooseShape> = {\n    [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];\n};\nexport declare function safeExtend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(schema: T, shape: SafeExtendShape<T[\"shape\"], U>): ZodMiniObject<util.Extend<T[\"shape\"], U>, T[\"_zod\"][\"config\"]>;\n/** @deprecated Identical to `z.extend(A, B)` */\nexport declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T[\"shape\"], U[\"shape\"]>, T[\"_zod\"][\"config\"]>;\nexport declare function pick<T extends ZodMiniObject, M extends util.Mask<keyof T[\"shape\"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T[\"shape\"]>, never>): ZodMiniObject<util.Flatten<Pick<T[\"shape\"], keyof T[\"shape\"] & keyof M>>, T[\"_zod\"][\"config\"]>;\nexport declare function omit<T extends ZodMiniObject, M extends util.Mask<keyof T[\"shape\"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T[\"shape\"]>, never>): ZodMiniObject<util.Flatten<Omit<T[\"shape\"], keyof M>>, T[\"_zod\"][\"config\"]>;\nexport declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{\n    [k in keyof T[\"shape\"]]: ZodMiniOptional<T[\"shape\"][k]>;\n}, T[\"_zod\"][\"config\"]>;\nexport declare function partial<T extends ZodMiniObject, M extends util.Mask<keyof T[\"shape\"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T[\"shape\"]>, never>): ZodMiniObject<{\n    [k in keyof T[\"shape\"]]: k extends keyof M ? ZodMiniOptional<T[\"shape\"][k]> : T[\"shape\"][k];\n}, T[\"_zod\"][\"config\"]>;\nexport type RequiredInterfaceShape<Shape extends core.$ZodLooseShape, Keys extends PropertyKey = keyof Shape> = util.Identity<{\n    [k in keyof Shape as k extends Keys ? k : never]: ZodMiniNonOptional<Shape[k]>;\n} & {\n    [k in keyof Shape as k extends Keys ? never : k]: Shape[k];\n}>;\nexport declare function required<T extends ZodMiniObject>(schema: T): ZodMiniObject<{\n    [k in keyof T[\"shape\"]]: ZodMiniNonOptional<T[\"shape\"][k]>;\n}, T[\"_zod\"][\"config\"]>;\nexport declare function required<T extends ZodMiniObject, M extends util.Mask<keyof T[\"shape\"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T[\"shape\"]>, never>): ZodMiniObject<util.Extend<T[\"shape\"], {\n    [k in keyof M & keyof T[\"shape\"]]: ZodMiniNonOptional<T[\"shape\"][k]>;\n}>, T[\"_zod\"][\"config\"]>;\nexport declare function catchall<T extends ZodMiniObject, U extends SomeType>(inst: T, catchall: U): ZodMiniObject<T[\"shape\"], core.$catchall<U>>;\nexport interface ZodMiniUnion<T extends readonly SomeType[] = readonly core.$ZodType[]> extends _ZodMiniType<core.$ZodUnionInternals<T>> {\n}\nexport declare const ZodMiniUnion: core.$constructor<ZodMiniUnion>;\nexport declare function union<const T extends readonly SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodMiniUnion<T>;\nexport interface ZodMiniXor<T extends readonly SomeType[] = readonly core.$ZodType[]> extends _ZodMiniType<core.$ZodXorInternals<T>> {\n}\nexport declare const ZodMiniXor: core.$constructor<ZodMiniXor>;\n/** Creates an exclusive union (XOR) where exactly one option must match.\n * Unlike regular unions that succeed when any option matches, xor fails if\n * zero or more than one option matches the input. */\nexport declare function xor<const T extends readonly SomeType[]>(options: T, params?: string | core.$ZodXorParams): ZodMiniXor<T>;\nexport interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] = readonly core.$ZodType[], Disc extends string = string> extends ZodMiniUnion<Options> {\n    _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;\n}\nexport declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;\nexport declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;\nexport interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {\n}\nexport declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;\nexport declare function intersection<T extends SomeType, U extends SomeType>(left: T, right: U): ZodMiniIntersection<T, U>;\nexport interface ZodMiniTuple<T extends util.TupleItems = readonly core.$ZodType[], Rest extends SomeType | null = core.$ZodType | null> extends _ZodMiniType<core.$ZodTupleInternals<T, Rest>> {\n}\nexport declare const ZodMiniTuple: core.$constructor<ZodMiniTuple>;\nexport declare function tuple<const T extends readonly [SomeType, ...SomeType[]]>(items: T, params?: string | core.$ZodTupleParams): ZodMiniTuple<T, null>;\nexport declare function tuple<const T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(items: T, rest: Rest, params?: string | core.$ZodTupleParams): ZodMiniTuple<T, Rest>;\nexport declare function tuple(items: [], params?: string | core.$ZodTupleParams): ZodMiniTuple<[], null>;\nexport interface ZodMiniRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodRecordInternals<Key, Value>> {\n}\nexport declare const ZodMiniRecord: core.$constructor<ZodMiniRecord>;\nexport declare function record<Key extends core.$ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodMiniRecord<Key, Value>;\nexport declare function partialRecord<Key extends core.$ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodMiniRecord<Key & core.$partial, Value>;\nexport declare function looseRecord<Key extends core.$ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodRecordParams): ZodMiniRecord<Key, Value>;\nexport interface ZodMiniMap<Key extends SomeType = core.$ZodType, Value extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodMapInternals<Key, Value>> {\n}\nexport declare const ZodMiniMap: core.$constructor<ZodMiniMap>;\nexport declare function map<Key extends SomeType, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMiniMap<Key, Value>;\nexport interface ZodMiniSet<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodSetInternals<T>> {\n}\nexport declare const ZodMiniSet: core.$constructor<ZodMiniSet>;\nexport declare function set<Value extends SomeType>(valueType: Value, params?: string | core.$ZodSetParams): ZodMiniSet<Value>;\nexport interface ZodMiniEnum<T extends util.EnumLike = util.EnumLike> extends _ZodMiniType<core.$ZodEnumInternals<T>> {\n    options: Array<T[keyof T]>;\n}\nexport declare const ZodMiniEnum: core.$constructor<ZodMiniEnum>;\ndeclare function _enum<const T extends readonly string[]>(values: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<util.ToEnum<T[number]>>;\ndeclare function _enum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<T>;\nexport { _enum as enum };\n/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.\n *\n * ```ts\n * enum Colors { red, green, blue }\n * z.enum(Colors);\n * ```\n */\nexport declare function nativeEnum<T extends util.EnumLike>(entries: T, params?: string | core.$ZodEnumParams): ZodMiniEnum<T>;\nexport interface ZodMiniLiteral<T extends util.Literal = util.Literal> extends _ZodMiniType<core.$ZodLiteralInternals<T>> {\n}\nexport declare const ZodMiniLiteral: core.$constructor<ZodMiniLiteral>;\nexport declare function literal<const T extends ReadonlyArray<util.Literal>>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T[number]>;\nexport declare function literal<const T extends util.Literal>(value: T, params?: string | core.$ZodLiteralParams): ZodMiniLiteral<T>;\nexport interface ZodMiniFile extends _ZodMiniType<core.$ZodFileInternals> {\n}\nexport declare const ZodMiniFile: core.$constructor<ZodMiniFile>;\nexport declare function file(params?: string | core.$ZodFileParams): ZodMiniFile;\nexport interface ZodMiniTransform<O = unknown, I = unknown> extends _ZodMiniType<core.$ZodTransformInternals<O, I>> {\n}\nexport declare const ZodMiniTransform: core.$constructor<ZodMiniTransform>;\nexport declare function transform<I = unknown, O = I>(fn: (input: I, ctx: core.ParsePayload) => O): ZodMiniTransform<Awaited<O>, I>;\nexport interface ZodMiniOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodOptionalInternals<T>>, core.$ZodOptional<T> {\n}\nexport declare const ZodMiniOptional: core.$constructor<ZodMiniOptional>;\nexport declare function optional<T extends SomeType>(innerType: T): ZodMiniOptional<T>;\nexport interface ZodMiniExactOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodExactOptionalInternals<T>>, core.$ZodExactOptional<T> {\n}\nexport declare const ZodMiniExactOptional: core.$constructor<ZodMiniExactOptional>;\nexport declare function exactOptional<T extends SomeType>(innerType: T): ZodMiniExactOptional<T>;\nexport interface ZodMiniNullable<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodNullableInternals<T>> {\n}\nexport declare const ZodMiniNullable: core.$constructor<ZodMiniNullable>;\nexport declare function nullable<T extends SomeType>(innerType: T): ZodMiniNullable<T>;\nexport declare function nullish<T extends SomeType>(innerType: T): ZodMiniOptional<ZodMiniNullable<T>>;\nexport interface ZodMiniDefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodDefaultInternals<T>> {\n}\nexport declare const ZodMiniDefault: core.$constructor<ZodMiniDefault>;\nexport declare function _default<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)): ZodMiniDefault<T>;\nexport interface ZodMiniPrefault<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPrefaultInternals<T>> {\n}\nexport declare const ZodMiniPrefault: core.$constructor<ZodMiniPrefault>;\nexport declare function prefault<T extends SomeType>(innerType: T, defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)): ZodMiniPrefault<T>;\nexport interface ZodMiniNonOptional<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodNonOptionalInternals<T>> {\n}\nexport declare const ZodMiniNonOptional: core.$constructor<ZodMiniNonOptional>;\nexport declare function nonoptional<T extends SomeType>(innerType: T, params?: string | core.$ZodNonOptionalParams): ZodMiniNonOptional<T>;\nexport interface ZodMiniSuccess<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodSuccessInternals<T>> {\n}\nexport declare const ZodMiniSuccess: core.$constructor<ZodMiniSuccess>;\nexport declare function success<T extends SomeType>(innerType: T): ZodMiniSuccess<T>;\nexport interface ZodMiniCatch<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodCatchInternals<T>> {\n}\nexport declare const ZodMiniCatch: core.$constructor<ZodMiniCatch>;\ndeclare function _catch<T extends SomeType>(innerType: T, catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)): ZodMiniCatch<T>;\nexport { _catch as catch };\nexport interface ZodMiniNaN extends _ZodMiniType<core.$ZodNaNInternals> {\n}\nexport declare const ZodMiniNaN: core.$constructor<ZodMiniNaN>;\nexport declare function nan(params?: string | core.$ZodNaNParams): ZodMiniNaN;\nexport interface ZodMiniPipe<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPipeInternals<A, B>> {\n}\nexport declare const ZodMiniPipe: core.$constructor<ZodMiniPipe>;\nexport declare function pipe<const A extends SomeType, B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodMiniPipe<A, B>;\nexport interface ZodMiniCodec<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends ZodMiniPipe<A, B>, core.$ZodCodec<A, B> {\n    _zod: core.$ZodCodecInternals<A, B>;\n    def: core.$ZodCodecDef<A, B>;\n}\nexport declare const ZodMiniCodec: core.$constructor<ZodMiniCodec>;\nexport declare function codec<const A extends SomeType, B extends core.SomeType = core.$ZodType>(in_: A, out: B, params: {\n    decode: (value: core.output<A>, payload: core.ParsePayload<core.output<A>>) => core.util.MaybeAsync<core.input<B>>;\n    encode: (value: core.input<B>, payload: core.ParsePayload<core.input<B>>) => core.util.MaybeAsync<core.output<A>>;\n}): ZodMiniCodec<A, B>;\nexport interface ZodMiniReadonly<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodReadonlyInternals<T>> {\n}\nexport declare const ZodMiniReadonly: core.$constructor<ZodMiniReadonly>;\nexport declare function readonly<T extends SomeType>(innerType: T): ZodMiniReadonly<T>;\nexport interface ZodMiniTemplateLiteral<Template extends string = string> extends _ZodMiniType<core.$ZodTemplateLiteralInternals<Template>> {\n}\nexport declare const ZodMiniTemplateLiteral: core.$constructor<ZodMiniTemplateLiteral>;\nexport declare function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[]>(parts: Parts, params?: string | core.$ZodTemplateLiteralParams): ZodMiniTemplateLiteral<core.$PartsToTemplateLiteral<Parts>>;\nexport interface ZodMiniLazy<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodLazyInternals<T>> {\n}\nexport declare const ZodMiniLazy: core.$constructor<ZodMiniLazy>;\ndeclare function _lazy<T extends SomeType>(getter: () => T): ZodMiniLazy<T>;\nexport { _lazy as lazy };\nexport interface ZodMiniPromise<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodPromiseInternals<T>> {\n}\nexport declare const ZodMiniPromise: core.$constructor<ZodMiniPromise>;\nexport declare function promise<T extends SomeType>(innerType: T): ZodMiniPromise<T>;\nexport interface ZodMiniCustom<O = unknown, I = unknown> extends _ZodMiniType<core.$ZodCustomInternals<O, I>> {\n}\nexport declare const ZodMiniCustom: core.$constructor<ZodMiniCustom>;\nexport declare function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O>;\nexport declare function custom<O = unknown, I = O>(fn?: (data: O) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodMiniCustom<O, I>;\nexport declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;\nexport declare function superRefine<T>(fn: (arg: T, payload: core.$RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T>;\nexport declare const describe: typeof core.describe;\nexport declare const meta: typeof core.meta;\ndeclare abstract class Class {\n    constructor(..._args: any[]);\n}\ndeclare function _instanceof<T extends typeof Class>(cls: T, params?: core.$ZodCustomParams): ZodMiniCustom<InstanceType<T>, InstanceType<T>>;\nexport { _instanceof as instanceof };\nexport declare const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodMiniCodec<ZodMiniString, ZodMiniBoolean>;\nexport type _ZodMiniJSONSchema = ZodMiniUnion<[\n    ZodMiniString,\n    ZodMiniNumber,\n    ZodMiniBoolean,\n    ZodMiniNull,\n    ZodMiniArray<ZodMiniJSONSchema>,\n    ZodMiniRecord<ZodMiniString<string>, ZodMiniJSONSchema>\n]>;\nexport type _ZodMiniJSONSchemaInternals = _ZodMiniJSONSchema[\"_zod\"];\nexport interface ZodMiniJSONSchemaInternals extends _ZodMiniJSONSchemaInternals {\n    output: util.JSONType;\n    input: util.JSONType;\n}\nexport interface ZodMiniJSONSchema extends _ZodMiniJSONSchema {\n    _zod: ZodMiniJSONSchemaInternals;\n}\nexport declare function json(): ZodMiniJSONSchema;\nexport interface ZodMiniFunction<Args extends core.$ZodFunctionIn = core.$ZodFunctionIn, Returns extends core.$ZodFunctionOut = core.$ZodFunctionOut> extends _ZodMiniType<core.$ZodFunctionInternals<Args, Returns>>, core.$ZodFunction<Args, Returns> {\n    _def: core.$ZodFunctionDef<Args, Returns>;\n    _input: core.$InferInnerFunctionType<Args, Returns>;\n    _output: core.$InferOuterFunctionType<Args, Returns>;\n    input<const Items extends util.TupleItems, const Rest extends core.$ZodFunctionOut = core.$ZodFunctionOut>(args: Items, rest?: Rest): ZodMiniFunction<ZodMiniTuple<Items, Rest>, Returns>;\n    input<NewArgs extends core.$ZodFunctionIn>(args: NewArgs): ZodMiniFunction<NewArgs, Returns>;\n    input(...args: any[]): ZodMiniFunction<any, Returns>;\n    output<NewReturns extends core.$ZodFunctionOut>(output: NewReturns): ZodMiniFunction<Args, NewReturns>;\n}\nexport declare const ZodMiniFunction: core.$constructor<ZodMiniFunction>;\nexport declare function _function(): ZodMiniFunction;\nexport declare function _function<const In extends Array<SomeType> = Array<SomeType>>(params: {\n    input: In;\n}): ZodMiniFunction<ZodMiniTuple<In, null>, core.$ZodFunctionOut>;\nexport declare function _function<const In extends Array<SomeType> = Array<SomeType>, const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {\n    input: In;\n    output: Out;\n}): ZodMiniFunction<ZodMiniTuple<In, null>, Out>;\nexport declare function _function<const In extends core.$ZodFunctionIn = core.$ZodFunctionIn>(params: {\n    input: In;\n}): ZodMiniFunction<In, core.$ZodFunctionOut>;\nexport declare function _function<const Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params: {\n    output: Out;\n}): ZodMiniFunction<core.$ZodFunctionIn, Out>;\nexport declare function _function<In extends core.$ZodFunctionIn = core.$ZodFunctionIn, Out extends core.$ZodFunctionOut = core.$ZodFunctionOut>(params?: {\n    input: In;\n    output: Out;\n}): ZodMiniFunction<In, Out>;\nexport { _function as function };\n"
+};
+
 const editorTypes_get = defineEventHandler((event) => {
   setHeader(event, "Cache-Control", "public, max-age=3600");
-  cachedTypes || (cachedTypes = (async () => {
-    const files = {};
-    await collect(join(zodRoot, "v4"), files);
-    return files;
-  })());
-  return cachedTypes;
+  return editorTypes;
 });
 
 export { editorTypes_get as default };