ima2-gen 3.14.0 → 3.15.0

package/node_modules/zod/v4/mini/external.d.ts

@@ -2,9 +2,12 @@ export * as core from "../core/index.js";
 export * from "./parse.js";
 export * from "./schemas.js";
 export * from "./checks.js";
-export type { infer, output, input } from "../core/index.js";
+export { deepPartial } from "./deep-partial.js";
+export { input, output } from "./in-out.js";
+export type { infer } from "../core/index.js";
 export type { JSONType } from "../core/util.js";
-export { globalRegistry, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from "../core/index.js";
+export type { CompileOptions } from "../core/index.js";
+export { globalRegistry, registry, config, memoizer, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, toZod, compile, ZodCompileAsyncError, ZodCompileUnsupportedError, getDiscriminatedOption, } from "../core/index.js";
 export { toJSONSchema } from "../core/json-schema-processors.js";
 export * as locales from "../locales/index.js";
 /** A special constant with type `never` */

package/node_modules/zod/v4/mini/external.js

@@ -2,7 +2,9 @@ export * as core from "../core/index.js";
 export * from "./parse.js";
 export * from "./schemas.js";
 export * from "./checks.js";
-export { globalRegistry, registry, config, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, } from "../core/index.js";
+export { deepPartial } from "./deep-partial.js";
+export { input, output } from "./in-out.js";
+export { globalRegistry, registry, config, memoizer, $output, $input, $brand, clone, regexes, treeifyError, prettifyError, formatError, flattenError, TimePrecision, util, NEVER, toZod, compile, ZodCompileAsyncError, ZodCompileUnsupportedError, getDiscriminatedOption, } from "../core/index.js";
 export { toJSONSchema } from "../core/json-schema-processors.js";
 export * as locales from "../locales/index.js";
 /** A special constant with type `never` */

package/node_modules/zod/v4/mini/in-out.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.input = input;
+exports.output = output;
+const util_js_1 = require("../core/util.cjs");
+const visit_js_1 = require("../core/visit.cjs");
+const schemas = __importStar(require("./schemas.cjs"));
+/** See `classic/in-out.ts`. */
+function withChecks(side, checks) {
+    if (!checks?.length)
+        return side;
+    const def = side._zod.def;
+    return (0, util_js_1.clone)(side, (0, util_js_1.mergeDefs)(def, { checks: [...(def.checks ?? []), ...checks] }), { parent: true });
+}
+/** See `classic/in-out.ts`. */
+function outSide(def) {
+    return withChecks(def.out, def.checks);
+}
+/** See `classic/in-out.ts`. */
+function inSide(def) {
+    return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+}
+/** See `classic/in-out.ts`. */
+function input(schema) {
+    return (0, visit_js_1.visit)(schema, {
+        pipe: (s) => inSide(s._zod.def),
+        // A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
+        default: (s, rewritten) => (rewritten ? schemas.optional(s._zod.def.innerType) : s),
+        // A catch value is output-side too, but `.catch()` leaves the declared input type alone, so the inner schema stands on its own.
+        catch: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+    });
+}
+/** See `classic/in-out.ts`. */
+function output(schema) {
+    return (0, visit_js_1.visit)(schema, {
+        pipe: (s) => outSide(s._zod.def),
+        // A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
+        prefault: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+    });
+}

package/node_modules/zod/v4/mini/in-out.d.cts

@@ -0,0 +1,8 @@
+import type * as core from "../core/index.cjs";
+import * as schemas from "./schemas.cjs";
+export type input<T> = core.input<T>;
+export type output<T> = core.output<T>;
+/** See `classic/in-out.ts`. */
+export declare function input<T extends core.$ZodType>(schema: T): schemas.ZodMiniType<core.input<T>, core.input<T>>;
+/** See `classic/in-out.ts`. */
+export declare function output<T extends core.$ZodType>(schema: T): schemas.ZodMiniType<core.output<T>, core.output<T>>;

package/node_modules/zod/v4/mini/in-out.d.ts

@@ -0,0 +1,8 @@
+import type * as core from "../core/index.js";
+import * as schemas from "./schemas.js";
+export type input<T> = core.input<T>;
+export type output<T> = core.output<T>;
+/** See `classic/in-out.ts`. */
+export declare function input<T extends core.$ZodType>(schema: T): schemas.ZodMiniType<core.input<T>, core.input<T>>;
+/** See `classic/in-out.ts`. */
+export declare function output<T extends core.$ZodType>(schema: T): schemas.ZodMiniType<core.output<T>, core.output<T>>;

package/node_modules/zod/v4/mini/in-out.js

@@ -0,0 +1,36 @@
+import { clone, mergeDefs } from "../core/util.js";
+import { visit } from "../core/visit.js";
+import * as schemas from "./schemas.js";
+/** See `classic/in-out.ts`. */
+function withChecks(side, checks) {
+    if (!checks?.length)
+        return side;
+    const def = side._zod.def;
+    return clone(side, mergeDefs(def, { checks: [...(def.checks ?? []), ...checks] }), { parent: true });
+}
+/** See `classic/in-out.ts`. */
+function outSide(def) {
+    return withChecks(def.out, def.checks);
+}
+/** See `classic/in-out.ts`. */
+function inSide(def) {
+    return def.in._zod.traits.has("$ZodTransform") ? outSide(def) : def.in;
+}
+/** See `classic/in-out.ts`. */
+export function input(schema) {
+    return visit(schema, {
+        pipe: (s) => inSide(s._zod.def),
+        // A default value belongs to the output side, so a rewritten inner type leaves it stranded. `.default()` widens the declared input type with `undefined`, and `optional` is what carries that across.
+        default: (s, rewritten) => (rewritten ? schemas.optional(s._zod.def.innerType) : s),
+        // A catch value is output-side too, but `.catch()` leaves the declared input type alone, so the inner schema stands on its own.
+        catch: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+    });
+}
+/** See `classic/in-out.ts`. */
+export function output(schema) {
+    return visit(schema, {
+        pipe: (s) => outSide(s._zod.def),
+        // A prefault value is fed through the schema, which makes it input-side, so a rewritten inner type leaves it stranded.
+        prefault: (s, rewritten) => (rewritten ? s._zod.def.innerType : s),
+    });
+}

package/node_modules/zod/v4/mini/parse.cjs

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.safeDecodeAsync = exports.safeEncodeAsync = exports.safeDecode = exports.safeEncode = exports.decodeAsync = exports.encodeAsync = exports.decode = exports.encode = exports.safeParseAsync = exports.parseAsync = exports.safeParse = exports.parse = void 0;
+exports.safeDecodeAsync = exports.safeEncodeAsync = exports.safeDecode = exports.safeEncode = exports.decodeAsync = exports.encodeAsync = exports.decode = exports.encode = exports.safeParseAsync = exports.parseAsync = exports.safeParse = exports.parse = exports.validateAsync = exports.validate = void 0;
 var index_js_1 = require("../core/index.cjs");
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return index_js_1.validate; } });
+Object.defineProperty(exports, "validateAsync", { enumerable: true, get: function () { return index_js_1.validateAsync; } });
 Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return index_js_1.parse; } });
 Object.defineProperty(exports, "safeParse", { enumerable: true, get: function () { return index_js_1.safeParse; } });
 Object.defineProperty(exports, "parseAsync", { enumerable: true, get: function () { return index_js_1.parseAsync; } });

