zod 3.26.0-canary.20250703T215303 → 3.26.0-canary.20250708T090717

package/v4/classic/schemas.js

@@ -935,10 +935,10 @@ export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def
     ZodType.init(inst, def);
 });
 // custom checks
-export function check(fn, params) {
+export function check(fn) {
     const ch = new core.$ZodCheck({
         check: "custom",
-        ...util.normalizeParams(params),
+        // ...util.normalizeParams(params),
     });
     ch._zod.check = fn;
     return ch;
@@ -950,7 +950,7 @@ export function refine(fn, _params = {}) {
     return core._refine(ZodCustom, fn, _params);
 }
 // superRefine
-export function superRefine(fn, params) {
+export function superRefine(fn) {
     const ch = check((payload) => {
         payload.addIssue = (issue) => {
             if (typeof issue === "string") {
@@ -969,7 +969,7 @@ export function superRefine(fn, params) {
             }
         };
         return fn(payload.value, payload);
-    }, params);
+    });
     return ch;
 }
 function _instanceof(cls, params = {

package/v4/core/checks.cjs

@@ -248,11 +248,12 @@ exports.$ZodCheckBigIntFormat = core.$constructor("$ZodCheckBigIntFormat", (inst
     };
 });
 exports.$ZodCheckMaxSize = core.$constructor("$ZodCheckMaxSize", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
         if (def.maximum < curr)
@@ -274,11 +275,12 @@ exports.$ZodCheckMaxSize = core.$constructor("$ZodCheckMaxSize", (inst, def) =>
     };
 });
 exports.$ZodCheckMinSize = core.$constructor("$ZodCheckMinSize", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
         if (def.minimum > curr)
@@ -300,11 +302,12 @@ exports.$ZodCheckMinSize = core.$constructor("$ZodCheckMinSize", (inst, def) =>
     };
 });
 exports.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const bag = inst._zod.bag;
         bag.minimum = def.size;
@@ -329,11 +332,12 @@ exports.$ZodCheckSizeEquals = core.$constructor("$ZodCheckSizeEquals", (inst, de
     };
 });
 exports.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
         if (def.maximum < curr)
@@ -357,11 +361,12 @@ exports.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def)
     };
 });
 exports.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
         if (def.minimum > curr)
@@ -385,11 +390,12 @@ exports.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def)
     };
 });
 exports.$ZodCheckLengthEquals = core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
+    var _a;
     exports.$ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const bag = inst._zod.bag;
         bag.minimum = def.length;

package/v4/core/checks.d.cts

@@ -7,6 +7,8 @@ export interface $ZodCheckDef {
     error?: errors.$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: schemas.ParsePayload) => boolean) | undefined;
 }
 export interface $ZodCheckInternals<T> {
     def: $ZodCheckDef;
@@ -14,7 +16,6 @@ export interface $ZodCheckInternals<T> {
     issc?: errors.$ZodIssueBase;
     check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
     onattach: ((schema: schemas.$ZodType) => void)[];
-    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
 }
 export interface $ZodCheck<in T = never> {
     _zod: $ZodCheckInternals<T>;

package/v4/core/checks.d.ts

@@ -7,6 +7,8 @@ export interface $ZodCheckDef {
     error?: errors.$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: schemas.ParsePayload) => boolean) | undefined;
 }
 export interface $ZodCheckInternals<T> {
     def: $ZodCheckDef;
@@ -14,7 +16,6 @@ export interface $ZodCheckInternals<T> {
     issc?: errors.$ZodIssueBase;
     check(payload: schemas.ParsePayload<T>): util.MaybeAsync<void>;
     onattach: ((schema: schemas.$ZodType) => void)[];
-    when?: ((payload: schemas.ParsePayload) => boolean) | undefined;
 }
 export interface $ZodCheck<in T = never> {
     _zod: $ZodCheckInternals<T>;

package/v4/core/checks.js

@@ -222,11 +222,12 @@ export const $ZodCheckBigIntFormat = /*@__PURE__*/ core.$constructor("$ZodCheckB
     };
 });
 export const $ZodCheckMaxSize = /*@__PURE__*/ core.$constructor("$ZodCheckMaxSize", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
         if (def.maximum < curr)
@@ -248,11 +249,12 @@ export const $ZodCheckMaxSize = /*@__PURE__*/ core.$constructor("$ZodCheckMaxSiz
     };
 });
 export const $ZodCheckMinSize = /*@__PURE__*/ core.$constructor("$ZodCheckMinSize", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
         if (def.minimum > curr)
@@ -274,11 +276,12 @@ export const $ZodCheckMinSize = /*@__PURE__*/ core.$constructor("$ZodCheckMinSiz
     };
 });
 export const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor("$ZodCheckSizeEquals", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.size !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const bag = inst._zod.bag;
         bag.minimum = def.size;
@@ -303,11 +306,12 @@ export const $ZodCheckSizeEquals = /*@__PURE__*/ core.$constructor("$ZodCheckSiz
     };
 });
 export const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor("$ZodCheckMaxLength", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY);
         if (def.maximum < curr)
