@intlayer/types 8.3.0-canary.3 → 8.3.0

package/dist/types/config.d.ts

@@ -1,9 +1,9 @@
 import { Locale } from "./allLocales.js";
+import { ZodType } from "./node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/schemas.js";
 import { LocalesValues, StrictModeLocaleMap } from "./module_augmentation.js";
 import { FilePathPattern } from "./filePathPattern.js";
 import { ContentAutoTransformation, DictionaryLocation, Fill } from "./dictionary.js";
 import { Plugin } from "./plugin.js";
-import { z } from "zod";
 
 //#region src/config.d.ts
 type StrictMode = "strict" | "inclusive" | "loose";
@@ -690,7 +690,7 @@ type CustomIntlayerConfig = {
   * }
   * ```
   */
-  schemas?: Record<string, z.ZodType>;
+  schemas?: Record<string, ZodType>;
   /**
   * Custom plugins configuration
   */
@@ -781,7 +781,7 @@ type IntlayerConfig = {
   /**
   * Custom schemas to validate the dictionaries content.
   */
-  schemas?: Record<string, z.ZodType>;
+  schemas?: Record<string, ZodType>;
   /**
   * Plugins configuration
   */

package/dist/types/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/config.ts"],"mappings":"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"}
+{"version":3,"file":"config.d.ts","names":[],"sources":["../../src/config.ts"],"mappings":"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"}

package/dist/types/module_augmentation.d.ts

@@ -1,7 +1,7 @@
 import { Locale } from "./allLocales.js";
-import { __DeclaredLocalesRegistry, __DictionaryRegistry, __EditorRegistry, __RequiredLocalesRegistry, __SchemaRegistry, __StrictModeRegistry } from "./intlayer/dist/types/index.js";
 import { Dictionary } from "./dictionary.js";
 import { StrictMode } from "./config.js";
+import { __DeclaredLocalesRegistry, __DictionaryRegistry, __EditorRegistry, __RequiredLocalesRegistry, __SchemaRegistry, __StrictModeRegistry } from "intlayer";
 
 //#region src/module_augmentation.d.ts
 type SchemaKeys = keyof __SchemaRegistry extends never ? string : keyof __SchemaRegistry;
@@ -22,7 +22,7 @@ type ResolvedStrictMode = __StrictModeRegistry extends {
 } ? M : "inclusive";
 type StrictModeLocaleMap<Content = unknown, Mode extends StrictMode = ResolvedStrictMode> = RequiredLocales extends never ? Partial<Record<Locale, Content>> : Mode extends "strict" ? Required<Record<RequiredLocales, Content>> & Partial<Record<DeclaredLocales, Content>> : Mode extends "inclusive" ? Required<Record<RequiredLocales, Content>> & Partial<Record<Locale, Content>> : Partial<Record<Locale, Content>>;
 type ResolvedEditor<Node, Editor> = __EditorRegistry extends {
-  enabled: "true";
+  enabled: true;
 } ? Editor : Node;
 //#endregion
 export { DeclaredLocales, DictionaryKeys, DictionaryRegistry, DictionaryRegistryContent, DictionaryRegistryElement, LocalesValues, RequiredLocales, ResolvedEditor, Schema, SchemaKeys, StrictModeLocaleMap };

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/errors.d.ts

@@ -0,0 +1,23 @@
+import { $ZodError, $ZodErrorMap, $ZodFlattenedError, $ZodFormattedError, $ZodIssue } from "../core/errors.js";
+import { $constructor } from "../core/core.js";
+
+//#region ../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/errors.d.cts
+/** An Error-like class used to store Zod validation issues.  */
+interface ZodError<T = unknown> extends $ZodError<T> {
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  format(): $ZodFormattedError<T>;
+  format<U>(mapper: (issue: $ZodIssue) => U): $ZodFormattedError<T, U>;
+  /** @deprecated Use the `z.treeifyError(err)` function instead. */
+  flatten(): $ZodFlattenedError<T>;
+  flatten<U>(mapper: (issue: $ZodIssue) => U): $ZodFlattenedError<T, U>;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssue(issue: $ZodIssue): void;
+  /** @deprecated Push directly to `.issues` instead. */
+  addIssues(issues: $ZodIssue[]): void;
+  /** @deprecated Check `err.issues.length === 0` instead. */
+  isEmpty: boolean;
+}
+declare const ZodError: $constructor<ZodError>;
+//#endregion
+export { ZodError };
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":["core","$ZodError","ZodIssue","$ZodIssue","ZodError","U","T","$ZodFormattedError","$ZodFlattenedError","format","issue","mapper","flatten","addIssue","addIssues","issues","isEmpty","$constructor","ZodRealError","ZodFlattenedError","ZodFormattedError","$ZodErrorMap","ZodErrorMap","IssueData","$ZodRawIssue"],"sources":["../../../../../../../../../../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/errors.d.cts"],"x_google_ignoreList":[0],"mappings":";;;;AAKA;AAAA,UAAiBI,QAAAA,sBAA8BH,SAAAA,CAAUK,CAAAA;EAAhCD;EAErBI,MAAAA,IAAUT,kBAAAA,CAAwBM,CAAAA;EAClCG,MAAAA,IAAUE,MAAAA,GAASD,KAAAA,EAAOV,SAAAA,KAAmBK,CAAAA,GAAIL,kBAAAA,CAAwBM,CAAAA,EAAGD,CAAAA;EADlEL;EAGVY,OAAAA,IAAWZ,kBAAAA,CAAwBM,CAAAA;EACnCM,OAAAA,IAAWD,MAAAA,GAASD,KAAAA,EAAOV,SAAAA,KAAmBK,CAAAA,GAAIL,kBAAAA,CAAwBM,CAAAA,EAAGD,CAAAA;EAHJC;EAKzEO,QAAAA,CAASH,KAAAA,EAAOV,SAAAA;EALiCA;EAOjDc,SAAAA,CAAUC,MAAAA,EAAQf,SAAAA;EALPA;EAOXgB,OAAAA;AAAAA;AAAAA,cAEiBZ,QAAAA,EAAUJ,YAAAA,CAAkBI,QAAAA"}

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/parse.d.ts

@@ -0,0 +1,17 @@
+import { ZodError } from "./errors.js";
+
+//#region ../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/parse.d.cts
+type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
+type ZodSafeParseSuccess<T> = {
+  success: true;
+  data: T;
+  error?: never;
+};
+type ZodSafeParseError<T> = {
+  success: false;
+  data?: never;
+  error: ZodError<T>;
+};
+//#endregion
+export { ZodSafeParseResult };
+//# sourceMappingURL=parse.d.ts.map

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","names":["core","ZodError","ZodSafeParseResult","T","ZodSafeParseSuccess","ZodSafeParseError","success","data","error","parse","$ZodType","$ZodIssue","ParseContext","util","AnyFunc","$ZodErrorClass","output","schema","value","_ctx","callee","Err","_params","parseAsync","Promise","safeParse","safeParseAsync","encode","input","decode","encodeAsync","decodeAsync","safeEncode","safeDecode","safeEncodeAsync","safeDecodeAsync"],"sources":["../../../../../../../../../../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/parse.d.cts"],"x_google_ignoreList":[0],"mappings":";;;KAEYE,kBAAAA,MAAwBE,mBAAAA,CAAoBD,CAAAA,IAAKE,iBAAAA,CAAkBF,CAAAA;AAAAA,KACnEC,mBAAAA;EACRE,OAAAA;EACAC,IAAAA,EAAMJ,CAAAA;EACNK,KAAAA;AAAAA;AAAAA,KAEQH,iBAAAA;EACRC,OAAAA;EACAC,IAAAA;EACAC,KAAAA,EAAOP,QAAAA,CAASE,CAAAA;AAAAA"}

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/schemas.d.ts

@@ -0,0 +1,169 @@
+import { StandardSchemaWithJSONProps } from "../core/standard-schema.js";
+import { $ZodRegistry, $replace, GlobalMeta } from "../core/registries.js";
+import { ToJSONSchemaParams, ZodStandardJSONSchemaPayload } from "../core/to-json-schema.js";
+import { NoUndefined } from "../core/util.js";
+import { $ZodArray, $ZodArrayInternals, $ZodCatch, $ZodCatchCtx, $ZodCatchInternals, $ZodDefault, $ZodDefaultInternals, $ZodExactOptional, $ZodExactOptionalInternals, $ZodIntersection, $ZodIntersectionInternals, $ZodNonOptional, $ZodNonOptionalInternals, $ZodNullable, $ZodNullableInternals, $ZodOptional, $ZodOptionalInternals, $ZodPipe, $ZodPipeInternals, $ZodPrefault, $ZodPrefaultInternals, $ZodReadonly, $ZodReadonlyInternals, $ZodTransform, $ZodTransformInternals, $ZodType, $ZodTypeInternals, $ZodUnion, $ZodUnionInternals, CheckFn, ParseContext, SomeType } from "../core/schemas.js";
+import { $ZodCheck } from "../core/checks.js";
+import { $ZodIssue } from "../core/errors.js";
+import { $ZodBranded, $constructor, input, output } from "../core/core.js";
+import { $RefinementCtx, $ZodCheckLengthEqualsParams, $ZodCheckMaxLengthParams, $ZodCheckMinLengthParams, $ZodCustomParams, $ZodNonOptionalParams } from "../core/api.js";
+import { ZodSafeParseResult } from "./parse.js";
+
+//#region ../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/schemas.d.cts
+type ZodStandardSchemaWithJSON<T> = StandardSchemaWithJSONProps<input<T>, output<T>>;
+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>>>;
+  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>): 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>(fn: (schema: this) => T): T;
+}
+interface _ZodType<out Internals extends $ZodTypeInternals = $ZodTypeInternals> extends ZodType<any, any, Internals> {}
+declare const ZodType: $constructor<ZodType>;
+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>;
+}
+declare const ZodArray: $constructor<ZodArray>;
+interface ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends _ZodType<$ZodUnionInternals<T>>, $ZodUnion<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  options: T;
+}
+declare const ZodUnion: $constructor<ZodUnion>;
+interface ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends _ZodType<$ZodIntersectionInternals<A, B>>, $ZodIntersection<A, B> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodIntersection: $constructor<ZodIntersection>;
+interface ZodTransform<O = unknown, I = unknown> extends _ZodType<$ZodTransformInternals<O, I>>, $ZodTransform<O, I> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+}
+declare const ZodTransform: $constructor<ZodTransform>;
+interface ZodOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodOptionalInternals<T>>, $ZodOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodOptional: $constructor<ZodOptional>;
+interface ZodExactOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodExactOptionalInternals<T>>, $ZodExactOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodExactOptional: $constructor<ZodExactOptional>;
+interface ZodNullable<T extends SomeType = $ZodType> extends _ZodType<$ZodNullableInternals<T>>, $ZodNullable<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodNullable: $constructor<ZodNullable>;
+interface ZodDefault<T extends SomeType = $ZodType> extends _ZodType<$ZodDefaultInternals<T>>, $ZodDefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeDefault(): T;
+}
+declare const ZodDefault: $constructor<ZodDefault>;
+interface ZodPrefault<T extends SomeType = $ZodType> extends _ZodType<$ZodPrefaultInternals<T>>, $ZodPrefault<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodPrefault: $constructor<ZodPrefault>;
+interface ZodNonOptional<T extends SomeType = $ZodType> extends _ZodType<$ZodNonOptionalInternals<T>>, $ZodNonOptional<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodNonOptional: $constructor<ZodNonOptional>;
+interface ZodCatch<T extends SomeType = $ZodType> extends _ZodType<$ZodCatchInternals<T>>, $ZodCatch<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+  /** @deprecated Use `.unwrap()` instead. */
+  removeCatch(): T;
+}
+declare const ZodCatch: $constructor<ZodCatch>;
+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;
+}
+declare const ZodPipe: $constructor<ZodPipe>;
+interface ZodReadonly<T extends SomeType = $ZodType> extends _ZodType<$ZodReadonlyInternals<T>>, $ZodReadonly<T> {
+  "~standard": ZodStandardSchemaWithJSON<this>;
+  unwrap(): T;
+}
+declare const ZodReadonly: $constructor<ZodReadonly>;
+//#endregion
+export { ZodType };
+//# sourceMappingURL=schemas.d.ts.map

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","names":["core","util","StandardSchemaWithJSONProps","parse","ZodStandardSchemaWithJSON","T","input","output","ZodType","R","Dir","Ch","NewOut","Output","Input","Internals","$ZodTypeInternals","ToJSONSchemaParams","ZodStandardJSONSchemaPayload","CheckFn","$ZodCheck","$ZodRegistry","$replace","PropertyKey","$ZodBranded","$ZodIssue","ParseContext","ZodSafeParseResult","Promise","$ZodCustomParams","$RefinementCtx","ZodOptional","ZodExactOptional","$ZodNonOptionalParams","ZodNonOptional","ZodNullable","NoUndefined","ZodDefault","ZodPrefault","ZodArray","SomeType","ZodUnion","ZodIntersection","Awaited","ZodTransform","ZodPipe","ZodCatch","$ZodCatchCtx","$ZodType","ZodReadonly","GlobalMeta","def","type","_def","_output","_input","toJSONSchema","params","check","checks","with","clone","parent","register","registry","meta","brand","value","data","safeParse","parseAsync","safeParseAsync","spa","encode","decode","encodeAsync","decodeAsync","safeEncode","safeDecode","safeEncodeAsync","safeDecodeAsync","refine","arg","superRefine","ctx","refinement","overwrite","x","fn","optional","exactOptional","nonoptional","nullable","nullish","default","prefault","array","or","option","and","incoming","transform","catch","pipe","target","readonly","describe","description","isOptional","isNullable","apply","schema","_ZodType","$constructor","_ZodString","$ZodStringInternals","RegExp","$ZodCheckRegexParams","$ZodCheckIncludesParams","$ZodCheckStartsWithParams","$ZodCheckEndsWithParams","$ZodCheckMinLengthParams","$ZodCheckMaxLengthParams","$ZodCheckLengthEqualsParams","$ZodCheckLowerCaseParams","$ZodCheckUpperCaseParams","format","minLength","maxLength","regex","includes","startsWith","endsWith","min","max","length","len","nonempty","lowercase","uppercase","trim","normalize","form","toLowerCase","toUpperCase","slugify","ZodString","$ZodCheckEmailParams","$ZodCheckURLParams","$ZodCheckJWTParams","$ZodCheckEmojiParams","$ZodCheckGUIDParams","$ZodCheckUUIDParams","$ZodCheckNanoIDParams","$ZodCheckCUIDParams","$ZodCheckCUID2Params","$ZodCheckULIDParams","$ZodCheckBase64Params","$ZodCheckBase64URLParams","$ZodCheckXIDParams","$ZodCheckKSUIDParams","$ZodCheckIPv4Params","$ZodCheckIPv6Params","$ZodCheckCIDRv4Params","$ZodCheckCIDRv6Params","$ZodCheckE164Params","$ZodCheckISODateTimeParams","$ZodCheckISODateParams","$ZodCheckISOTimeParams","$ZodCheckISODurationParams","email","url","jwt","emoji","guid","uuid","uuidv4","uuidv6","uuidv7","nanoid","cuid","cuid2","ulid","base64","base64url","xid","ksuid","ipv4","ipv6","cidrv4","cidrv6","e164","datetime","date","time","duration","string","$ZodStringParams","ZodStringFormat","Format","$ZodStringFormatInternals","ZodEmail","$ZodEmailInternals","_zod","$ZodEmailParams","ZodGUID","$ZodGUIDInternals","$ZodGUIDParams","ZodUUID","$ZodUUIDInternals","$ZodUUIDParams","$ZodUUIDv4Params","$ZodUUIDv6Params","$ZodUUIDv7Params","ZodURL","$ZodURLInternals","$ZodURLParams","httpUrl","Omit","ZodEmoji","$ZodEmojiInternals","$ZodEmojiParams","ZodNanoID","$ZodNanoIDInternals","$ZodNanoIDParams","ZodCUID","$ZodCUIDInternals","$ZodCUIDParams","ZodCUID2","$ZodCUID2Internals","$ZodCUID2Params","ZodULID","$ZodULIDInternals","$ZodULIDParams","ZodXID","$ZodXIDInternals","$ZodXIDParams","ZodKSUID","$ZodKSUIDInternals","$ZodKSUIDParams","ZodIPv4","$ZodIPv4Internals","$ZodIPv4Params","ZodMAC","$ZodMACInternals","mac","$ZodMACParams","ZodIPv6","$ZodIPv6Internals","$ZodIPv6Params","ZodCIDRv4","$ZodCIDRv4Internals","$ZodCIDRv4Params","ZodCIDRv6","$ZodCIDRv6Internals","$ZodCIDRv6Params","ZodBase64","$ZodBase64Internals","$ZodBase64Params","ZodBase64URL","$ZodBase64URLInternals","$ZodBase64URLParams","ZodE164","$ZodE164Internals","$ZodE164Params","ZodJWT","$ZodJWTInternals","$ZodJWTParams","ZodCustomStringFormat","$ZodCustomStringFormatInternals","$ZodCustomStringFormat","stringFormat","MaybeAsync","$ZodStringFormatParams","fnOrRegex","_params","hostname","hex","hash","Alg","Enc","HashAlgorithm","HashEncoding","alg","enc","_ZodNumber","$ZodNumberInternals","$ZodCheckGreaterThanParams","$ZodCheckLessThanParams","$ZodCheckNumberFormatParams","$ZodCheckMultipleOfParams","gt","gte","lt","lte","int","safe","positive","nonnegative","negative","nonpositive","multipleOf","step","finite","minValue","maxValue","isInt","isFinite","ZodNumber","number","$ZodNumberParams","ZodNumberFormat","$ZodNumberFormatInternals","ZodInt","ZodFloat32","float32","ZodFloat64","float64","ZodInt32","int32","ZodUInt32","uint32","_ZodBoolean","$ZodBooleanInternals","ZodBoolean","boolean","$ZodBooleanParams","_ZodBigInt","$ZodBigIntInternals","ZodBigInt","bigint","$ZodBigIntParams","ZodBigIntFormat","$ZodBigIntFormatInternals","int64","$ZodBigIntFormatParams","uint64","ZodSymbol","$ZodSymbolInternals","symbol","$ZodSymbolParams","ZodUndefined","$ZodUndefinedInternals","_undefined","$ZodUndefinedParams","undefined","ZodNull","$ZodNullInternals","_null","$ZodNullParams","null","ZodAny","$ZodAnyInternals","any","ZodUnknown","$ZodUnknownInternals","unknown","ZodNever","$ZodNeverInternals","never","$ZodNeverParams","ZodVoid","$ZodVoidInternals","_void","$ZodVoidParams","void","_ZodDate","$ZodDateInternals","Date","minDate","maxDate","ZodDate","$ZodDateParams","$ZodArrayInternals","$ZodArray","element","unwrap","$ZodArrayParams","keyof","ZodObject","KeysEnum","ZodEnum","SafeExtendShape","Base","Ext","$ZodShape","$ZodLooseShape","K","U","M","Shape","Config","$ZodObjectConfig","$strip","$ZodObjectInternals","ToEnum","$catchall","$loose","$strict","Extend","Record","Partial","Mask","Exclude","Extract","Pick","Flatten","k","$ZodObject","shape","catchall","passthrough","loose","strict","strip","extend","safeExtend","merge","other","pick","mask","omit","partial","required","object","$ZodObjectParams","Writeable","strictObject","looseObject","$ZodUnionInternals","$ZodUnion","options","union","$ZodUnionParams","ZodXor","$ZodXorInternals","$ZodXor","xor","$ZodXorParams","ZodDiscriminatedUnion","Options","Disc","$ZodDiscriminatedUnionInternals","$ZodDiscriminatedUnionDef","$ZodDiscriminatedUnion","discriminatedUnion","Types","$ZodTypeDiscriminable","$ZodDiscriminatedUnionParams","discriminator","A","B","$ZodIntersectionInternals","$ZodIntersection","intersection","left","right","ZodTuple","Rest","TupleItems","$ZodTupleInternals","$ZodTuple","rest","tuple","$ZodTupleParams","items","ZodRecord","Key","Value","$ZodRecordKey","$ZodRecordInternals","$ZodRecord","keyType","valueType","record","$ZodRecordParams","partialRecord","$partial","looseRecord","ZodMap","$ZodMapInternals","$ZodCheckMinSizeParams","$ZodCheckMaxSizeParams","$ZodCheckSizeEqualsParams","$ZodMap","minSize","maxSize","size","map","$ZodMapParams","ZodSet","$ZodSetInternals","$ZodSet","set","$ZodSetParams","EnumLike","$ZodEnumInternals","Array","$ZodEnumParams","$ZodEnum","enum","extract","values","exclude","_enum","entries","nativeEnum","ZodLiteral","Literal","$ZodLiteralInternals","Set","$ZodLiteral","literal","ReadonlyArray","$ZodLiteralParams","ZodFile","$ZodFileInternals","MimeTypes","$ZodCheckMimeTypeParams","$ZodFile","mime","types","file","$ZodFileParams","O","I","$ZodTransformInternals","$ZodTransform","ParsePayload","$ZodOptionalInternals","$ZodOptional","innerType","$ZodExactOptionalInternals","$ZodExactOptional","$ZodNullableInternals","$ZodNullable","$ZodDefaultInternals","$ZodDefault","removeDefault","_default","defaultValue","$ZodPrefaultInternals","$ZodPrefault","$ZodNonOptionalInternals","$ZodNonOptional","ZodSuccess","$ZodSuccessInternals","$ZodSuccess","success","$ZodCatchInternals","$ZodCatch","removeCatch","_catch","catchValue","ZodNaN","$ZodNaNInternals","$ZodNaN","nan","$ZodNaNParams","$ZodPipeInternals","$ZodPipe","in","out","in_","ZodCodec","$ZodCodecInternals","$ZodCodecDef","$ZodCodec","codec","payload","$ZodReadonlyInternals","$ZodReadonly","ZodTemplateLiteral","Template","$ZodTemplateLiteralInternals","$ZodTemplateLiteral","templateLiteral","Parts","$ZodTemplateLiteralPart","$ZodTemplateLiteralParams","$PartsToTemplateLiteral","parts","ZodLazy","$ZodLazyInternals","$ZodLazy","lazy","getter","ZodPromise","$ZodPromiseInternals","$ZodPromise","promise","ZodFunction","Items","NewArgs","NewReturns","Args","Returns","$ZodFunctionIn","$ZodFunctionOut","$ZodFunctionInternals","$ZodFunctionDef","$InferInnerFunctionType","$InferOuterFunctionType","$ZodFunction","args","_function","In","Out","function","ZodCustom","$ZodCustomInternals","$ZodCustom","custom","NoInfer","ZodInstanceOfParams","$ZodIssueCustom","Params","_instanceof","Class","InstanceType","cls","instanceof","stringbool","$ZodStringBoolParams","_ZodJSONSchema","ZodJSONSchema","_ZodJSONSchemaInternals","ZodJSONSchemaInternals","JSONType","json","preprocess"],"sources":["../../../../../../../../../../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/classic/schemas.d.cts"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/api.d.ts

@@ -0,0 +1,32 @@
+import { EmptyToNever, Flatten, MakePartial } from "./util.js";
+import { $ZodCustom, $ZodNonOptional, $ZodType, ParsePayload } from "./schemas.js";
+import { $ZodCheck, $ZodCheckLengthEquals, $ZodCheckMaxLength, $ZodCheckMinLength } from "./checks.js";
+import { $ZodErrorMap, $ZodIssue, $ZodIssueBase } from "./errors.js";
+
+//#region ../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/api.d.cts
+type Params<T extends $ZodType | $ZodCheck, IssueTypes extends $ZodIssueBase, OmitKeys extends keyof T["_zod"]["def"] = never> = Flatten<Partial<EmptyToNever<Omit<T["_zod"]["def"], OmitKeys> & ([IssueTypes] extends [never] ? {} : {
+  error?: string | $ZodErrorMap<IssueTypes> | undefined; /** @deprecated This parameter is deprecated. Use `error` instead. */
+  message?: string | undefined;
+})>>>;
+type TypeParams<T extends $ZodType = $ZodType & {
+  _isst: never;
+}, AlsoOmit extends Exclude<keyof T["_zod"]["def"], "type" | "checks" | "error"> = never> = Params<T, NonNullable<T["_zod"]["isst"]>, "type" | "checks" | "error" | AlsoOmit>;
+type CheckParams<T extends $ZodCheck = $ZodCheck, // & { _issc: never },
+AlsoOmit extends Exclude<keyof T["_zod"]["def"], "check" | "error"> = never> = Params<T, NonNullable<T["_zod"]["issc"]>, "check" | "error" | AlsoOmit>;
+type CheckTypeParams<T extends $ZodType & $ZodCheck = $ZodType & $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>;
+type $ZodCheckMaxLengthParams = CheckParams<$ZodCheckMaxLength, "maximum" | "when">;
+type $ZodCheckMinLengthParams = CheckParams<$ZodCheckMinLength, "minimum" | "when">;
+type $ZodCheckLengthEqualsParams = CheckParams<$ZodCheckLengthEquals, "length" | "when">;
+type $ZodNonOptionalParams = TypeParams<$ZodNonOptional, "innerType">;
+type $ZodCustomParams = CheckTypeParams<$ZodCustom, "fn">;
+type $ZodSuperRefineIssue<T extends $ZodIssueBase = $ZodIssue> = T extends any ? RawIssue<T> : never;
+type RawIssue<T extends $ZodIssueBase> = T extends any ? Flatten<MakePartial<T, "message" | "path"> & {
+  /** The schema or check that originated this issue. */readonly inst?: $ZodType | $ZodCheck; /** If `true`, Zod will execute subsequent checks/refinements instead of immediately aborting */
+  readonly continue?: boolean | undefined;
+} & Record<string, unknown>> : never;
+interface $RefinementCtx<T = unknown> extends ParsePayload<T> {
+  addIssue(arg: string | $ZodSuperRefineIssue): void;
+}
+//#endregion
+export { $RefinementCtx, $ZodCheckLengthEqualsParams, $ZodCheckMaxLengthParams, $ZodCheckMinLengthParams, $ZodCustomParams, $ZodNonOptionalParams };
+//# sourceMappingURL=api.d.ts.map

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","names":["checks","core","errors","registries","schemas","util","Params","T","IssueTypes","OmitKeys","$ZodType","$ZodCheck","$ZodIssueBase","Omit","$ZodErrorMap","EmptyToNever","Partial","Flatten","error","message","TypeParams","AlsoOmit","Exclude","NonNullable","_isst","CheckParams","StringFormatParams","$ZodStringFormat","CheckStringFormatParams","CheckTypeParams","$ZodStringParams","$ZodString","_string","SchemaClass","Class","params","_coercedString","$ZodStringFormatParams","$ZodCheckStringFormatParams","$ZodCheckStringFormat","$ZodEmailParams","$ZodEmail","$ZodCheckEmailParams","_email","$ZodGUIDParams","$ZodGUID","$ZodCheckGUIDParams","_guid","$ZodUUIDParams","$ZodUUID","$ZodCheckUUIDParams","_uuid","$ZodUUIDv4Params","$ZodCheckUUIDv4Params","_uuidv4","$ZodUUIDv6Params","$ZodCheckUUIDv6Params","_uuidv6","$ZodUUIDv7Params","$ZodCheckUUIDv7Params","_uuidv7","$ZodURLParams","$ZodURL","$ZodCheckURLParams","_url","$ZodEmojiParams","$ZodEmoji","$ZodCheckEmojiParams","_emoji","$ZodNanoIDParams","$ZodNanoID","$ZodCheckNanoIDParams","_nanoid","$ZodCUIDParams","$ZodCUID","$ZodCheckCUIDParams","_cuid","$ZodCUID2Params","$ZodCUID2","$ZodCheckCUID2Params","_cuid2","$ZodULIDParams","$ZodULID","$ZodCheckULIDParams","_ulid","$ZodXIDParams","$ZodXID","$ZodCheckXIDParams","_xid","$ZodKSUIDParams","$ZodKSUID","$ZodCheckKSUIDParams","_ksuid","$ZodIPv4Params","$ZodIPv4","$ZodCheckIPv4Params","_ipv4","$ZodIPv6Params","$ZodIPv6","$ZodCheckIPv6Params","_ipv6","$ZodMACParams","$ZodMAC","$ZodCheckMACParams","_mac","$ZodCIDRv4Params","$ZodCIDRv4","$ZodCheckCIDRv4Params","_cidrv4","$ZodCIDRv6Params","$ZodCIDRv6","$ZodCheckCIDRv6Params","_cidrv6","$ZodBase64Params","$ZodBase64","$ZodCheckBase64Params","_base64","$ZodBase64URLParams","$ZodBase64URL","$ZodCheckBase64URLParams","_base64url","$ZodE164Params","$ZodE164","$ZodCheckE164Params","_e164","$ZodJWTParams","$ZodJWT","$ZodCheckJWTParams","_jwt","TimePrecision","Any","Minute","Second","Millisecond","Microsecond","$ZodISODateTimeParams","$ZodISODateTime","$ZodCheckISODateTimeParams","_isoDateTime","$ZodISODateParams","$ZodISODate","$ZodCheckISODateParams","_isoDate","$ZodISOTimeParams","$ZodISOTime","$ZodCheckISOTimeParams","_isoTime","$ZodISODurationParams","$ZodISODuration","$ZodCheckISODurationParams","_isoDuration","$ZodNumberParams","$ZodNumber","$ZodNumberFormatParams","$ZodNumberFormat","$ZodCheckNumberFormatParams","$ZodCheckNumberFormat","_number","_coercedNumber","_int","_float32","_float64","_int32","_uint32","$ZodBooleanParams","$ZodBoolean","_boolean","_coercedBoolean","$ZodBigIntParams","$ZodBigInt","$ZodBigIntFormatParams","$ZodBigIntFormat","$ZodCheckBigIntFormatParams","$ZodCheckBigIntFormat","_bigint","_coercedBigint","_int64","_uint64","$ZodSymbolParams","$ZodSymbol","_symbol","$ZodUndefinedParams","$ZodUndefined","_undefined","$ZodNullParams","$ZodNull","_null","$ZodAnyParams","$ZodAny","_any","$ZodUnknownParams","$ZodUnknown","_unknown","$ZodNeverParams","$ZodNever","_never","$ZodVoidParams","$ZodVoid","_void","$ZodDateParams","$ZodDate","_date","_coercedDate","$ZodNaNParams","$ZodNaN","_nan","$ZodCheckLessThanParams","$ZodCheckLessThan","_lt","Numeric","value","_lte","_max","$ZodCheckGreaterThanParams","$ZodCheckGreaterThan","_gt","_gte","_min","_positive","_negative","_nonpositive","_nonnegative","$ZodCheckMultipleOfParams","$ZodCheckMultipleOf","_multipleOf","$ZodCheckMaxSizeParams","$ZodCheckMaxSize","_maxSize","HasSize","maximum","$ZodCheckMinSizeParams","$ZodCheckMinSize","_minSize","minimum","$ZodCheckSizeEqualsParams","$ZodCheckSizeEquals","_size","size","$ZodCheckMaxLengthParams","$ZodCheckMaxLength","_maxLength","HasLength","$ZodCheckMinLengthParams","$ZodCheckMinLength","_minLength","$ZodCheckLengthEqualsParams","$ZodCheckLengthEquals","_length","length","$ZodCheckRegexParams","$ZodCheckRegex","_regex","RegExp","pattern","$ZodCheckLowerCaseParams","$ZodCheckLowerCase","_lowercase","$ZodCheckUpperCaseParams","$ZodCheckUpperCase","_uppercase","$ZodCheckIncludesParams","$ZodCheckIncludes","_includes","includes","$ZodCheckStartsWithParams","$ZodCheckStartsWith","_startsWith","prefix","$ZodCheckEndsWithParams","$ZodCheckEndsWith","_endsWith","suffix","$ZodCheckPropertyParams","$ZodCheckProperty","_property","K","output","property","schema","k","$ZodCheckMimeTypeParams","$ZodCheckMimeType","_mime","MimeTypes","types","_overwrite","$ZodCheckOverwrite","input","tx","_normalize","form","_trim","_toLowerCase","_toUpperCase","_slugify","$ZodArrayParams","$ZodArray","_array","element","$ZodObjectParams","$ZodObject","$ZodUnionParams","$ZodUnion","_union","options","$ZodXorParams","$ZodXor","_xor","$ZodTypeDiscriminableInternals","PropValues","$ZodTypeInternals","propValues","$ZodTypeDiscriminable","_zod","$ZodDiscriminatedUnionParams","$ZodDiscriminatedUnion","_discriminatedUnion","Types","Disc","discriminator","$ZodIntersectionParams","$ZodIntersection","_intersection","U","left","right","$ZodTupleParams","$ZodTuple","_tuple","items","Rest","rest","$ZodRecordParams","$ZodRecord","_record","Key","Value","$ZodRecordKey","keyType","valueType","$ZodMapParams","$ZodMap","_map","$ZodSetParams","$ZodSet","_set","$ZodEnumParams","$ZodEnum","_enum","ToEnum","values","EnumLike","entries","_nativeEnum","$ZodLiteralParams","$ZodLiteral","_literal","Literal","Array","$ZodFileParams","$ZodFile","_file","$ZodTransformParams","$ZodTransform","_transform","I","O","ParsePayload","Awaited","ctx","fn","$ZodOptionalParams","$ZodOptional","_optional","innerType","$ZodNullableParams","$ZodNullable","_nullable","$ZodDefaultParams","$ZodDefault","_default","NoUndefined","defaultValue","$ZodNonOptionalParams","$ZodNonOptional","_nonoptional","$ZodSuccessParams","$ZodSuccess","_success","$ZodCatchParams","$ZodCatch","_catch","$ZodCatchCtx","catchValue","$ZodPipeParams","$ZodPipe","_pipe","A","B","in_","out","$ZodReadonlyParams","$ZodReadonly","_readonly","$ZodTemplateLiteralParams","$ZodTemplateLiteral","_templateLiteral","Parts","$ZodTemplateLiteralPart","$PartsToTemplateLiteral","parts","$ZodLazyParams","$ZodLazy","_lazy","getter","$ZodPromiseParams","$ZodPromise","_promise","$ZodCustomParams","$ZodCustom","_custom","data","_params","_refine","$ZodSuperRefineIssue","$ZodIssue","RawIssue","MakePartial","Record","inst","continue","$RefinementCtx","addIssue","arg","_superRefine","Promise","payload","_check","CheckFn","describe","description","meta","GlobalMeta","metadata","$ZodStringBoolParams","truthy","falsy","case","_stringbool","$ZodCodec","Codec","Boolean","String","Classes","_stringFormat","Format","$ZodCustomStringFormat","MaybeAsync","format","fnOrRegex"],"sources":["../../../../../../../../../../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/api.d.cts"],"x_google_ignoreList":[0],"mappings":";;;;;;KAMYM,MAAAA,WAAiBF,QAAAA,GAAmBJ,SAAAA,qBAAqCE,aAAAA,yBAA6CK,CAAAA,2BAA4BF,OAAAA,CAAaW,OAAAA,CAAQX,YAAAA,CAAkBQ,IAAAA,CAAKN,CAAAA,iBAAkBE,QAAAA,MAAcD,UAAAA;EACtOU,KAAAA,YAAiBhB,YAAAA,CAAoBM,UAAAA,eADvBD;EAGdY,OAAAA;AAAAA;AAAAA,KAEQC,UAAAA,WAAqBhB,QAAAA,GAAmBA,QAAAA;EAChDoB,KAAAA;AAAAA,oBACgBF,OAAAA,OAAcf,CAAAA,yDAA0DD,MAAAA,CAAOC,CAAAA,EAAGgB,WAAAA,CAAYhB,CAAAA,iDAAkDc,QAAAA;AAAAA,KACxJI,WAAAA,WAAsBzB,SAAAA,GAAmBA,SAAAA;AAAAA,iBACpCsB,OAAAA,OAAcf,CAAAA,+CAAgDD,MAAAA,CAAOC,CAAAA,EAAGgB,WAAAA,CAAYhB,CAAAA,uCAAwCc,QAAAA;AAAAA,KAGjIQ,eAAAA,WAA0BzB,QAAAA,GAAmBJ,SAAAA,GAAmBI,QAAAA,GAAmBJ,SAAAA,mBAAmCsB,OAAAA,OAAcf,CAAAA,mEAAoED,MAAAA,CAAOC,CAAAA,EAAGgB,WAAAA,CAAYhB,CAAAA,mBAAoBA,CAAAA,2DAA4Dc,QAAAA;AAAAA,KA6J9SyN,wBAAAA,GAA2BrN,WAAAA,CAAYzB,kBAAAA;AAAAA,KAEvCkP,wBAAAA,GAA2BzN,WAAAA,CAAYzB,kBAAAA;AAAAA,KAEvCqP,2BAAAA,GAA8B5N,WAAAA,CAAYzB,qBAAAA;AAAAA,KA4E1C+X,qBAAAA,GAAwB3W,UAAAA,CAAWhB,eAAAA;AAAAA,KAgBnC8Z,gBAAAA,GAAmBrY,eAAAA,CAAgBzB,UAAAA;AAAAA,KAGnCoa,oBAAAA,WAA+Bta,aAAAA,GAAuBA,SAAAA,IAAoBK,CAAAA,eAAgBma,QAAAA,CAASna,CAAAA;AAAAA,KAC1Gma,QAAAA,WAAmBxa,aAAAA,IAAwBK,CAAAA,eAAgBF,OAAAA,CAAaA,WAAAA,CAAiBE,CAAAA;iEAEjFsa,IAAAA,GAAOza,QAAAA,GAAmBJ,SAAAA;WAE1B8a,QAAAA;AAAAA,IACTF,MAAAA;AAAAA,UACaG,cAAAA,sBAAoC3a,YAAAA,CAAqBG,CAAAA;EACtEya,QAAAA,CAASC,GAAAA,WAAcT,oBAAAA;AAAAA"}

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/checks.d.ts

@@ -0,0 +1,65 @@
+import { HasLength, MaybeAsync } from "./util.js";
+import { $ZodType, ParsePayload } from "./schemas.js";
+import { $ZodErrorMap, $ZodIssueBase, $ZodIssueTooBig, $ZodIssueTooSmall } from "./errors.js";
+import { $constructor } from "./core.js";
+
+//#region ../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/checks.d.cts
+interface $ZodCheckDef {
+  check: string;
+  error?: $ZodErrorMap<never> | undefined;
+  /** If true, no later checks will be executed if this check fails. Default `false`. */
+  abort?: boolean | undefined;
+  /** If provided, this check will only be executed if the function returns `true`. Defaults to `payload => z.util.isAborted(payload)`. */
+  when?: ((payload: ParsePayload) => boolean) | undefined;
+}
+interface $ZodCheckInternals<T> {
+  def: $ZodCheckDef;
+  /** The set of issues this check might throw. */
+  issc?: $ZodIssueBase;
+  check(payload: ParsePayload<T>): MaybeAsync<void>;
+  onattach: ((schema: $ZodType) => void)[];
+}
+interface $ZodCheck<in T = never> {
+  _zod: $ZodCheckInternals<T>;
+}
+declare const $ZodCheck: $constructor<$ZodCheck<any>>;
+interface $ZodCheckMaxLengthDef extends $ZodCheckDef {
+  check: "max_length";
+  maximum: number;
+}
+interface $ZodCheckMaxLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMaxLengthDef;
+  issc: $ZodIssueTooBig<T>;
+}
+interface $ZodCheckMaxLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMaxLengthInternals<T>;
+}
+declare const $ZodCheckMaxLength: $constructor<$ZodCheckMaxLength>;
+interface $ZodCheckMinLengthDef extends $ZodCheckDef {
+  check: "min_length";
+  minimum: number;
+}
+interface $ZodCheckMinLengthInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckMinLengthDef;
+  issc: $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckMinLength<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckMinLengthInternals<T>;
+}
+declare const $ZodCheckMinLength: $constructor<$ZodCheckMinLength>;
+interface $ZodCheckLengthEqualsDef extends $ZodCheckDef {
+  check: "length_equals";
+  length: number;
+}
+interface $ZodCheckLengthEqualsInternals<T extends HasLength = HasLength> extends $ZodCheckInternals<T> {
+  def: $ZodCheckLengthEqualsDef;
+  issc: $ZodIssueTooBig<T> | $ZodIssueTooSmall<T>;
+}
+interface $ZodCheckLengthEquals<T extends HasLength = HasLength> extends $ZodCheck<T> {
+  _zod: $ZodCheckLengthEqualsInternals<T>;
+}
+declare const $ZodCheckLengthEquals: $constructor<$ZodCheckLengthEquals>;
+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";
+//#endregion
+export { $ZodCheck, $ZodCheckDef, $ZodCheckInternals, $ZodCheckLengthEquals, $ZodCheckMaxLength, $ZodCheckMinLength, $ZodStringFormats };
+//# sourceMappingURL=checks.d.ts.map

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","names":["core","errors","schemas","util","$ZodCheckDef","$ZodErrorMap","ParsePayload","check","error","abort","when","payload","$ZodCheckInternals","T","$ZodIssueBase","MaybeAsync","$ZodType","def","issc","onattach","schema","$ZodCheck","_zod","$constructor","$ZodCheckLessThanDef","Numeric","value","inclusive","$ZodCheckLessThanInternals","$ZodIssueTooBig","$ZodCheckLessThan","$ZodCheckGreaterThanDef","$ZodCheckGreaterThanInternals","$ZodIssueTooSmall","$ZodCheckGreaterThan","$ZodCheckMultipleOfDef","$ZodCheckMultipleOfInternals","$ZodIssueNotMultipleOf","$ZodCheckMultipleOf","$ZodNumberFormats","$ZodCheckNumberFormatDef","format","$ZodCheckNumberFormatInternals","$ZodIssueInvalidType","$ZodCheckNumberFormat","$ZodBigIntFormats","$ZodCheckBigIntFormatDef","$ZodCheckBigIntFormatInternals","$ZodCheckBigIntFormat","$ZodCheckMaxSizeDef","maximum","$ZodCheckMaxSizeInternals","HasSize","$ZodCheckMaxSize","$ZodCheckMinSizeDef","minimum","$ZodCheckMinSizeInternals","$ZodCheckMinSize","$ZodCheckSizeEqualsDef","size","$ZodCheckSizeEqualsInternals","$ZodCheckSizeEquals","$ZodCheckMaxLengthDef","$ZodCheckMaxLengthInternals","HasLength","$ZodCheckMaxLength","$ZodCheckMinLengthDef","$ZodCheckMinLengthInternals","$ZodCheckMinLength","$ZodCheckLengthEqualsDef","length","$ZodCheckLengthEqualsInternals","$ZodCheckLengthEquals","$ZodStringFormats","$ZodCheckStringFormatDef","Format","RegExp","pattern","$ZodCheckStringFormatInternals","$ZodIssueInvalidStringFormat","$ZodCheckStringFormat","$ZodCheckRegexDef","$ZodCheckRegexInternals","$ZodCheckRegex","$ZodCheckLowerCaseDef","$ZodCheckLowerCaseInternals","$ZodCheckLowerCase","$ZodCheckUpperCaseDef","$ZodCheckUpperCaseInternals","$ZodCheckUpperCase","$ZodCheckIncludesDef","includes","position","$ZodCheckIncludesInternals","$ZodCheckIncludes","$ZodCheckStartsWithDef","prefix","$ZodCheckStartsWithInternals","$ZodCheckStartsWith","$ZodCheckEndsWithDef","suffix","$ZodCheckEndsWithInternals","$ZodCheckEndsWith","$ZodCheckPropertyDef","property","$ZodCheckPropertyInternals","$ZodIssue","$ZodCheckProperty","$ZodCheckMimeTypeDef","MimeTypes","mime","$ZodCheckMimeTypeInternals","File","$ZodIssueInvalidValue","$ZodCheckMimeType","$ZodCheckOverwriteDef","tx","$ZodCheckOverwriteInternals","$ZodCheckOverwrite","$ZodChecks","$ZodStringFormatChecks","$ZodStringFormatTypes"],"sources":["../../../../../../../../../../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/checks.d.cts"],"x_google_ignoreList":[0],"mappings":";;;;;;UAIiBI,YAAAA;EACbG,KAAAA;EACAC,KAAAA,GAAQP,YAAAA;EAFiB;EAIzBQ,KAAAA;EAEsC;EAAtCC,IAAAA,KAASC,OAAAA,EAAST,YAAAA;AAAAA;AAAAA,UAELU,kBAAAA;EACbK,GAAAA,EAAKb,YAAAA;EALLK;EAOAS,IAAAA,GAAOjB,aAAAA;EACPM,KAAAA,CAAMI,OAAAA,EAAST,YAAAA,CAAqBW,CAAAA,IAAKV,UAAAA;EACzCgB,QAAAA,IAAYC,MAAAA,EAAQlB,QAAAA;AAAAA;AAAAA,UAEPmB,SAAAA;EACbC,IAAAA,EAAMV,kBAAAA,CAAmBC,CAAAA;AAAAA;AAAAA,cAERQ,SAAAA,EAAWrB,YAAAA,CAAkBqB,SAAAA;AAAAA,UAqGjCyC,qBAAAA,SAA8B1D,YAAAA;EAC3CG,KAAAA;EACA2C,OAAAA;AAAAA;AAAAA,UAEaa,2BAAAA,WAAsC5D,SAAAA,GAAiBA,SAAAA,UAAwBS,kBAAAA,CAAmBC,CAAAA;EAC/GI,GAAAA,EAAK6C,qBAAAA;EACL5C,IAAAA,EAAMjB,eAAAA,CAAuBY,CAAAA;AAAAA;AAAAA,UAEhBoD,kBAAAA,WAA6B9D,SAAAA,GAAiBA,SAAAA,UAAwBkB,SAAAA,CAAUR,CAAAA;EAC7FS,IAAAA,EAAMyC,2BAAAA,CAA4BlD,CAAAA;AAAAA;AAAAA,cAEjBoD,kBAAAA,EAAoBjE,YAAAA,CAAkBiE,kBAAAA;AAAAA,UAC1CC,qBAAAA,SAA8B9D,YAAAA;EAC3CG,KAAAA;EACAgD,OAAAA;AAAAA;AAAAA,UAEaY,2BAAAA,WAAsChE,SAAAA,GAAiBA,SAAAA,UAAwBS,kBAAAA,CAAmBC,CAAAA;EAC/GI,GAAAA,EAAKiD,qBAAAA;EACLhD,IAAAA,EAAMjB,iBAAAA,CAAyBY,CAAAA;AAAAA;AAAAA,UAElBuD,kBAAAA,WAA6BjE,SAAAA,GAAiBA,SAAAA,UAAwBkB,SAAAA,CAAUR,CAAAA;EAC7FS,IAAAA,EAAM6C,2BAAAA,CAA4BtD,CAAAA;AAAAA;AAAAA,cAEjBuD,kBAAAA,EAAoBpE,YAAAA,CAAkBoE,kBAAAA;AAAAA,UAC1CC,wBAAAA,SAAiCjE,YAAAA;EAC9CG,KAAAA;EACA+D,MAAAA;AAAAA;AAAAA,UAEaC,8BAAAA,WAAyCpE,SAAAA,GAAiBA,SAAAA,UAAwBS,kBAAAA,CAAmBC,CAAAA;EAClHI,GAAAA,EAAKoD,wBAAAA;EACLnD,IAAAA,EAAMjB,eAAAA,CAAuBY,CAAAA,IAAKZ,iBAAAA,CAAyBY,CAAAA;AAAAA;AAAAA,UAE9C2D,qBAAAA,WAAgCrE,SAAAA,GAAiBA,SAAAA,UAAwBkB,SAAAA,CAAUR,CAAAA;EAChGS,IAAAA,EAAMiD,8BAAAA,CAA+B1D,CAAAA;AAAAA;AAAAA,cAEpB2D,qBAAAA,EAAuBxE,YAAAA,CAAkBwE,qBAAAA;AAAAA,KAClDC,iBAAAA"}

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.d.ts

@@ -0,0 +1,48 @@
+import { Class } from "./util.js";
+import { SomeType } from "./schemas.js";
+
+//#region ../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.d.cts
+type ZodTrait = {
+  _zod: {
+    def: any;
+    [k: string]: any;
+  };
+};
+interface $constructor<T extends ZodTrait, D = T["_zod"]["def"]> {
+  new (def: D): T;
+  init(inst: T, def: D): asserts inst is T;
+}
+declare function $constructor<T extends ZodTrait, D = T["_zod"]["def"]>(name: string, initializer: (inst: T, def: D) => void, params?: {
+  Parent?: typeof Class;
+}): $constructor<T, D>;
+declare const $brand: unique symbol;
+type $brand<T extends string | number | symbol = string | number | symbol> = {
+  [$brand]: { [k in T]: true };
+};
+type $ZodBranded<T extends SomeType, Brand extends string | number | symbol, Dir extends "in" | "out" | "inout" = "out"> = T & (Dir extends "inout" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+    output: output<T> & $brand<Brand>;
+  };
+} : Dir extends "in" ? {
+  _zod: {
+    input: input<T> & $brand<Brand>;
+  };
+} : {
+  _zod: {
+    output: output<T> & $brand<Brand>;
+  };
+});
+type input<T> = T extends {
+  _zod: {
+    input: any;
+  };
+} ? T["_zod"]["input"] : unknown;
+type output<T> = T extends {
+  _zod: {
+    output: any;
+  };
+} ? T["_zod"]["output"] : unknown;
+//#endregion
+export { $ZodBranded, $constructor, input, output };
+//# sourceMappingURL=core.d.ts.map

package/dist/types/node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","names":["errors","schemas","Class","ZodTrait","_zod","def","k","$constructor","T","D","init","inst","NEVER","name","initializer","Parent","params","$brand","$ZodBranded","Brand","Dir","SomeType","input","output","$ZodNarrow","Out","$ZodAsyncError","Error","constructor","$ZodEncodeError","infer","$ZodConfig","$ZodErrorMap","customError","localeError","jitless","globalConfig","config","Partial","newConfig"],"sources":["../../../../../../../../../../../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/core.d.cts"],"x_google_ignoreList":[0],"mappings":";;;;KAGKG,QAAAA;EACDC,IAAAA;IACIC,GAAAA;IAAAA,CACCC,CAAAA;EAAAA;AAAAA;AAAAA,UAGQC,YAAAA,WAAuBJ,QAAAA,MAAcK,CAAAA;EAAAA,KAC7CH,GAAAA,EAAKI,CAAAA,GAAID,CAAAA;EACdE,IAAAA,CAAKC,IAAAA,EAAMH,CAAAA,EAAGH,GAAAA,EAAKI,CAAAA,WAAYE,IAAAA,IAAQH,CAAAA;AAAAA;AAAAA,iBAInBD,YAAAA,WAAuBJ,QAAAA,MAAcK,CAAAA,gBAAAA,CAAkBK,IAAAA,UAAcC,WAAAA,GAAcH,IAAAA,EAAMH,CAAAA,EAAGH,GAAAA,EAAKI,CAAAA,WAAYO,MAAAA;EACjID,MAAAA,UAAgBb,KAAAA;AAAAA,IAChBK,YAAAA,CAAaC,CAAAA,EAAGC,CAAAA;AAAAA,cACCQ,MAAAA;AAAAA,KACTA,MAAAA;EAAAA,CACPA,MAAAA,WACST,CAAAA;AAAAA;AAAAA,KAGFU,WAAAA,WAAsBjB,QAAAA,wFAAwGO,CAAAA,IAAKY,GAAAA;EAC3IhB,IAAAA;IACIkB,KAAAA,EAAOA,KAAAA,CAAMd,CAAAA,IAAKS,MAAAA,CAAOE,KAAAA;IACzBI,MAAAA,EAAQA,MAAAA,CAAOf,CAAAA,IAAKS,MAAAA,CAAOE,KAAAA;EAAAA;AAAAA,IAE/BC,GAAAA;EACAhB,IAAAA;IACIkB,KAAAA,EAAOA,KAAAA,CAAMd,CAAAA,IAAKS,MAAAA,CAAOE,KAAAA;EAAAA;AAAAA;EAG7Bf,IAAAA;IACImB,MAAAA,EAAQA,MAAAA,CAAOf,CAAAA,IAAKS,MAAAA,CAAOE,KAAAA;EAAAA;AAAAA;AAAAA,KAcvBG,KAAAA,MAAWd,CAAAA;EACnBJ,IAAAA;IACIkB,KAAAA;EAAAA;AAAAA,IAEJd,CAAAA;AAAAA,KACQe,MAAAA,MAAYf,CAAAA;EACpBJ,IAAAA;IACImB,MAAAA;EAAAA;AAAAA,IAEJf,CAAAA"}