package/node_modules/zod/v4/mini/parse.d.cts

@@ -1 +1 @@
-export { parse, safeParse, parseAsync, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync, } from "../core/index.cjs";
+export { validate, validateAsync, parse, safeParse, parseAsync, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync, } from "../core/index.cjs";

package/node_modules/zod/v4/mini/parse.d.ts

@@ -1 +1 @@
-export { parse, safeParse, parseAsync, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync, } from "../core/index.js";
+export { validate, validateAsync, parse, safeParse, parseAsync, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync, } from "../core/index.js";

package/node_modules/zod/v4/mini/parse.js

@@ -1 +1 @@
-export { parse, safeParse, parseAsync, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync, } from "../core/index.js";
+export { validate, validateAsync, parse, safeParse, parseAsync, safeParseAsync, encode, decode, encodeAsync, decodeAsync, safeEncode, safeDecode, safeEncodeAsync, safeDecodeAsync, } from "../core/index.js";

package/node_modules/zod/v4/mini/schemas.cjs

@@ -23,8 +23,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZodMiniFile = exports.ZodMiniLiteral = exports.ZodMiniEnum = exports.ZodMiniSet = exports.ZodMiniMap = exports.ZodMiniRecord = exports.ZodMiniTuple = exports.ZodMiniIntersection = exports.ZodMiniDiscriminatedUnion = exports.ZodMiniXor = exports.ZodMiniUnion = exports.ZodMiniObject = exports.ZodMiniArray = exports.ZodMiniDate = exports.ZodMiniVoid = exports.ZodMiniNever = exports.ZodMiniUnknown = exports.ZodMiniAny = exports.ZodMiniNull = exports.ZodMiniUndefined = exports.ZodMiniSymbol = exports.ZodMiniBigIntFormat = exports.ZodMiniBigInt = exports.ZodMiniBoolean = exports.ZodMiniNumberFormat = exports.ZodMiniNumber = exports.ZodMiniCustomStringFormat = exports.ZodMiniJWT = exports.ZodMiniE164 = exports.ZodMiniBase64URL = exports.ZodMiniBase64 = exports.ZodMiniMAC = exports.ZodMiniCIDRv6 = exports.ZodMiniCIDRv4 = exports.ZodMiniIPv6 = exports.ZodMiniIPv4 = exports.ZodMiniKSUID = exports.ZodMiniXID = exports.ZodMiniULID = exports.ZodMiniCUID2 = exports.ZodMiniCUID = exports.ZodMiniNanoID = exports.ZodMiniEmoji = exports.ZodMiniURL = exports.ZodMiniUUID = exports.ZodMiniGUID = exports.ZodMiniEmail = exports.ZodMiniStringFormat = exports.ZodMiniString = exports.ZodMiniType = void 0;
-exports.ZodMiniFunction = exports.stringbool = exports.meta = exports.describe = exports.ZodMiniCustom = exports.ZodMiniPromise = exports.ZodMiniLazy = exports.ZodMiniTemplateLiteral = exports.ZodMiniReadonly = exports.ZodMiniCodec = exports.ZodMiniPipe = exports.ZodMiniNaN = exports.ZodMiniCatch = exports.ZodMiniSuccess = exports.ZodMiniNonOptional = exports.ZodMiniPrefault = exports.ZodMiniDefault = exports.ZodMiniNullable = exports.ZodMiniExactOptional = exports.ZodMiniOptional = exports.ZodMiniTransform = void 0;
+exports.ZodMiniLiteral = exports.ZodMiniEnum = exports.ZodMiniSet = exports.ZodMiniMap = exports.ZodMiniRecord = exports.ZodMiniTuple = exports.ZodMiniIntersection = exports.ZodMiniDiscriminatedUnion = exports.ZodMiniXor = exports.ZodMiniUnion = exports.ZodMiniObject = exports.ZodMiniArray = exports.ZodMiniDate = exports.ZodMiniVoid = exports.ZodMiniNever = exports.ZodMiniUnknown = exports.ZodMiniAny = exports.ZodMiniNull = exports.ZodMiniUndefined = exports.ZodMiniSymbol = exports.ZodMiniBigIntFormat = exports.ZodMiniBigInt = exports.ZodMiniBoolean = exports.ZodMiniNumberFormat = exports.ZodMiniNumber = exports.ZodMiniCustomStringFormat = exports.ZodMiniJWT = exports.ZodMiniCreditCard = exports.ZodMiniE164 = exports.ZodMiniBase64URL = exports.ZodMiniBase64 = exports.ZodMiniMAC = exports.ZodMiniCIDRv6 = exports.ZodMiniCIDRv4 = exports.ZodMiniIPv6 = exports.ZodMiniIPv4 = exports.ZodMiniKSUID = exports.ZodMiniXID = exports.ZodMiniULID = exports.ZodMiniCUID2 = exports.ZodMiniCUID = exports.ZodMiniNanoID = exports.ZodMiniEmoji = exports.ZodMiniURL = exports.ZodMiniUUID = exports.ZodMiniGUID = exports.ZodMiniEmail = exports.ZodMiniStringFormat = exports.ZodMiniString = exports.ZodMiniType = void 0;
+exports.ZodMiniFunction = exports.stringbool = exports.meta = exports.describe = exports.ZodMiniCustom = exports.ZodMiniPromise = exports.ZodMiniLazy = exports.ZodMiniTemplateLiteral = exports.ZodMiniReadonly = exports.ZodMiniCodec = exports.ZodMiniPipe = exports.ZodMiniNaN = exports.ZodMiniCatch = exports.ZodMiniSuccess = exports.ZodMiniNonOptional = exports.ZodMiniPrefault = exports.ZodMiniDefault = exports.ZodMiniNullable = exports.ZodMiniExactOptional = exports.ZodMiniOptional = exports.ZodMiniTransform = exports.ZodMiniFile = void 0;
 exports.string = string;
 exports.email = email;
 exports.guid = guid;