@@ -331,11 +335,12 @@ export const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor("$ZodCheckMaxL
     };
 });
 export const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor("$ZodCheckMinLength", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const curr = (inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY);
         if (def.minimum > curr)
@@ -359,11 +364,12 @@ export const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor("$ZodCheckMinL
     };
 });
 export const $ZodCheckLengthEquals = /*@__PURE__*/ core.$constructor("$ZodCheckLengthEquals", (inst, def) => {
+    var _a;
     $ZodCheck.init(inst, def);
-    inst._zod.when = (payload) => {
+    (_a = inst._zod.def).when ?? (_a.when = (payload) => {
         const val = payload.value;
         return !util.nullish(val) && val.length !== undefined;
-    };
+    });
     inst._zod.onattach.push((inst) => {
         const bag = inst._zod.bag;
         bag.minimum = def.length;

package/v4/core/errors.cjs

@@ -48,6 +48,10 @@ const initializer = (inst, def) => {
         enumerable: true,
         // configurable: false,
     });
+    Object.defineProperty(inst, "toString", {
+        value: () => inst.message,
+        enumerable: false,
+    });
 };
 exports.$ZodError = (0, core_js_1.$constructor)("$ZodError", initializer);
 exports.$ZodRealError = (0, core_js_1.$constructor)("$ZodError", initializer, { Parent: Error });

package/v4/core/errors.js

@@ -17,6 +17,10 @@ const initializer = (inst, def) => {
         enumerable: true,
         // configurable: false,
     });
+    Object.defineProperty(inst, "toString", {
+        value: () => inst.message,
+        enumerable: false,
+    });
 };
 export const $ZodError = $constructor("$ZodError", initializer);
 export const $ZodRealError = $constructor("$ZodError", initializer, { Parent: Error });

package/v4/core/registries.cjs

