@agimon-ai/doompi-web-components 0.0.1-alpha.8 → 0.0.1-alpha.80

package/dist/node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/schemas.d.mts

@@ -0,0 +1,775 @@
+import { StandardSchemaWithJSONProps } from "../core/standard-schema.mjs";
+import { $ZodRegistry, $replace, GlobalMeta } from "../core/registries.mjs";
+import { ToJSONSchemaParams, ZodStandardJSONSchemaPayload } from "../core/to-json-schema.mjs";
+import { Class, EnumLike, Extend, Flatten, HashAlgorithm, HashEncoding, JSONType, KeysEnum, Literal, Mask, MaybeAsync, MimeTypes, NoUndefined, ToEnum, TupleItems, Writeable, util_d_exports } from "../core/util.mjs";
+import { $InferInnerFunctionType, $InferObjectInput, $InferOuterFunctionType, $PartsToTemplateLiteral, $ZodAnyInternals, $ZodArray, $ZodArrayInternals, $ZodBase64Internals, $ZodBase64URLInternals, $ZodBigIntFormatInternals, $ZodBigIntInternals, $ZodBooleanInternals, $ZodCIDRv4Internals, $ZodCIDRv6Internals, $ZodCUID2Internals, $ZodCUIDInternals, $ZodCatch, $ZodCatchCtx, $ZodCatchInternals, $ZodCodec, $ZodCodecDef, $ZodCodecInternals, $ZodCreditCardInternals, $ZodCustom, $ZodCustomInternals, $ZodCustomStringFormat, $ZodCustomStringFormatInternals, $ZodDateInternals, $ZodDefault, $ZodDefaultInternals, $ZodDiscriminatedUnion, $ZodDiscriminatedUnionDef, $ZodDiscriminatedUnionInternals, $ZodE164Internals, $ZodEmailInternals, $ZodEmojiInternals, $ZodEnum, $ZodEnumInternals, $ZodExactOptional, $ZodExactOptionalInternals, $ZodFile, $ZodFileInternals, $ZodFunction, $ZodFunctionDef, $ZodFunctionIn, $ZodFunctionInternals, $ZodFunctionOut, $ZodGUIDInternals, $ZodIBANInternals, $ZodIPv4Internals, $ZodIPv6Internals, $ZodISODateInternals, $ZodISODateTimeInternals, $ZodISODurationInternals, $ZodISOTimeInternals, $ZodIntersection, $ZodIntersectionInternals, $ZodJWTInternals, $ZodKSUIDInternals, $ZodLazy, $ZodLazyInternals, $ZodLiteral, $ZodLiteralInternals, $ZodLooseShape, $ZodMACInternals, $ZodMap, $ZodMapInternals, $ZodNaN, $ZodNaNInternals, $ZodNanoIDInternals, $ZodNeverInternals, $ZodNonOptional, $ZodNonOptionalInternals, $ZodNullInternals, $ZodNullable, $ZodNullableInternals, $ZodNumberFormatInternals, $ZodNumberInternals, $ZodObject, $ZodObjectConfig, $ZodObjectInternals, $ZodOptional, $ZodOptionalInternals, $ZodPipe, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultInternals, $ZodPreprocess, $ZodPreprocessDef, $ZodPreprocessInternals, $ZodPromise, $ZodPromiseInternals, $ZodReadonly, $ZodReadonlyInternals, $ZodRecord, $ZodRecordInternals, $ZodRecordKey, $ZodSet, $ZodSetInternals, $ZodShape, $ZodStringFormatInternals, $ZodStringInternals, $ZodSuccess, $ZodSuccessInternals, $ZodSymbolInternals, $ZodTemplateLiteral, $ZodTemplateLiteralInternals, $ZodTemplateLiteralPart, $ZodTransform, $ZodTransformInternals, $ZodTuple, $ZodTupleInternals, $ZodType, $ZodTypeInternals, $ZodULIDInternals, $ZodURLInternals, $ZodUUIDInternals, $ZodUndefinedInternals, $ZodUnion, $ZodUnionInternals, $ZodUnknownInternals, $ZodVoidInternals, $ZodXIDInternals, $ZodXor, $ZodXorInternals, $catchall, $loose, $partial, $strict, $strip, CheckFn, ParseContext, ParsePayload, SomeType } from "../core/schemas.mjs";
+import { $ZodBigIntFormats, $ZodCheck, $ZodNumberFormats } from "../core/checks.mjs";
+import { $ZodIssue, $ZodIssueCustom } from "../core/errors.mjs";
+import { $ZodBranded, $constructor, infer as output, input } from "../core/core.mjs";
+import { $RefinementCtx, $ZodArrayParams, $ZodBase64Params, $ZodBase64URLParams, $ZodBigIntFormatParams, $ZodBigIntParams, $ZodBooleanParams, $ZodCIDRv4Params, $ZodCIDRv6Params, $ZodCUID2Params, $ZodCUIDParams, $ZodCheckBase64Params, $ZodCheckBase64URLParams, $ZodCheckCIDRv4Params, $ZodCheckCIDRv6Params, $ZodCheckCUID2Params, $ZodCheckCUIDParams, $ZodCheckE164Params, $ZodCheckEmailParams, $ZodCheckEmojiParams, $ZodCheckEndsWithParams, $ZodCheckGUIDParams, $ZodCheckGreaterThanParams, $ZodCheckIPv4Params, $ZodCheckIPv6Params, $ZodCheckISODateParams, $ZodCheckISODateTimeParams, $ZodCheckISODurationParams, $ZodCheckISOTimeParams, $ZodCheckIncludesParams, $ZodCheckJWTParams, $ZodCheckKSUIDParams, $ZodCheckLengthEqualsParams, $ZodCheckLessThanParams, $ZodCheckLowerCaseParams, $ZodCheckMaxLengthParams, $ZodCheckMaxSizeParams, $ZodCheckMimeTypeParams, $ZodCheckMinLengthParams, $ZodCheckMinSizeParams, $ZodCheckMultipleOfParams, $ZodCheckNanoIDParams, $ZodCheckNumberFormatParams, $ZodCheckPropertiesParams, $ZodCheckRegexParams, $ZodCheckSizeEqualsParams, $ZodCheckStartsWithParams, $ZodCheckULIDParams, $ZodCheckURLParams, $ZodCheckUUIDParams, $ZodCheckUpperCaseParams, $ZodCheckXIDParams, $ZodCreditCardParams, $ZodCustomParams, $ZodDateParams, $ZodDiscriminatedUnionParams, $ZodE164Params, $ZodEmailParams, $ZodEmojiParams, $ZodEnumParams, $ZodFileParams, $ZodGUIDParams, $ZodIBANParams, $ZodIPv4Params, $ZodIPv6Params, $ZodJWTParams, $ZodKSUIDParams, $ZodLiteralParams, $ZodMACParams, $ZodMapParams, $ZodNaNParams, $ZodNanoIDParams, $ZodNeverParams, $ZodNonOptionalParams, $ZodNullParams, $ZodNumberParams, $ZodObjectParams, $ZodRecordParams, $ZodSetParams, $ZodStringBoolParams, $ZodStringFormatParams, $ZodStringParams, $ZodSuperRefineParams, $ZodSymbolParams, $ZodTemplateLiteralParams, $ZodTupleParams, $ZodTypeDiscriminable, $ZodULIDParams, $ZodURLParams, $ZodUUIDParams, $ZodUUIDv4Params, $ZodUUIDv6Params, $ZodUUIDv7Params, $ZodUndefinedParams, $ZodUnionParams, $ZodVoidParams, $ZodXIDParams, $ZodXorParams, Params, describe as describe$1, meta as meta$1 } from "../core/api.mjs";
+import { index_d_exports } from "../core/index.mjs";
+import { ZodSafeParseResult, parse_d_exports } from "./parse.mjs";
+declare namespace schemas_d_exports {
+  export { SafeExtendShape, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCreditCard, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodExactOptional, ZodFile, ZodFloat32, ZodFloat64, ZodFunction, ZodGUID, ZodIBAN, ZodIPv4, ZodIPv6, ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, ZodInstanceOf, ZodInt, ZodInt32, ZodInt64, ZodIntersection, ZodJSONSchema, ZodJSONSchemaInternals, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMAC, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPreprocess, ZodPromise, ZodReadonly, ZodRecord, ZodSet, ZodStandardSchemaWithJSON, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodType, ZodUInt32, ZodUInt64, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, ZodXor, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber, _ZodString, _ZodType, _default, _function, any, array, base64, base64url, bigint, boolean, _catch as catch, check, cidrv4, cidrv6, codec, creditCard, cuid, cuid2, currencyCode, custom, date, describe, discriminatedUnion, e164, email, emoji, _enum as enum, exactOptional, file, float32, float64, _function as function, guid, hash, hex, hostname, httpUrl, iban, _instanceof as instanceof, int, int32, int64, intersection, invertCodec, ipv4, ipv6, json, jwt, keyof, ksuid, lazy, literal, looseObject, looseRecord, mac, map, meta, nan, nanoid, nativeEnum, never, nonoptional, _null as null, nullable, nullish, number, object, optional, partialRecord, pipe, prefault, preprocess, promise, readonly, record, refine, set, strictObject, string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, transform, tuple, uint32, uint64, ulid, _undefined as undefined, union, unknown, url, uuid, uuidv4, uuidv6, uuidv7, _void as void, xid, xor };
+}
+export type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+export interface ZodType<out Output = unknown, out Input = unknown, out Internals extends $ZodTypeInternals<Output, Input> = $ZodTypeInternals<Output, Input>> extends $ZodType<Output, Input, Internals> {
+  def: Internals["def"];
+  type: Internals["def"]["type"];
+  /** @deprecated Use `.def` instead. */
+  _def: Internals["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: Internals["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: Internals["input"];
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  /** Converts this schema to a JSON Schema representation. */
+  toJSONSchema(params?: ToJSONSchemaParams): ZodStandardJSONSchemaPayload<this>;
+  check(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  with(...checks: (CheckFn<output<this>> | $ZodCheck<output<this>>)[]): this;
+  clone(def?: Internals["def"], params?: {
+    parent: boolean;
+  }): this;
+  register<R extends $ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [$replace<R["_meta"], this>?] : [$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
+  brand<T extends PropertyKey = PropertyKey, Dir extends "in" | "out" | "inout" = "out">(value?: T): PropertyKey extends T ? this : $ZodBranded<this, T, Dir>;
+  parse(data: unknown, params?: ParseContext<$ZodIssue>): output<this>;
+  safeParse(data: unknown, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  parseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeParseAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  spa: (data: unknown, params?: ParseContext<$ZodIssue>) => Promise<ZodSafeParseResult<output<this>>>;
+  validate(data: unknown, params?: ParseContext<$ZodIssue>): data is input<this>;
+  validateAsync(data: unknown, params?: ParseContext<$ZodIssue>): Promise<boolean>;
+  encode(data: output<this>, params?: ParseContext<$ZodIssue>): input<this>;
+  decode(data: input<this>, params?: ParseContext<$ZodIssue>): output<this>;
+  encodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<input<this>>;
+  decodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<output<this>>;
+  safeEncode(data: output<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<input<this>>;
+  safeDecode(data: input<this>, params?: ParseContext<$ZodIssue>): ZodSafeParseResult<output<this>>;
+  safeEncodeAsync(data: output<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<input<this>>>;
+  safeDecodeAsync(data: input<this>, params?: ParseContext<$ZodIssue>): Promise<ZodSafeParseResult<output<this>>>;
+  refine<Ch extends (arg: output<this>) => unknown | Promise<unknown>>(check: Ch, params?: string | $ZodCustomParams): Ch extends ((arg: any) => arg is infer R) ? this & ZodType<R, input<this>> : this;
+  superRefine(refinement: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => void | Promise<void>, params?: $ZodSuperRefineParams): this;
+  overwrite(fn: (x: output<this>) => output<this>): this;
+  optional(): ZodOptional<this>;
+  exactOptional(): ZodExactOptional<this>;
+  nonoptional(params?: string | $ZodNonOptionalParams): ZodNonOptional<this>;
+  nullable(): ZodNullable<this>;
+  nullish(): ZodOptional<ZodNullable<this>>;
+  default(def: NoUndefined<output<this>>): ZodDefault<this>;
+  default(def: () => NoUndefined<output<this>>): ZodDefault<this>;
+  prefault(def: () => input<this>): ZodPrefault<this>;
+  prefault(def: input<this>): ZodPrefault<this>;
+  array(): ZodArray<this>;
+  or<T extends SomeType>(option: T): ZodUnion<[this, T]>;
+  and<T extends SomeType>(incoming: T): ZodIntersection<this, T>;
+  transform<NewOut>(transform: (arg: output<this>, ctx: $RefinementCtx<output<this>>) => NewOut | Promise<NewOut>): ZodPipe<this, ZodTransform<Awaited<NewOut>, output<this>>>;
+  catch(def: output<this>): ZodCatch<this>;
+  catch(def: (ctx: $ZodCatchCtx) => output<this>): ZodCatch<this>;
+  pipe<T extends $ZodType<any, output<this>>>(target: T | $ZodType<any, output<this>>): ZodPipe<this, T>;
+  readonly(): ZodReadonly<this>;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified description */
+  describe(description: string): this;
+  description?: string;
+  /** Returns the metadata associated with this instance in `z.globalRegistry` */
+  meta(): $replace<GlobalMeta, this> | undefined;
+  /** Returns a new instance that has been registered in `z.globalRegistry` with the specified metadata */
+  meta(data: $replace<GlobalMeta, this>): this;
+  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+   *
+   * ```ts
+   * const schema = z.string().optional();
+   * const isOptional = schema.safeParse(undefined).success; // true
+   * ```
+   */
+  isOptional(): boolean;
+  /**
+   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+   *
+   * ```ts
+   * const schema = z.string().nullable();
+   * const isNullable = schema.safeParse(null).success; // true
+   * ```
+   */
+  isNullable(): boolean;
+  apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
+}
+export interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {}
+export declare const ZodType: $constructor<ZodType>;
+export interface _ZodString<T extends $ZodStringInternals<unknown> = $ZodStringInternals<unknown>> extends _ZodType<T> {
+  format: string | null;
+  minLength: number | null;
+  maxLength: number | null;
+  regex(regex: RegExp, params?: string | $ZodCheckRegexParams): this;
+  includes(value: string, params?: string | $ZodCheckIncludesParams): this;
+  startsWith(value: string, params?: string | $ZodCheckStartsWithParams): this;
+  endsWith(value: string, params?: string | $ZodCheckEndsWithParams): this;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  lowercase(params?: string | $ZodCheckLowerCaseParams): this;
+  uppercase(params?: string | $ZodCheckUpperCaseParams): this;
+  trim(): this;
+  normalize(form?: "NFC" | "NFD" | "NFKC" | "NFKD" | (string & {})): this;
+  toLowerCase(): this;
+  toUpperCase(): this;
+  slugify(): this;
+}
+/** @internal */
+export declare const _ZodString: $constructor<_ZodString>;
+export interface ZodString extends _ZodString<$ZodStringInternals<string>> {
+  /** @deprecated Use `z.email()` instead. */
+  email(params?: string | $ZodCheckEmailParams): this;
+  /** @deprecated Use `z.url()` instead. */
+  url(params?: string | $ZodCheckURLParams): this;
+  /** @deprecated Use `z.jwt()` instead. */
+  jwt(params?: string | $ZodCheckJWTParams): this;
+  /** @deprecated Use `z.emoji()` instead. */
+  emoji(params?: string | $ZodCheckEmojiParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | $ZodCheckGUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuid(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv4(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv6(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.uuid()` instead. */
+  uuidv7(params?: string | $ZodCheckUUIDParams): this;
+  /** @deprecated Use `z.nanoid()` instead. */
+  nanoid(params?: string | $ZodCheckNanoIDParams): this;
+  /** @deprecated Use `z.guid()` instead. */
+  guid(params?: string | $ZodCheckGUIDParams): this;
+  /**
+   * @deprecated CUID v1 is deprecated by its authors due to information leakage
+   * (timestamps embedded in the id). Use `z.cuid2()` instead.
+   * See https://github.com/paralleldrive/cuid.
+   */
+  cuid(params?: string | $ZodCheckCUIDParams): this;
+  /** @deprecated Use `z.cuid2()` instead. */
+  cuid2(params?: string | $ZodCheckCUID2Params): this;
+  /** @deprecated Use `z.ulid()` instead. */
+  ulid(params?: string | $ZodCheckULIDParams): this;
+  /** @deprecated Use `z.base64()` instead. */
+  base64(params?: string | $ZodCheckBase64Params): this;
+  /** @deprecated Use `z.base64url()` instead. */
+  base64url(params?: string | $ZodCheckBase64URLParams): this;
+  /** @deprecated Use `z.xid()` instead. */
+  xid(params?: string | $ZodCheckXIDParams): this;
+  /** @deprecated Use `z.ksuid()` instead. */
+  ksuid(params?: string | $ZodCheckKSUIDParams): this;
+  /** @deprecated Use `z.ipv4()` instead. */
+  ipv4(params?: string | $ZodCheckIPv4Params): this;
+  /** @deprecated Use `z.ipv6()` instead. */
+  ipv6(params?: string | $ZodCheckIPv6Params): this;
+  /** @deprecated Use `z.cidrv4()` instead. */
+  cidrv4(params?: string | $ZodCheckCIDRv4Params): this;
+  /** @deprecated Use `z.cidrv6()` instead. */
+  cidrv6(params?: string | $ZodCheckCIDRv6Params): this;
+  /** @deprecated Use `z.e164()` instead. */
+  e164(params?: string | $ZodCheckE164Params): this;
+  /** @deprecated Use `z.iso.datetime()` instead. */
+  datetime(params?: string | $ZodCheckISODateTimeParams): this;
+  /** @deprecated Use `z.iso.date()` instead. */
+  date(params?: string | $ZodCheckISODateParams): this;
+  /** @deprecated Use `z.iso.time()` instead. */
+  time(params?: string | $ZodCheckISOTimeParams): this;
+  /** @deprecated Use `z.iso.duration()` instead. */
+  duration(params?: string | $ZodCheckISODurationParams): this;
+}
+export declare const ZodString: $constructor<ZodString>;
+export declare function string(params?: string | $ZodStringParams): ZodString;
+export declare function string<T extends string>(params?: string | $ZodStringParams): $ZodType<T, T>;
+export interface ZodStringFormat<Format extends string = string> extends _ZodString<$ZodStringFormatInternals<Format>> {}
+export declare const ZodStringFormat: $constructor<ZodStringFormat>;
+export interface ZodISODateTime extends ZodStringFormat {
+  _zod: $ZodISODateTimeInternals;
+}
+export declare const ZodISODateTime: $constructor<ZodISODateTime>;
+export interface ZodISODate extends ZodStringFormat {
+  _zod: $ZodISODateInternals;
+}
+export declare const ZodISODate: $constructor<ZodISODate>;
+export interface ZodISOTime extends ZodStringFormat {
+  _zod: $ZodISOTimeInternals;
+}
+export declare const ZodISOTime: $constructor<ZodISOTime>;
+export interface ZodISODuration extends ZodStringFormat {
+  _zod: $ZodISODurationInternals;
+}
+export declare const ZodISODuration: $constructor<ZodISODuration>;
+export interface ZodEmail extends ZodStringFormat<"email"> {
+  _zod: $ZodEmailInternals;
+}
+export declare const ZodEmail: $constructor<ZodEmail>;
+export declare function email(params?: string | $ZodEmailParams): ZodEmail;
+export interface ZodGUID extends ZodStringFormat<"guid"> {
+  _zod: $ZodGUIDInternals;
+}
+export declare const ZodGUID: $constructor<ZodGUID>;
+export declare function guid(params?: string | $ZodGUIDParams): ZodGUID;
+export interface ZodUUID extends ZodStringFormat<"uuid"> {
+  _zod: $ZodUUIDInternals;
+}
+export declare const ZodUUID: $constructor<ZodUUID>;
+export declare function uuid(params?: string | $ZodUUIDParams): ZodUUID;
+export declare function uuidv4(params?: string | $ZodUUIDv4Params): ZodUUID;
+export declare function uuidv6(params?: string | $ZodUUIDv6Params): ZodUUID;
+export declare function uuidv7(params?: string | $ZodUUIDv7Params): ZodUUID;
+export interface ZodURL extends ZodStringFormat<"url"> {
+  _zod: $ZodURLInternals;
+}
+export declare const ZodURL: $constructor<ZodURL>;
+export declare function url(params?: string | $ZodURLParams): ZodURL;
+export declare function httpUrl(params?: string | Omit<$ZodURLParams, "protocol" | "hostname">): ZodURL;
+export interface ZodEmoji extends ZodStringFormat<"emoji"> {
+  _zod: $ZodEmojiInternals;
+}
+export declare const ZodEmoji: $constructor<ZodEmoji>;
+export declare function emoji(params?: string | $ZodEmojiParams): ZodEmoji;
+export interface ZodNanoID extends ZodStringFormat<"nanoid"> {
+  _zod: $ZodNanoIDInternals;
+}
+export declare const ZodNanoID: $constructor<ZodNanoID>;
+export declare function nanoid(params?: string | $ZodNanoIDParams): ZodNanoID;
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export interface ZodCUID extends ZodStringFormat<"cuid"> {
+  _zod: $ZodCUIDInternals;
+}
+/**
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link ZodCUID2} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export declare const ZodCUID: $constructor<ZodCUID>;
+/**
+ * Validates a CUID v1 string.
+ *
+ * @deprecated CUID v1 is deprecated by its authors due to information leakage
+ * (timestamps embedded in the id). Use {@link cuid2 | `z.cuid2()`} instead.
+ * See https://github.com/paralleldrive/cuid.
+ */
+export declare function cuid(params?: string | $ZodCUIDParams): ZodCUID;
+export interface ZodCUID2 extends ZodStringFormat<"cuid2"> {
+  _zod: $ZodCUID2Internals;
+}
+export declare const ZodCUID2: $constructor<ZodCUID2>;
+export declare function cuid2(params?: string | $ZodCUID2Params): ZodCUID2;
+export interface ZodULID extends ZodStringFormat<"ulid"> {
+  _zod: $ZodULIDInternals;
+}
+export declare const ZodULID: $constructor<ZodULID>;
+export declare function ulid(params?: string | $ZodULIDParams): ZodULID;
+export interface ZodXID extends ZodStringFormat<"xid"> {
+  _zod: $ZodXIDInternals;
+}
+export declare const ZodXID: $constructor<ZodXID>;
+export declare function xid(params?: string | $ZodXIDParams): ZodXID;
+export interface ZodKSUID extends ZodStringFormat<"ksuid"> {
+  _zod: $ZodKSUIDInternals;
+}
+export declare const ZodKSUID: $constructor<ZodKSUID>;
+export declare function ksuid(params?: string | $ZodKSUIDParams): ZodKSUID;
+export interface ZodIPv4 extends ZodStringFormat<"ipv4"> {
+  _zod: $ZodIPv4Internals;
+}
+export declare const ZodIPv4: $constructor<ZodIPv4>;
+export declare function ipv4(params?: string | $ZodIPv4Params): ZodIPv4;
+export interface ZodMAC extends ZodStringFormat<"mac"> {
+  _zod: $ZodMACInternals;
+}
+export declare const ZodMAC: $constructor<ZodMAC>;
+export declare function mac(params?: string | $ZodMACParams): ZodMAC;
+export interface ZodIPv6 extends ZodStringFormat<"ipv6"> {
+  _zod: $ZodIPv6Internals;
+}
+export declare const ZodIPv6: $constructor<ZodIPv6>;
+export declare function ipv6(params?: string | $ZodIPv6Params): ZodIPv6;
+export interface ZodCIDRv4 extends ZodStringFormat<"cidrv4"> {
+  _zod: $ZodCIDRv4Internals;
+}
+export declare const ZodCIDRv4: $constructor<ZodCIDRv4>;
+export declare function cidrv4(params?: string | $ZodCIDRv4Params): ZodCIDRv4;
+export interface ZodCIDRv6 extends ZodStringFormat<"cidrv6"> {
+  _zod: $ZodCIDRv6Internals;
+}
+export declare const ZodCIDRv6: $constructor<ZodCIDRv6>;
+export declare function cidrv6(params?: string | $ZodCIDRv6Params): ZodCIDRv6;
+export interface ZodBase64 extends ZodStringFormat<"base64"> {
+  _zod: $ZodBase64Internals;
+}
+export declare const ZodBase64: $constructor<ZodBase64>;
+export declare function base64(params?: string | $ZodBase64Params): ZodBase64;
+export interface ZodBase64URL extends ZodStringFormat<"base64url"> {
+  _zod: $ZodBase64URLInternals;
+}
+export declare const ZodBase64URL: $constructor<ZodBase64URL>;
+export declare function base64url(params?: string | $ZodBase64URLParams): ZodBase64URL;
+export interface ZodE164 extends ZodStringFormat<"e164"> {
+  _zod: $ZodE164Internals;
+}
+export declare const ZodE164: $constructor<ZodE164>;
+export declare function e164(params?: string | $ZodE164Params): ZodE164;
+export interface ZodCreditCard extends ZodStringFormat<"credit_card"> {
+  _zod: $ZodCreditCardInternals;
+}
+export declare const ZodCreditCard: $constructor<ZodCreditCard>;
+export declare function creditCard(params?: string | $ZodCreditCardParams): ZodCreditCard;
+export interface ZodIBAN extends ZodStringFormat<"iban"> {
+  _zod: $ZodIBANInternals;
+}
+export declare const ZodIBAN: $constructor<ZodIBAN>;
+export declare function iban(params?: string | $ZodIBANParams): ZodIBAN;
+export interface ZodJWT extends ZodStringFormat<"jwt"> {
+  _zod: $ZodJWTInternals;
+}
+export declare const ZodJWT: $constructor<ZodJWT>;
+export declare function jwt(params?: string | $ZodJWTParams): ZodJWT;
+export interface ZodCustomStringFormat<Format extends string = string> extends ZodStringFormat<Format>, $ZodCustomStringFormat<Format> {
+  _zod: $ZodCustomStringFormatInternals<Format>;
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodCustomStringFormat: $constructor<ZodCustomStringFormat>;
+export declare function stringFormat<Format extends string>(format: Format, fnOrRegex: ((arg: string) => MaybeAsync<unknown>) | RegExp, _params?: string | $ZodStringFormatParams): ZodCustomStringFormat<Format>;
+export declare function hostname(_params?: string | $ZodStringFormatParams): ZodCustomStringFormat<"hostname">;
+export declare function hex(_params?: string | $ZodStringFormatParams): ZodCustomStringFormat<"hex">;
+export declare function currencyCode(_params?: string | $ZodStringFormatParams): ZodCustomStringFormat<"currency_code">;
+export declare function hash<Alg extends HashAlgorithm, Enc extends HashEncoding = "hex">(alg: Alg, params?: {
+  enc?: Enc;
+} & $ZodStringFormatParams): ZodCustomStringFormat<`${Alg}_${Enc}`>;
+export interface _ZodNumber<Internals extends $ZodNumberInternals = $ZodNumberInternals> extends _ZodType<Internals> {
+  gt(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  /** Identical to .min() */
+  gte(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  min(value: number, params?: string | $ZodCheckGreaterThanParams): this;
+  lt(value: number, params?: string | $ZodCheckLessThanParams): this;
+  /** Identical to .max() */
+  lte(value: number, params?: string | $ZodCheckLessThanParams): this;
+  max(value: number, params?: string | $ZodCheckLessThanParams): this;
+  /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
+  int(params?: string | $ZodCheckNumberFormatParams): this;
+  /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
+  safe(params?: string | $ZodCheckNumberFormatParams): this;
+  positive(params?: string | $ZodCheckGreaterThanParams): this;
+  nonnegative(params?: string | $ZodCheckGreaterThanParams): this;
+  negative(params?: string | $ZodCheckLessThanParams): this;
+  nonpositive(params?: string | $ZodCheckLessThanParams): this;
+  multipleOf(value: number, params?: string | $ZodCheckMultipleOfParams): this;
+  /** @deprecated Use `.multipleOf()` instead. */
+  step(value: number, params?: string | $ZodCheckMultipleOfParams): this;
+  /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
+  finite(params?: unknown): this;
+  minValue: number | null;
+  maxValue: number | null;
+  /** @deprecated Check the `format` property instead.  */
+  isInt: boolean;
+  /** @deprecated Number schemas no longer accept infinite values, so this always returns `true`. */
+  isFinite: boolean;
+  format: string | null;
+}
+export interface ZodNumber extends _ZodNumber<$ZodNumberInternals<number>> {}
+export declare const ZodNumber: $constructor<ZodNumber>;
+export declare function number(params?: string | $ZodNumberParams): ZodNumber;
+export interface ZodNumberFormat<Format extends $ZodNumberFormats = $ZodNumberFormats> extends ZodNumber {
+  _zod: $ZodNumberFormatInternals<Format>;
+}
+export declare const ZodNumberFormat: $constructor<ZodNumberFormat>;
+export interface ZodInt extends ZodNumberFormat<"safeint"> {}
+export declare function int(params?: string | $ZodCheckNumberFormatParams): ZodInt;
+export interface ZodFloat32 extends ZodNumberFormat<"float32"> {}
+export declare function float32(params?: string | $ZodCheckNumberFormatParams): ZodFloat32;
+export interface ZodFloat64 extends ZodNumberFormat<"float64"> {}
+export declare function float64(params?: string | $ZodCheckNumberFormatParams): ZodFloat64;
+export interface ZodInt32 extends ZodNumberFormat<"int32"> {}
+export declare function int32(params?: string | $ZodCheckNumberFormatParams): ZodInt32;
+export interface ZodUInt32 extends ZodNumberFormat<"uint32"> {}
+export declare function uint32(params?: string | $ZodCheckNumberFormatParams): ZodUInt32;
+export interface _ZodBoolean<T extends $ZodBooleanInternals = $ZodBooleanInternals> extends _ZodType<T> {}
+export interface ZodBoolean extends _ZodBoolean<$ZodBooleanInternals<boolean>> {}
+export declare const ZodBoolean: $constructor<ZodBoolean>;
+export declare function boolean(params?: string | $ZodBooleanParams): ZodBoolean;
+export interface _ZodBigInt<T extends $ZodBigIntInternals = $ZodBigIntInternals> extends _ZodType<T> {
+  gte(value: bigint, params?: string | $ZodCheckGreaterThanParams): this;
+  /** Alias of `.gte()` */
+  min(value: bigint, params?: string | $ZodCheckGreaterThanParams): this;
+  gt(value: bigint, params?: string | $ZodCheckGreaterThanParams): this;
+  /** Alias of `.lte()` */
+  lte(value: bigint, params?: string | $ZodCheckLessThanParams): this;
+  max(value: bigint, params?: string | $ZodCheckLessThanParams): this;
+  lt(value: bigint, params?: string | $ZodCheckLessThanParams): this;
+  positive(params?: string | $ZodCheckGreaterThanParams): this;
+  negative(params?: string | $ZodCheckLessThanParams): this;
+  nonpositive(params?: string | $ZodCheckLessThanParams): this;
+  nonnegative(params?: string | $ZodCheckGreaterThanParams): this;
+  multipleOf(value: bigint, params?: string | $ZodCheckMultipleOfParams): this;
+  minValue: bigint | null;
+  maxValue: bigint | null;
+  format: string | null;
+}
+export interface ZodBigInt extends _ZodBigInt<$ZodBigIntInternals<bigint>> {}
+export declare const ZodBigInt: $constructor<ZodBigInt>;
+export declare function bigint(params?: string | $ZodBigIntParams): ZodBigInt;
+export interface ZodBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends ZodBigInt {
+  _zod: $ZodBigIntFormatInternals<Format>;
+}
+export declare const ZodBigIntFormat: $constructor<ZodBigIntFormat>;
+export interface ZodInt64 extends ZodBigIntFormat<"int64"> {}
+export declare function int64(params?: string | $ZodBigIntFormatParams): ZodInt64;
+export interface ZodUInt64 extends ZodBigIntFormat<"uint64"> {}
+export declare function uint64(params?: string | $ZodBigIntFormatParams): ZodUInt64;
+export interface ZodSymbol extends _ZodType<$ZodSymbolInternals> {}
+export declare const ZodSymbol: $constructor<ZodSymbol>;
+export declare function symbol(params?: string | $ZodSymbolParams): ZodSymbol;
+export interface ZodUndefined extends _ZodType<$ZodUndefinedInternals> {}
+export declare const ZodUndefined: $constructor<ZodUndefined>;
+declare function _undefined(params?: string | $ZodUndefinedParams): ZodUndefined;
+export interface ZodNull extends _ZodType<$ZodNullInternals> {}
+export declare const ZodNull: $constructor<ZodNull>;
+declare function _null(params?: string | $ZodNullParams): ZodNull;
+export interface ZodAny extends _ZodType<$ZodAnyInternals> {}
+export declare const ZodAny: $constructor<ZodAny>;
+export declare function any(): ZodAny;
+export interface ZodUnknown extends _ZodType<$ZodUnknownInternals> {}
+export declare const ZodUnknown: $constructor<ZodUnknown>;
+export declare function unknown(): ZodUnknown;
+export interface ZodNever extends _ZodType<$ZodNeverInternals> {}
+export declare const ZodNever: $constructor<ZodNever>;
+export declare function never(params?: string | $ZodNeverParams): ZodNever;
+export interface ZodVoid extends _ZodType<$ZodVoidInternals> {}
+export declare const ZodVoid: $constructor<ZodVoid>;
+declare function _void(params?: string | $ZodVoidParams): ZodVoid;
+export interface _ZodDate<T extends $ZodDateInternals = $ZodDateInternals> extends _ZodType<T> {
+  min(value: number | Date, params?: string | $ZodCheckGreaterThanParams): this;
+  max(value: number | Date, params?: string | $ZodCheckLessThanParams): this;
+  /** @deprecated Not recommended. */
+  minDate: Date | null;
+  /** @deprecated Not recommended. */
+  maxDate: Date | null;
+}
+export interface ZodDate extends _ZodDate<$ZodDateInternals<Date>> {}
+export declare const ZodDate: $constructor<ZodDate>;
+export declare function date(params?: string | $ZodDateParams): ZodDate;
+export interface ZodArray<T extends SomeType = $ZodType> extends _ZodType<$ZodArrayInternals<T>>, $ZodArray<T> {
+  element: T;
+  min(minLength: number, params?: string | $ZodCheckMinLengthParams): this;
+  nonempty(params?: string | $ZodCheckMinLengthParams): this;
+  max(maxLength: number, params?: string | $ZodCheckMaxLengthParams): this;
+  length(len: number, params?: string | $ZodCheckLengthEqualsParams): this;
+  unwrap(): T;
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodArray: $constructor<ZodArray>;
+export declare function array<T extends SomeType>(element: T, params?: string | $ZodArrayParams): ZodArray<T>;
+export declare function keyof<T extends ZodObject>(schema: T): ZodEnum<KeysEnum<T["_zod"]["output"]>>;
+export type SafeExtendShape<Base extends $ZodShape, Ext extends $ZodLooseShape> = { [K in keyof Ext]: K extends keyof Base ? output<Ext[K]> extends output<Base[K]> ? input<Ext[K]> extends input<Base[K]> ? Ext[K] : never : never : Ext[K]; };
+export interface ZodObject<
+/** @ts-ignore Cast variance */
+out Shape extends $ZodShape = $ZodLooseShape, out Config extends $ZodObjectConfig = $strip> extends _ZodType<$ZodObjectInternals<Shape, Config>>, $ZodObject<Shape, Config> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  shape: Shape;
+  keyof(): ZodEnum<ToEnum<keyof Shape & string>>;
+  /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
+  catchall<T extends SomeType>(schema: T): ZodObject<Shape, $catchall<T>>;
+  /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
+  passthrough(): ZodObject<Shape, $loose>;
+  /** Consider `z.looseObject(A.shape)` instead */
+  loose(): ZodObject<Shape, $loose>;
+  /** Consider `z.strictObject(A.shape)` instead */
+  strict(): ZodObject<Shape, $strict>;
+  /** This is the default behavior. This method call is likely unnecessary. */
+  strip(): ZodObject<Shape, $strip>;
+  extend<U extends $ZodLooseShape>(shape: U): ZodObject<Extend<Shape, Writeable<U>>, Config>;
+  safeExtend<U extends $ZodLooseShape>(shape: SafeExtendShape<Shape, U> & Partial<Record<keyof Shape, SomeType>>): ZodObject<Extend<Shape, Writeable<U>>, Config>;
+  /**
+   * @deprecated Use [`A.extend(B.shape)`](https://zod.dev/api?id=extend) instead.
+   */
+  merge<U extends ZodObject>(other: U): ZodObject<Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
+  pick<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  omit<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
+  partial(): ZodObject<{ -readonly [k in keyof Shape]: ZodOptional<Shape[k]>; }, Config>;
+  partial<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ -readonly [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k]; }, Config>;
+  exactPartial(): ZodObject<{ -readonly [k in keyof Shape]: ZodExactOptional<Shape[k]>; }, Config>;
+  exactPartial<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ -readonly [k in keyof Shape]: k extends keyof M ? ZodExactOptional<Shape[k]> : Shape[k]; }, Config>;
+  required(): ZodObject<{ -readonly [k in keyof Shape]: ZodNonOptional<Shape[k]>; }, Config>;
+  required<M extends Mask<keyof Shape>>(mask: M & Record<Exclude<keyof M, keyof Shape>, never>): ZodObject<{ -readonly [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k]; }, Config>;
+}
+export declare const ZodObject: $constructor<ZodObject>;
+export declare function object<T extends $ZodLooseShape = Partial<Record<never, SomeType>>>(shape?: T, params?: string | $ZodObjectParams): ZodObject<Writeable<T>, $strip>;
+export declare function strictObject<T extends $ZodLooseShape>(shape: T, params?: string | $ZodObjectParams): ZodObject<Writeable<T>, $strict>;
+export declare function looseObject<T extends $ZodLooseShape>(shape: T, params?: string | $ZodObjectParams): ZodObject<Writeable<T>, $loose>;
+export interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  options: T;
+}
+export declare const ZodUnion: $constructor<ZodUnion>;
+export declare function union<const T extends readonly SomeType[]>(options: T, params?: string | $ZodUnionParams): ZodUnion<T>;
+export interface ZodXor<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodXorInternals<T>>, $ZodXor<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  options: T;
+}
+export declare const ZodXor: $constructor<ZodXor>;
+/** Creates an exclusive union (XOR) where exactly one option must match.
+ * Unlike regular unions that succeed when any option matches, xor fails if
+ * zero or more than one option matches the input. */
+export declare function xor<const T extends readonly SomeType[]>(options: T, params?: string | $ZodXorParams): ZodXor<T>;
+export interface ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly $ZodType[], Disc extends string = string> extends ZodUnion<Options>, $ZodDiscriminatedUnion<Options, Disc> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: $ZodDiscriminatedUnionInternals<Options, Disc>;
+  def: $ZodDiscriminatedUnionDef<Options, Disc>;
+}
+export declare const ZodDiscriminatedUnion: $constructor<ZodDiscriminatedUnion>;
+export declare function discriminatedUnion<Types extends readonly [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | $ZodDiscriminatedUnionParams): ZodDiscriminatedUnion<Types, Disc>;
+export interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodIntersection: $constructor<ZodIntersection>;
+export declare function intersection<T extends SomeType, U extends SomeType>(left: T, right: U): ZodIntersection<T, U>;
+export interface ZodTuple<T extends TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends _ZodType<$ZodTupleInternals<T, Rest>>, $ZodTuple<T, Rest> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  rest<Rest extends SomeType = $ZodType>(rest: Rest): ZodTuple<T, Rest>;
+  partial(): ZodTuple<{ -readonly [k in keyof T]: ZodOptional<T[k]>; }, Rest>;
+}
+export declare const ZodTuple: $constructor<ZodTuple>;
+export declare function tuple<T extends readonly [SomeType, ...SomeType[]]>(items: T, params?: string | $ZodTupleParams): ZodTuple<T, null>;
+export declare function tuple<T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(items: T, rest: Rest, params?: string | $ZodTupleParams): ZodTuple<T, Rest>;
+export declare function tuple(items: [], params?: string | $ZodTupleParams): ZodTuple<[], null>;
+export interface ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends _ZodType<$ZodRecordInternals<Key, Value>>, $ZodRecord<Key, Value> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  keyType: Key;
+  valueType: Value;
+}
+export declare const ZodRecord: $constructor<ZodRecord>;
+export declare function record<Key extends $ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | $ZodRecordParams): ZodRecord<Key, Value>;
+export declare function partialRecord<Key extends $ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | $ZodRecordParams): ZodRecord<Key & $partial, Value>;
+export declare function looseRecord<Key extends $ZodRecordKey, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | $ZodRecordParams): ZodRecord<Key, Value>;
+export interface ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends _ZodType<$ZodMapInternals<Key, Value>>, $ZodMap<Key, Value> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  keyType: Key;
+  valueType: Value;
+  min(minSize: number, params?: string | $ZodCheckMinSizeParams): this;
+  nonempty(params?: string | $ZodCheckMinSizeParams): this;
+  max(maxSize: number, params?: string | $ZodCheckMaxSizeParams): this;
+  size(size: number, params?: string | $ZodCheckSizeEqualsParams): this;
+}
+export declare const ZodMap: $constructor<ZodMap>;
+export declare function map<Key extends SomeType, Value extends SomeType>(keyType: Key, valueType: Value, params?: string | $ZodMapParams): ZodMap<Key, Value>;
+export interface ZodSet<T extends SomeType = $ZodType> extends _ZodType<$ZodSetInternals<T>>, $ZodSet<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  min(minSize: number, params?: string | $ZodCheckMinSizeParams): this;
+  nonempty(params?: string | $ZodCheckMinSizeParams): this;
+  max(maxSize: number, params?: string | $ZodCheckMaxSizeParams): this;
+  size(size: number, params?: string | $ZodCheckSizeEqualsParams): this;
+}
+export declare const ZodSet: $constructor<ZodSet>;
+export declare function set<Value extends SomeType>(valueType: Value, params?: string | $ZodSetParams): ZodSet<Value>;
+export interface ZodEnum<
+/** @ts-ignore Cast variance */
+out T extends EnumLike = EnumLike> extends _ZodType<$ZodEnumInternals<T>>, $ZodEnum<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  enum: T;
+  options: Array<T[keyof T]>;
+  extract<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Pick<T, U[number]>>>;
+  exclude<const U extends readonly (keyof T)[]>(values: U, params?: string | $ZodEnumParams): ZodEnum<Flatten<Omit<T, U[number]>>>;
+}
+export declare const ZodEnum: $constructor<ZodEnum>;
+declare function _enum<const T extends readonly string[]>(values: T, params?: string | $ZodEnumParams): ZodEnum<ToEnum<T[number]>>;
+declare function _enum<const T extends EnumLike>(entries: T, params?: string | $ZodEnumParams): ZodEnum<T>;
+/** @deprecated This API has been merged into `z.enum()`. Use `z.enum()` instead.
+ *
+ * ```ts
+ * enum Colors { red, green, blue }
+ * z.enum(Colors);
+ * ```
+ */
+export declare function nativeEnum<T extends EnumLike>(entries: T, params?: string | $ZodEnumParams): ZodEnum<T>;
+export interface ZodLiteral<T extends Literal = Literal> extends _ZodType<$ZodLiteralInternals<T>>, $ZodLiteral<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  values: Set<T>;
+  /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+  value: T;
+}
+export declare const ZodLiteral: $constructor<ZodLiteral>;
+export declare function literal<const T extends ReadonlyArray<Literal>>(value: T, params?: string | $ZodLiteralParams): ZodLiteral<T[number]>;
+export declare function literal<const T extends Literal>(value: T, params?: string | $ZodLiteralParams): ZodLiteral<T>;
+export interface ZodFile extends _ZodType<$ZodFileInternals>, $ZodFile {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  min(size: number, params?: string | $ZodCheckMinSizeParams): this;
+  max(size: number, params?: string | $ZodCheckMaxSizeParams): this;
+  mime(types: MimeTypes | Array<MimeTypes>, params?: string | $ZodCheckMimeTypeParams): this;
+}
+export declare const ZodFile: $constructor<ZodFile>;
+export declare function file(params?: string | $ZodFileParams): ZodFile;
+export interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodTransform: $constructor<ZodTransform>;
+export declare function transform<I = unknown, O = I>(fn: (input: I, ctx: $RefinementCtx) => O): ZodTransform<Awaited<O>, I>;
+export interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodOptional: $constructor<ZodOptional>;
+export declare function optional<T extends SomeType>(innerType: T): ZodOptional<T>;
+export interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodExactOptional: $constructor<ZodExactOptional>;
+export declare function exactOptional<T extends SomeType>(innerType: T): ZodExactOptional<T>;
+export interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodNullable: $constructor<ZodNullable>;
+export declare function nullable<T extends SomeType>(innerType: T): ZodNullable<T>;
+export declare function nullish<T extends SomeType>(innerType: T): ZodOptional<ZodNullable<T>>;
+export interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+export declare const ZodDefault: $constructor<ZodDefault>;
+export declare function _default<T extends SomeType>(innerType: T, defaultValue: NoUndefined<output<T>> | (() => NoUndefined<output<T>>)): ZodDefault<T>;
+export interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodPrefault: $constructor<ZodPrefault>;
+export declare function prefault<T extends SomeType>(innerType: T, defaultValue: input<T> | (() => input<T>)): ZodPrefault<T>;
+export interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodNonOptional: $constructor<ZodNonOptional>;
+export declare function nonoptional<T extends SomeType>(innerType: T, params?: string | $ZodNonOptionalParams): ZodNonOptional<T>;
+export interface ZodSuccess<T extends SomeType = $ZodType> extends _ZodType<$ZodSuccessInternals<T>>, $ZodSuccess<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodSuccess: $constructor<ZodSuccess>;
+export declare function success<T extends SomeType>(innerType: T): ZodSuccess<T>;
+export interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+export declare const ZodCatch: $constructor<ZodCatch>;
+declare function _catch<T extends SomeType>(innerType: T, catchValue: output<T> | ((ctx: $ZodCatchCtx) => output<T>)): ZodCatch<T>;
+export interface ZodNaN extends _ZodType<$ZodNaNInternals>, $ZodNaN {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodNaN: $constructor<ZodNaN>;
+export declare function nan(params?: string | $ZodNaNParams): ZodNaN;
+export interface ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodPipeInternals<A, B>>, $ZodPipe<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  in: A;
+  out: B;
+}
+export declare const ZodPipe: $constructor<ZodPipe>;
+export declare function pipe<const A extends SomeType, B extends $ZodType<unknown, output<A>> = $ZodType<unknown, output<A>>>(in_: A, out: B | $ZodType<unknown, output<A>>): ZodPipe<A, B>;
+export interface ZodCodec<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends ZodPipe<A, B>, $ZodCodec<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: $ZodCodecInternals<A, B>;
+  def: $ZodCodecDef<A, B>;
+}
+export declare const ZodCodec: $constructor<ZodCodec>;
+export declare function codec<const A extends SomeType, B extends SomeType = $ZodType>(in_: A, out: B, params: {
+  decode: (value: output<A>, payload: ParsePayload<output<A>>) => MaybeAsync<input<B>>;
+  encode: (value: input<B>, payload: ParsePayload<input<B>>) => MaybeAsync<output<A>>;
+}): ZodCodec<A, B>;
+export declare function invertCodec<A extends SomeType, B extends SomeType>(codec: ZodCodec<A, B>): ZodCodec<B, A>;
+export interface ZodPreprocess<B extends SomeType = $ZodType, I = unknown> extends ZodPipe<$ZodTransform<unknown, I>, B>, $ZodPreprocess<B, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _zod: $ZodPreprocessInternals<B, I>;
+  def: $ZodPreprocessDef<B, I>;
+}
+export declare const ZodPreprocess: $constructor<ZodPreprocess>;
+export interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodReadonly: $constructor<ZodReadonly>;
+export declare function readonly<T extends SomeType>(innerType: T): ZodReadonly<T>;
+export interface ZodTemplateLiteral<Template extends string = string> extends _ZodType<$ZodTemplateLiteralInternals<Template>>, $ZodTemplateLiteral<Template> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodTemplateLiteral: $constructor<ZodTemplateLiteral>;
+export declare function templateLiteral<const Parts extends $ZodTemplateLiteralPart[]>(parts: Parts, params?: string | $ZodTemplateLiteralParams): ZodTemplateLiteral<$PartsToTemplateLiteral<Parts>>;
+export interface ZodLazy<T extends SomeType = $ZodType> extends _ZodType<$ZodLazyInternals<T>>, $ZodLazy<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodLazy: $constructor<ZodLazy>;
+export declare function lazy<T extends SomeType>(getter: () => T): ZodLazy<T>;
+export interface ZodPromise<T extends SomeType = $ZodType> extends _ZodType<$ZodPromiseInternals<T>>, $ZodPromise<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+export declare const ZodPromise: $constructor<ZodPromise>;
+export declare function promise<T extends SomeType>(innerType: T): ZodPromise<T>;
+export interface ZodFunction<Args extends $ZodFunctionIn = $ZodFunctionIn, Returns extends $ZodFunctionOut = $ZodFunctionOut> extends _ZodType<$ZodFunctionInternals<Args, Returns>>, $ZodFunction<Args, Returns> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  _def: $ZodFunctionDef<Args, Returns>;
+  _input: $InferInnerFunctionType<Args, Returns>;
+  _output: $InferOuterFunctionType<Args, Returns>;
+  input<const Items extends TupleItems, const Rest extends $ZodFunctionOut = $ZodFunctionOut>(args: Items, rest?: Rest): ZodFunction<$ZodTuple<Items, Rest>, Returns>;
+  input<NewArgs extends $ZodFunctionIn>(args: NewArgs): ZodFunction<NewArgs, Returns>;
+  input(...args: any[]): ZodFunction<any, Returns>;
+  output<NewReturns extends $ZodType>(output: NewReturns): ZodFunction<Args, NewReturns>;
+}
+export declare const ZodFunction: $constructor<ZodFunction>;
+export declare function _function(): ZodFunction;
+export declare function _function<const In extends ReadonlyArray<$ZodType>>(params: {
+  input: In;
+}): ZodFunction<ZodTuple<In, null>, $ZodFunctionOut>;
+export declare function _function<const In extends ReadonlyArray<$ZodType>, const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
+  input: In;
+  output: Out;
+}): ZodFunction<ZodTuple<In, null>, Out>;
+export declare function _function<const In extends $ZodFunctionIn = $ZodFunctionIn>(params: {
+  input: In;
+}): ZodFunction<In, $ZodFunctionOut>;
+export declare function _function<const Out extends $ZodFunctionOut = $ZodFunctionOut>(params: {
+  output: Out;
+}): ZodFunction<$ZodFunctionIn, Out>;
+export declare function _function<In extends $ZodFunctionIn = $ZodFunctionIn, Out extends $ZodType = $ZodType>(params?: {
+  input: In;
+  output: Out;
+}): ZodFunction<In, Out>;
+export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<$ZodCustomInternals<O, I>>, $ZodCustom<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+export declare const ZodCustom: $constructor<ZodCustom>;
+export declare function check<O = unknown>(fn: CheckFn<O>): $ZodCheck<O>;
+export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | $ZodCustomParams | undefined): ZodCustom<O, O>;
+export declare function refine<T>(fn: (arg: NoInfer<T>) => MaybeAsync<unknown>, _params?: string | $ZodCustomParams): $ZodCheck<T>;
+export declare function superRefine<T>(fn: (arg: T, payload: $RefinementCtx<T>) => void | Promise<void>, params?: $ZodSuperRefineParams): $ZodCheck<T>;
+export declare const describe: typeof describe$1;
+export declare const meta: typeof meta$1;
+type ZodInstanceOfParams = Params<ZodCustom, $ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
+export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
+  properties<Shape extends { [k in keyof T as T[k] extends Function ? never : k]?: $ZodType<unknown, T[k]>; }>(shape: Shape, params?: string | $ZodCheckPropertiesParams): ZodInstanceOf<T & $InferObjectInput<Shape, {}>>;
+}
+export declare const ZodInstanceOf: $constructor<ZodInstanceOf>;
+declare function _instanceof<T extends typeof Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;
+export declare const stringbool: (_params?: string | $ZodStringBoolParams) => ZodCodec<ZodString, ZodBoolean>;
+type _ZodJSONSchema = ZodUnion<[ZodString, ZodNumber, ZodBoolean, ZodNull, ZodArray<ZodJSONSchema>, ZodRecord<ZodString, ZodJSONSchema>]>;
+type _ZodJSONSchemaInternals = _ZodJSONSchema["_zod"];
+export interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
+  output: JSONType;
+  input: JSONType;
+}
+export interface ZodJSONSchema extends _ZodJSONSchema {
+  _zod: ZodJSONSchemaInternals;
+}
+export declare function json(params?: string | $ZodCustomParams): ZodJSONSchema;
+export declare function preprocess<A, U extends SomeType, B = unknown>(fn: (arg: B, ctx: $RefinementCtx) => A, schema: U): ZodPreprocess<U, B>;
+//#endregion
+export { _function as function, _catch as catch, _enum as enum, _instanceof as instanceof, _null as null, schemas_d_exports, _undefined as undefined, _void as void };
+//# sourceMappingURL=schemas.d.mts.map