@@ -49,6 +49,7 @@ exports.mac = mac;
 exports.base64 = base64;
 exports.base64url = base64url;
 exports.e164 = e164;
+exports.creditCard = creditCard;
 exports.jwt = jwt;
 exports.stringFormat = stringFormat;
 exports.hostname = hostname;
@@ -83,6 +84,7 @@ exports.merge = merge;
 exports.pick = pick;
 exports.omit = omit;
 exports.partial = partial;
+exports.exactPartial = exactPartial;
 exports.required = required;
 exports.catchall = catchall;
 exports.union = union;
@@ -136,31 +138,49 @@ exports.ZodMiniType = core.$constructor("ZodMiniType", (inst, def) => {
     core.$ZodType.init(inst, def);
     inst.def = def;
     inst.type = def.type;
-    inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
-    inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
-    inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
-    inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);
-    inst.check = (...checks) => {
-        return inst.clone({
+}, {
+    // `with` is an alias for `check`: the same function object, not a wrapper.
+    get with() {
+        return this.check;
+    },
+    set with(value) {
+        util.own(this, "with", value);
+    },
+    parse(data, params) {
+        return parse.parse(this, data, params, { callee: this.parse });
+    },
+    parseAsync(data, params) {
+        return parse.parseAsync(this, data, params, { callee: this.parseAsync });
+    },
+    safeParse(data, params) {
+        return parse.safeParse(this, data, params);
+    },
+    safeParseAsync(data, params) {
+        return parse.safeParseAsync(this, data, params);
+    },
+    check(...checks) {
+        const def = this.def;
+        return this.clone({
             ...def,
             checks: [
                 ...(def.checks ?? []),
-                ...checks.map((ch) => typeof ch === "function"
-                    ? {
-                        _zod: { check: ch, def: { check: "custom" }, onattach: [] },
-                    }
-                    : ch),
+                ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
             ],
         }, { parent: true });
-    };
-    inst.with = inst.check;
-    inst.clone = (_def, params) => core.clone(inst, _def, params);
-    inst.brand = () => inst;
-    inst.register = ((reg, meta) => {
-        reg.add(inst, meta);
-        return inst;
-    });
-    inst.apply = (fn) => fn(inst);
+    },
+    clone(_def, params) {
+        return core.clone(this, _def, params);
+    },
+    brand() {
+        return this;
+    },
+    register(reg, meta) {
+        reg.add(this, meta);
+        return this;
+    },
+    apply(fn, ...args) {
+        return args.length === 0 ? fn(this) : fn(this, ...args);
+    },
 });
 exports.ZodMiniString = core.$constructor("ZodMiniString", (inst, def) => {
     core.$ZodString.init(inst, def);
@@ -360,6 +380,14 @@ exports.ZodMiniE164 = core.$constructor("ZodMiniE164", (inst, def) => {
 function e164(params) {
     return core._e164(exports.ZodMiniE164, params);
 }
+exports.ZodMiniCreditCard = core.$constructor("ZodMiniCreditCard", (inst, def) => {
+    core.$ZodCreditCard.init(inst, def);
+    exports.ZodMiniStringFormat.init(inst, def);
+});
+// @__NO_SIDE_EFFECTS__
+function creditCard(params) {
+    return core._creditCard(exports.ZodMiniCreditCard, params);
+}
 exports.ZodMiniJWT = core.$constructor("ZodMiniJWT", (inst, def) => {
     core.$ZodJWT.init(inst, def);
     exports.ZodMiniStringFormat.init(inst, def);
@@ -406,28 +434,18 @@ exports.ZodMiniNumberFormat = core.$constructor("ZodMiniNumberFormat", (inst, de
     core.$ZodNumberFormat.init(inst, def);
     exports.ZodMiniNumber.init(inst, def);
 });
-// int
-// @__NO_SIDE_EFFECTS__
 function int(params) {
     return core._int(exports.ZodMiniNumberFormat, params);
 }
-// float32
-// @__NO_SIDE_EFFECTS__
 function float32(params) {
     return core._float32(exports.ZodMiniNumberFormat, params);
 }
-// float64
-// @__NO_SIDE_EFFECTS__
 function float64(params) {
     return core._float64(exports.ZodMiniNumberFormat, params);
 }
-// int32
-// @__NO_SIDE_EFFECTS__
 function int32(params) {
     return core._int32(exports.ZodMiniNumberFormat, params);
 }
-// uint32
-// @__NO_SIDE_EFFECTS__
 function uint32(params) {
     return core._uint32(exports.ZodMiniNumberFormat, params);
 }
@@ -451,13 +469,9 @@ exports.ZodMiniBigIntFormat = core.$constructor("ZodMiniBigIntFormat", (inst, de
     core.$ZodBigIntFormat.init(inst, def);
     exports.ZodMiniBigInt.init(inst, def);
 });
-// int64
-// @__NO_SIDE_EFFECTS__
 function int64(params) {
     return core._int64(exports.ZodMiniBigIntFormat, params);
 }
-// uint64
-// @__NO_SIDE_EFFECTS__
 function uint64(params) {
     return core._uint64(exports.ZodMiniBigIntFormat, params);
 }
@@ -546,7 +560,7 @@ function keyof(schema) {
 exports.ZodMiniObject = core.$constructor("ZodMiniObject", (inst, def) => {
     core.$ZodObject.init(inst, def);
     exports.ZodMiniType.init(inst, def);
-    util.defineLazy(inst, "shape", () => def.shape);
+    util.installLazyProp(inst, "shape", (self) => self._zod.def.shape, false);
 });
 // @__NO_SIDE_EFFECTS__
 function object(shape, params) {
@@ -586,9 +600,12 @@ function extend(schema, shape) {
 function safeExtend(schema, shape) {
     return util.safeExtend(schema, shape);
 }
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://zod.dev/api?id=extend) instead.
+ */
 // @__NO_SIDE_EFFECTS__
-function merge(schema, shape) {
-    return util.extend(schema, shape);
+function merge(a, b) {
+    return util.merge(a, b);
 }
 // @__NO_SIDE_EFFECTS__
 function pick(schema, mask) {
@@ -601,7 +618,20 @@ function omit(schema, mask) {
 }
 // @__NO_SIDE_EFFECTS__
 function partial(schema, mask) {
-    return util.partial(exports.ZodMiniOptional, schema, mask);
+    const def = schema._zod.def;
+    if (def.type !== "tuple")
+        return util.partial(exports.ZodMiniOptional, schema, mask);
+    // a refinement was authored against the full arity; partialing would run it on a shorter array
+    if (def.checks?.length)
+        throw new Error(".partial() cannot be used on tuple schemas containing refinements");
+    return util.clone(schema, {
+        ...def,
+        items: def.items.map((item) => new exports.ZodMiniOptional({ type: "optional", innerType: item })),
+    });
+}
+// @__NO_SIDE_EFFECTS__
+function exactPartial(schema, mask) {
+    return util.partial(exports.ZodMiniExactOptional, schema, mask, "exactPartial");
 }
 // @__NO_SIDE_EFFECTS__
 function required(schema, mask) {
@@ -646,7 +676,7 @@ exports.ZodMiniDiscriminatedUnion = core.$constructor("ZodMiniDiscriminatedUnion
 function discriminatedUnion(discriminator, options, params) {
     return new exports.ZodMiniDiscriminatedUnion({
         type: "union",
-        options,
+        options: options,
         discriminator,
         ...util.normalizeParams(params),
     });
@@ -703,13 +733,12 @@ function record(keyType, valueType, params) {
 }
 // @__NO_SIDE_EFFECTS__
 function partialRecord(keyType, valueType, params) {
-    const k = core.clone(keyType);
-    k._zod.values = undefined;
     return new exports.ZodMiniRecord({
         type: "record",
-        keyType: k,
+        keyType,
         valueType: valueType,
         ...util.normalizeParams(params),
+        partial: true,
     });
 }
 function looseRecord(keyType, valueType, params) {
@@ -904,7 +933,7 @@ function _catch(innerType, catchValue) {
     return new exports.ZodMiniCatch({
         type: "catch",
         innerType: innerType,
-        catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue),
+        catchValue: (typeof catchValue === "function" ? catchValue : core.util.constantCatch(catchValue)),
     });
 }
 exports.ZodMiniNaN = core.$constructor("ZodMiniNaN", (inst, def) => {
@@ -1014,8 +1043,7 @@ function check(fn, params) {
     ch._zod.check = fn;
     return ch;
 }
-// ZodCustom
-// custom schema
+// ZodCustom custom schema
 // @__NO_SIDE_EFFECTS__
 function custom(fn, _params) {
     return core._custom(exports.ZodMiniCustom, fn ?? (() => true), _params);

package/node_modules/zod/v4/mini/schemas.d.cts

@@ -1,4 +1,5 @@
 import * as core from "../core/index.cjs";
+import type { $ZodBigIntFormats } from "../core/index.cjs";
 import * as util from "../core/util.cjs";
 type SomeType = core.SomeType;
 export interface ZodMiniType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
@@ -15,7 +16,7 @@ export interface ZodMiniType<out Output = unknown, out Input = unknown, out Inte
     safeParse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): util.SafeParseResult<core.output<this>>;
     parseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<core.output<this>>;
     safeParseAsync(data: unknown, params?: core.ParseContext<core.$ZodIssue>): Promise<util.SafeParseResult<core.output<this>>>;
-    apply<T>(fn: (schema: this) => T): T;
+    apply<T, TArgs extends unknown[] = []>(fn: (schema: this, ...args: TArgs) => T, ...args: TArgs): T;
 }
 interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<any, any, Internals> {
 }
@@ -127,6 +128,10 @@ export interface ZodMiniE164 extends _ZodMiniString<core.$ZodE164Internals> {
 }
 export declare const ZodMiniE164: core.$constructor<ZodMiniE164>;
 export declare function e164(params?: string | core.$ZodE164Params): ZodMiniE164;
+export interface ZodMiniCreditCard extends _ZodMiniString<core.$ZodCreditCardInternals> {
+}
+export declare const ZodMiniCreditCard: core.$constructor<ZodMiniCreditCard>;
+export declare function creditCard(params?: string | core.$ZodCreditCardParams): ZodMiniCreditCard;
 export interface ZodMiniJWT extends _ZodMiniString<core.$ZodJWTInternals> {
 }
 export declare const ZodMiniJWT: core.$constructor<ZodMiniJWT>;
@@ -148,14 +153,24 @@ export interface ZodMiniNumber<Input = unknown> extends _ZodMiniNumber<core.$Zod
 }
 export declare const ZodMiniNumber: core.$constructor<ZodMiniNumber>;
 export declare function number(params?: string | core.$ZodNumberParams): ZodMiniNumber<number>;
-export interface ZodMiniNumberFormat extends _ZodMiniNumber<core.$ZodNumberFormatInternals>, core.$ZodNumberFormat {
+export interface ZodMiniNumberFormat<Format extends core.$ZodNumberFormats = core.$ZodNumberFormats> extends _ZodMiniNumber<core.$ZodNumberFormatInternals<Format>>, core.$ZodNumberFormat<Format> {
 }
 export declare const ZodMiniNumberFormat: core.$constructor<ZodMiniNumberFormat>;
-export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
-export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniNumberFormat;
+export interface ZodMiniInt extends ZodMiniNumberFormat<"safeint"> {
+}
+export declare function int(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt;
+export interface ZodMiniFloat32 extends ZodMiniNumberFormat<"float32"> {
+}
+export declare function float32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat32;
+export interface ZodMiniFloat64 extends ZodMiniNumberFormat<"float64"> {
+}
+export declare function float64(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniFloat64;
+export interface ZodMiniInt32 extends ZodMiniNumberFormat<"int32"> {
+}
+export declare function int32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniInt32;
+export interface ZodMiniUInt32 extends ZodMiniNumberFormat<"uint32"> {
+}
+export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodMiniUInt32;
 export interface ZodMiniBoolean<T = unknown> extends _ZodMiniType<core.$ZodBooleanInternals<T>> {
 }
 export declare const ZodMiniBoolean: core.$constructor<ZodMiniBoolean>;
@@ -164,11 +179,15 @@ export interface ZodMiniBigInt<T = unknown> extends _ZodMiniType<core.$ZodBigInt
 }
 export declare const ZodMiniBigInt: core.$constructor<ZodMiniBigInt>;
 export declare function bigint(params?: string | core.$ZodBigIntParams): ZodMiniBigInt<bigint>;
-export interface ZodMiniBigIntFormat extends _ZodMiniType<core.$ZodBigIntFormatInternals> {
+export interface ZodMiniBigIntFormat<Format extends $ZodBigIntFormats = $ZodBigIntFormats> extends _ZodMiniType<core.$ZodBigIntFormatInternals<Format>> {
 }
 export declare const ZodMiniBigIntFormat: core.$constructor<ZodMiniBigIntFormat>;
-export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
-export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniBigIntFormat;
+export interface ZodMiniInt64 extends ZodMiniBigIntFormat<"int64"> {
+}
+export declare function int64(params?: string | core.$ZodBigIntFormatParams): ZodMiniInt64;
+export interface ZodMiniUInt64 extends ZodMiniBigIntFormat<"uint64"> {
+}
+export declare function uint64(params?: string | core.$ZodBigIntFormatParams): ZodMiniUInt64;
 export interface ZodMiniSymbol extends _ZodMiniType<core.$ZodSymbolInternals> {
 }
 export declare const ZodMiniSymbol: core.$constructor<ZodMiniSymbol>;
@@ -223,8 +242,10 @@ export type SafeExtendShape<Base extends core.$ZodShape, Ext extends core.$ZodLo
     [K in keyof Ext]: K extends keyof Base ? core.output<Ext[K]> extends core.output<Base[K]> ? core.input<Ext[K]> extends core.input<Base[K]> ? Ext[K] : never : never : Ext[K];
 };
 export declare function safeExtend<T extends ZodMiniObject, U extends core.$ZodLooseShape>(schema: T, shape: SafeExtendShape<T["shape"], U>): ZodMiniObject<util.Extend<T["shape"], util.Writeable<U>>, T["_zod"]["config"]>;
-/** @deprecated Identical to `z.extend(A, B)` */
-export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, T["_zod"]["config"]>;
+/**
+ * @deprecated Use [`z.extend(A, B.shape)`](https://zod.dev/api?id=extend) instead.
+ */
+export declare function merge<T extends ZodMiniObject, U extends ZodMiniObject>(a: T, b: U): ZodMiniObject<util.Extend<T["shape"], U["shape"]>, U["_zod"]["config"]>;
 export declare function pick<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<util.Flatten<Pick<T["shape"], keyof T["shape"] & keyof M>>, T["_zod"]["config"]>;
 export declare function omit<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<util.Flatten<Omit<T["shape"], keyof M>>, T["_zod"]["config"]>;
 export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
@@ -233,6 +254,15 @@ export declare function partial<T extends ZodMiniObject>(schema: T): ZodMiniObje
 export declare function partial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<{
     -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniOptional<T["shape"][k]> : T["shape"][k];
 }, T["_zod"]["config"]>;
+export declare function partial<T extends util.TupleItems, Rest extends SomeType | null>(schema: ZodMiniTuple<T, Rest>): ZodMiniTuple<{
+    -readonly [k in keyof T]: ZodMiniOptional<T[k]>;
+}, Rest>;
+export declare function exactPartial<T extends ZodMiniObject>(schema: T): ZodMiniObject<{
+    -readonly [k in keyof T["shape"]]: ZodMiniExactOptional<T["shape"][k]>;
+}, T["_zod"]["config"]>;
+export declare function exactPartial<T extends ZodMiniObject, M extends util.Mask<keyof T["shape"]>>(schema: T, mask: M & Record<Exclude<keyof M, keyof T["shape"]>, never>): ZodMiniObject<{
+    -readonly [k in keyof T["shape"]]: k extends keyof M ? ZodMiniExactOptional<T["shape"][k]> : T["shape"][k];
+}, T["_zod"]["config"]>;
 export type RequiredInterfaceShape<Shape extends core.$ZodLooseShape, Keys extends PropertyKey = keyof Shape> = util.Identity<{
     [k in keyof Shape as k extends Keys ? k : never]: ZodMiniNonOptional<Shape[k]>;
 } & {
@@ -260,7 +290,7 @@ export interface ZodMiniDiscriminatedUnion<Options extends readonly SomeType[] =
     _zod: core.$ZodDiscriminatedUnionInternals<Options, Disc>;
 }
 export declare const ZodMiniDiscriminatedUnion: core.$constructor<ZodMiniDiscriminatedUnion>;
-export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable<Disc>, ...core.$ZodTypeDiscriminable<Disc>[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
+export declare function discriminatedUnion<Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]], Disc extends string>(discriminator: Disc, options: Types, params?: string | core.$ZodDiscriminatedUnionParams): ZodMiniDiscriminatedUnion<Types, Disc>;
 export interface ZodMiniIntersection<A extends SomeType = core.$ZodType, B extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodIntersectionInternals<A, B>> {
 }
 export declare const ZodMiniIntersection: core.$constructor<ZodMiniIntersection>;