@@ -6,7 +6,7 @@ exports.$output = Symbol("ZodOutput");
 exports.$input = Symbol("ZodInput");
 class $ZodRegistry {
     constructor() {
-        this._map = new WeakMap();
+        this._map = new Map();
         this._idmap = new Map();
     }
     add(schema, ..._meta) {
@@ -20,7 +20,16 @@ class $ZodRegistry {
         }
         return this;
     }
+    clear() {
+        this._map = new Map();
+        this._idmap = new Map();
+        return this;
+    }
     remove(schema) {
+        const meta = this._map.get(schema);
+        if (meta && typeof meta === "object" && "id" in meta) {
+            this._idmap.delete(meta.id);
+        }
         this._map.delete(schema);
         return this;
     }

package/v4/core/registries.d.cts

@@ -13,9 +13,10 @@ type MetadataType = Record<string, unknown> | undefined;
 export declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
     _meta: Meta;
     _schema: Schema;
-    _map: WeakMap<Schema, $replace<Meta, Schema>>;
+    _map: Map<Schema, $replace<Meta, Schema>>;
     _idmap: Map<string, Schema>;
     add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+    clear(): this;
     remove(schema: Schema): this;
     get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
     has(schema: Schema): boolean;

package/v4/core/registries.d.ts

@@ -13,9 +13,10 @@ type MetadataType = Record<string, unknown> | undefined;
 export declare class $ZodRegistry<Meta extends MetadataType = MetadataType, Schema extends $ZodType = $ZodType> {
     _meta: Meta;
     _schema: Schema;
-    _map: WeakMap<Schema, $replace<Meta, Schema>>;
+    _map: Map<Schema, $replace<Meta, Schema>>;
     _idmap: Map<string, Schema>;
     add<S extends Schema>(schema: S, ..._meta: undefined extends Meta ? [$replace<Meta, S>?] : [$replace<Meta, S>]): this;
+    clear(): this;
     remove(schema: Schema): this;
     get<S extends Schema>(schema: S): $replace<Meta, S> | undefined;
     has(schema: Schema): boolean;

package/v4/core/registries.js

@@ -2,7 +2,7 @@ export const $output = Symbol("ZodOutput");
 export const $input = Symbol("ZodInput");
 export class $ZodRegistry {
     constructor() {
-        this._map = new WeakMap();
+        this._map = new Map();
         this._idmap = new Map();
     }
     add(schema, ..._meta) {
@@ -16,7 +16,16 @@ export class $ZodRegistry {
         }
         return this;
     }
+    clear() {
+        this._map = new Map();
+        this._idmap = new Map();
+        return this;
+    }
     remove(schema) {
+        const meta = this._map.get(schema);
+        if (meta && typeof meta === "object" && "id" in meta) {
+            this._idmap.delete(meta.id);
+        }
         this._map.delete(schema);
         return this;
     }

package/v4/core/schemas.cjs

@@ -38,8 +38,6 @@ const versions_js_1 = require("./versions.cjs");
 exports.$ZodType = core.$constructor("$ZodType", (inst, def) => {
     var _a;
     inst ?? (inst = {});
-    // avoids issues with using Math.random() in Next.js caching
-    util.defineLazy(inst._zod, "id", () => def.type + "_" + util.randomString(10));
     inst._zod.def = def; // set _def property
     inst._zod.bag = inst._zod.bag || {}; // initialize _bag object
     inst._zod.version = versions_js_1.version;
@@ -67,8 +65,8 @@ exports.$ZodType = core.$constructor("$ZodType", (inst, def) => {
             let isAborted = util.aborted(payload);
             let asyncResult;
             for (const ch of checks) {
-                if (ch._zod.when) {
-                    const shouldRun = ch._zod.when(payload);
+                if (ch._zod.def.when) {
+                    const shouldRun = ch._zod.def.when(payload);
                     if (!shouldRun)
                         continue;
                 }
@@ -189,7 +187,9 @@ exports.$ZodURL = core.$constructor("$ZodURL", (inst, def) => {
     exports.$ZodStringFormat.init(inst, def);
     inst._zod.check = (payload) => {
         try {
-            const url = new URL(payload.value);
+            const orig = payload.value;
+            const url = new URL(orig);
+            const href = url.href;
             if (def.hostname) {
                 def.hostname.lastIndex = 0;
                 if (!def.hostname.test(url.hostname)) {
@@ -218,6 +218,13 @@ exports.$ZodURL = core.$constructor("$ZodURL", (inst, def) => {
                     });
                 }
             }
+            // payload.value = url.href;
+            if (!orig.endsWith("/") && href.endsWith("/")) {
+                payload.value = href.slice(0, -1);
+            }
+            else {
+                payload.value = href;
+            }
             return;
         }
         catch (_) {
@@ -751,8 +758,9 @@ exports.$ZodObject = core.$constructor("$ZodObject", (inst, def) => {
         };
         doc.write(`const input = payload.value;`);
         const ids = Object.create(null);
+        let counter = 0;
         for (const key of normalized.keys) {
-            ids[key] = util.randomString(15);
+            ids[key] = `key_${counter++}`;
         }
         // A: preserve key order {
         doc.write(`const newResult = {}`);
@@ -1626,6 +1634,7 @@ function handlePipeResult(left, def, ctx) {
 exports.$ZodReadonly = core.$constructor("$ZodReadonly", (inst, def) => {
     exports.$ZodType.init(inst, def);
     util.defineLazy(inst._zod, "propValues", () => def.innerType._zod.propValues);
+    util.defineLazy(inst._zod, "values", () => def.innerType._zod.values);
     util.defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
     util.defineLazy(inst._zod, "optout", () => def.innerType._zod.optout);
     inst._zod.parse = (payload, ctx) => {

package/v4/core/schemas.d.cts

@@ -32,7 +32,6 @@ export interface _$ZodTypeInternals {
     /** Schema definition. */
     def: $ZodTypeDef;
     /** @internal Randomly generated ID for this schema. */
-    id: string;
     /** @internal List of deferred initializers. */
     deferred: util.AnyFunc[] | undefined;
     /** @internal Parses input and runs all checks (refinements). */
@@ -516,11 +515,13 @@ export interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef
     type: "array";
     element: T;
 }
-export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>[], core.input<T>[]> {
+export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends _$ZodTypeInternals {
     def: $ZodArrayDef<T>;
     isst: errors.$ZodIssueInvalidType;
+    output: core.output<T>[];
+    input: core.input<T>[];
 }
-export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<core.output<T>[], core.input<T>[], $ZodArrayInternals<T>> {
+export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType<any, any, $ZodArrayInternals<T>> {
 }
 export declare const $ZodArray: core.$constructor<$ZodArray>;
 type OptionalOutSchema = {
@@ -533,12 +534,12 @@ type OptionalInSchema = {
         optin: "optional";
     };
 };
-export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? Record<string, unknown> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, core.output<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
     -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: T[k]["_zod"]["output"];
 } & {
     -readonly [k in keyof T as T[k] extends OptionalOutSchema ? k : never]?: T[k]["_zod"]["output"];
 } & Extra>;
-export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? Record<string, unknown> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+export type $InferObjectInput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? util.IsAny<T[keyof T]> extends true ? Record<string, unknown> : Record<string, core.input<T[keyof T]>> : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
     -readonly [k in keyof T as T[k] extends OptionalInSchema ? never : k]: T[k]["_zod"]["input"];
 } & {
     -readonly [k in keyof T as T[k] extends OptionalInSchema ? k : never]?: T[k]["_zod"]["input"];
@@ -600,14 +601,17 @@ export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $Zo
 }
 type IsOptionalIn<T extends SomeType> = T extends OptionalInSchema ? true : false;
 type IsOptionalOut<T extends SomeType> = T extends OptionalOutSchema ? true : false;
-export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeInternals<$InferUnionOutput<T[number]>, $InferUnionInput<T[number]>> {
+export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends _$ZodTypeInternals {
     def: $ZodUnionDef<T>;
     isst: errors.$ZodIssueInvalidUnion;
     pattern: T[number]["_zod"]["pattern"];
+    values: T[number]["_zod"]["values"];
+    output: $InferUnionOutput<T[number]>;
+    input: $InferUnionInput<T[number]>;
     optin: IsOptionalIn<T[number]> extends false ? "optional" | undefined : "optional";
     optout: IsOptionalOut<T[number]> extends false ? "optional" | undefined : "optional";
 }
-export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
+export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType<any, any, $ZodUnionInternals<T>> {
     _zod: $ZodUnionInternals<T>;
 }
 export declare const $ZodUnion: core.$constructor<$ZodUnion>;
@@ -631,6 +635,8 @@ export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right ext
 export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>> {
     def: $ZodIntersectionDef<A, B>;
     isst: never;
+    optin: A["_zod"]["optin"] | B["_zod"]["optin"];
+    optout: A["_zod"]["optout"] | B["_zod"]["optout"];
 }
 export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodIntersectionInternals<A, B>;
@@ -677,12 +683,17 @@ export interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value
     keyType: Key;
     valueType: Value;
 }
-export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : number extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : symbol extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
-export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : number extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : symbol extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : Partial<Record<core.input<Key>, core.input<Value>>> : Record<core.input<Key>, core.input<Value>>;
+export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
+export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = Key extends $partial ? Partial<Record<core.input<Key>, core.input<Value>>> : Record<core.input<Key>, core.input<Value>>;
 export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
     def: $ZodRecordDef<Key, Value>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
 }
+export type $partial = {
+    "~~partial": true;
+};
 export interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodRecordInternals<Key, Value>;
 }
@@ -695,6 +706,8 @@ export interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeT
 export interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<core.output<Key>, core.output<Value>>, Map<core.input<Key>, core.input<Value>>> {
     def: $ZodMapDef<Key, Value>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey | errors.$ZodIssueInvalidElement<unknown>;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
 }
 export interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodMapInternals<Key, Value>;
@@ -707,6 +720,8 @@ export interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
 export interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<core.output<T>>, Set<core.input<T>>> {
     def: $ZodSetDef<T>;
     isst: errors.$ZodIssueInvalidType;
+    optin?: "optional" | undefined;
+    optout?: "optional" | undefined;
 }
 export interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodSetInternals<T>;
@@ -819,6 +834,7 @@ export interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeD
 export interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
     def: $ZodDefaultDef<T>;
     optin: "optional";
+    optout?: "optional" | undefined;
     isst: never;
     values: T["_zod"]["values"];
 }
@@ -835,6 +851,7 @@ export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodType
 export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
     def: $ZodPrefaultDef<T>;
     optin: "optional";
+    optout?: "optional" | undefined;
     isst: never;
     values: T["_zod"]["values"];
 }
@@ -850,6 +867,8 @@ export interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends
     def: $ZodNonOptionalDef<T>;
     isst: errors.$ZodIssueInvalidType;
     values: T["_zod"]["values"];
+    optin: "optional" | undefined;
+    optout: "optional" | undefined;
 }
 export interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodNonOptionalInternals<T>;
@@ -862,6 +881,8 @@ export interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeD
 export interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, core.input<T>> {
     def: $ZodSuccessDef<T>;
     isst: never;
+    optin: T["_zod"]["optin"];
+    optout: "optional" | undefined;
 }
 export interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodSuccessInternals<T>;
@@ -928,6 +949,7 @@ export interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $Z
     optout: T["_zod"]["optout"];
     isst: never;
     propValues: T["_zod"]["propValues"];
+    values: T["_zod"]["values"];
 }
 export interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodReadonlyInternals<T>;