zod 3.25.50-beta.0 → 3.25.50

package/dist/cjs/v4/core/checks.js

@@ -347,6 +347,7 @@ exports.$ZodCheckMaxLength = core.$constructor("$ZodCheckMaxLength", (inst, def)
             origin,
             code: "too_big",
             maximum: def.maximum,
+            inclusive: true,
             input,
             inst,
             continue: !def.abort,
@@ -374,6 +375,7 @@ exports.$ZodCheckMinLength = core.$constructor("$ZodCheckMinLength", (inst, def)
             origin,
             code: "too_small",
             minimum: def.minimum,
+            inclusive: true,
             input,
             inst,
             continue: !def.abort,

package/dist/cjs/v4/core/core.js

@@ -15,7 +15,8 @@ function $constructor(name, initializer, params) {
         initializer(inst, def);
         // support prototype modifications
         for (const k in _.prototype) {
-            Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+            if (!(k in inst))
+                Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
         }
         inst._zod.constr = _;
         inst._zod.def = def;

package/dist/cjs/v4/mini/schemas.js

@@ -447,9 +447,6 @@ function strictObject(shape, params) {
             core_1.util.assignProp(this, "shape", { ...shape });
             return this.shape;
         },
-        // get optional() {
-        //   return util.optionalKeys(shape);
-        // },
         catchall: never(),
         ...core_1.util.normalizeParams(params),
     });

package/dist/esm/v4/core/checks.js

@@ -321,6 +321,7 @@ export const $ZodCheckMaxLength = /*@__PURE__*/ core.$constructor("$ZodCheckMaxL
             origin,
             code: "too_big",
             maximum: def.maximum,
+            inclusive: true,
             input,
             inst,
             continue: !def.abort,
@@ -348,6 +349,7 @@ export const $ZodCheckMinLength = /*@__PURE__*/ core.$constructor("$ZodCheckMinL
             origin,
             code: "too_small",
             minimum: def.minimum,
+            inclusive: true,
             input,
             inst,
             continue: !def.abort,

package/dist/esm/v4/core/core.js

@@ -10,7 +10,8 @@ export /*@__NO_SIDE_EFFECTS__*/ function $constructor(name, initializer, params)
         initializer(inst, def);
         // support prototype modifications
         for (const k in _.prototype) {
-            Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
+            if (!(k in inst))
+                Object.defineProperty(inst, k, { value: _.prototype[k].bind(inst) });
         }
         inst._zod.constr = _;
         inst._zod.def = def;

package/dist/esm/v4/mini/schemas.js

@@ -339,9 +339,6 @@ export function strictObject(shape, params) {
             util.assignProp(this, "shape", { ...shape });
             return this.shape;
         },
-        // get optional() {
-        //   return util.optionalKeys(shape);
-        // },
         catchall: never(),
         ...util.normalizeParams(params),
     });

package/dist/types/v4/classic/coerce.d.ts

@@ -6,12 +6,12 @@ export declare function string<T = unknown>(params?: string | core.$ZodStringPar
 export interface ZodCoercedNumber<T = unknown> extends schemas._ZodNumber<core.$ZodNumberInternals<T>> {
 }
 export declare function number<T = unknown>(params?: string | core.$ZodNumberParams): ZodCoercedNumber<T>;
-export interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<T> {
+export interface ZodCoercedBoolean<T = unknown> extends schemas._ZodBoolean<core.$ZodBooleanInternals<T>> {
 }
 export declare function boolean<T = unknown>(params?: string | core.$ZodBooleanParams): ZodCoercedBoolean<T>;
-export interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<T> {
+export interface ZodCoercedBigInt<T = unknown> extends schemas._ZodBigInt<core.$ZodBigIntInternals<T>> {
 }
 export declare function bigint<T = unknown>(params?: string | core.$ZodBigIntParams): ZodCoercedBigInt<T>;
-export interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<T> {
+export interface ZodCoercedDate<T = unknown> extends schemas._ZodDate<core.$ZodDateInternals<T>> {
 }
 export declare function date<T = unknown>(params?: string | core.$ZodDateParams): ZodCoercedDate<T>;

package/dist/types/v4/classic/schemas.d.ts

@@ -4,10 +4,9 @@ import * as parse from "./parse.js";
 export interface RefinementCtx<T = unknown> extends core.ParsePayload<T> {
     addIssue(arg: string | core.$ZodRawIssue | Partial<core.$ZodIssueCustom>): void;
 }
-export interface __ZodType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends core._$ZodType<Internals> {
+export interface ZodType<out Output = unknown, out Input = unknown, out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> extends core.$ZodType<Output, Input, Internals> {
     def: Internals["def"];
     type: Internals["def"]["type"];
-    "~standard": core.$ZodStandardSchema<this>;
     /** @deprecated Use `.def` instead. */
     _def: Internals["def"];
     /** @deprecated Use `z.output<typeof schema>` instead. */
@@ -70,13 +69,10 @@ export interface __ZodType<out Internals extends core.$ZodTypeInternals = core.$
      */
     isNullable(): boolean;
 }
-export interface _ZodType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends __ZodType<Internals>, core.$ZodType<Internals["output"], Internals["input"]> {
-    _zod: Internals;
-}
-export interface ZodType<out Output = unknown, out Input = unknown> extends _ZodType<core.$ZodTypeInternals<Output, Input>> {
+export interface _ZodType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodType<any, any, Internals> {
 }
 export declare const ZodType: core.$constructor<ZodType>;
-export interface _ZodString<Internals extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>> extends _ZodType<Internals> {
+export interface _ZodString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>> extends _ZodType<T> {
     format: string | null;
     minLength: number | null;
     maxLength: number | null;
@@ -309,13 +305,13 @@ export declare function int32(params?: string | core.$ZodCheckNumberFormatParams
 export interface ZodUInt32 extends ZodNumberFormat {
 }
 export declare function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodUInt32;
-export interface _ZodBoolean<T = unknown> extends _ZodType<core.$ZodBooleanInternals<T>> {
+export interface _ZodBoolean<T extends core.$ZodBooleanInternals = core.$ZodBooleanInternals> extends _ZodType<T> {
 }
-export interface ZodBoolean extends _ZodBoolean<boolean> {
+export interface ZodBoolean extends _ZodBoolean<core.$ZodBooleanInternals<boolean>> {
 }
 export declare const ZodBoolean: core.$constructor<ZodBoolean>;
 export declare function boolean(params?: string | core.$ZodBooleanParams): ZodBoolean;
-export interface _ZodBigInt<T = unknown> extends _ZodType<core.$ZodBigIntInternals<T>> {
+export interface _ZodBigInt<T extends core.$ZodBigIntInternals = core.$ZodBigIntInternals> extends _ZodType<T> {
     gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
     /** Alias of `.gte()` */
     min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
@@ -333,7 +329,7 @@ export interface _ZodBigInt<T = unknown> extends _ZodType<core.$ZodBigIntInterna
     maxValue: bigint | null;
     format: string | null;
 }
-export interface ZodBigInt extends _ZodBigInt<bigint> {
+export interface ZodBigInt extends _ZodBigInt<core.$ZodBigIntInternals<bigint>> {
 }
 export declare const ZodBigInt: core.$constructor<ZodBigInt>;
 export declare function bigint(params?: string | core.$ZodBigIntParams): ZodBigInt;
@@ -374,7 +370,7 @@ export interface ZodVoid extends _ZodType<core.$ZodVoidInternals> {
 export declare const ZodVoid: core.$constructor<ZodVoid>;
 declare function _void(params?: string | core.$ZodVoidParams): ZodVoid;
 export { _void as void };
-export interface _ZodDate<T = unknown> extends _ZodType<core.$ZodDateInternals<T>> {
+export interface _ZodDate<T extends core.$ZodDateInternals = core.$ZodDateInternals> extends _ZodType<T> {
     min(value: number | Date, params?: string | core.$ZodCheckGreaterThanParams): this;
     max(value: number | Date, params?: string | core.$ZodCheckLessThanParams): this;
     /** @deprecated Not recommended. */
@@ -382,11 +378,11 @@ export interface _ZodDate<T = unknown> extends _ZodType<core.$ZodDateInternals<T
     /** @deprecated Not recommended. */
     maxDate: Date | null;
 }
-export interface ZodDate extends _ZodDate<Date> {
+export interface ZodDate extends _ZodDate<core.$ZodDateInternals<Date>> {
 }
 export declare const ZodDate: core.$constructor<ZodDate>;
 export declare function date(params?: string | core.$ZodDateParams): ZodDate;
-export interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodArrayInternals<T>> {
+export interface ZodArray<T extends core.SomeType = core.$ZodType> extends ZodType<any, any, core.$ZodArrayInternals<T>>, core.$ZodArray<T> {
     element: T;
     min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
     nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
@@ -395,12 +391,11 @@ export interface ZodArray<T extends core.SomeType = core.$ZodType> extends _ZodT
     unwrap(): T;
 }
 export declare const ZodArray: core.$constructor<ZodArray>;
-export declare function array<T extends core._$ZodType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
+export declare function array<T extends core.SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
 export declare function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["output"]>;
 export interface ZodObject<
 /** @ts-ignore Cast variance */
-out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends __ZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
-    _zod: core.$ZodObjectInternals<Shape, Config>;
+out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends _ZodType<core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
     shape: Shape;
     keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
     /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
@@ -444,7 +439,7 @@ out Shape extends core.$ZodShape = core.$ZodLooseShape, out Config extends core.
     }, Config>;
 }
 export declare const ZodObject: core.$constructor<ZodObject>;
-export declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<util.Writeable<T> & {}, core.$strip>;
+export declare function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(shape?: T, params?: string | core.$ZodObjectParams): ZodObject<util.Writeable<T>, core.$strip>;
 export declare function strictObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$strict>;
 export declare function looseObject<T extends core.$ZodLooseShape>(shape: T, params?: string | core.$ZodObjectParams): ZodObject<T, core.$loose>;
 export interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$ZodType[]> extends _ZodType<core.$ZodUnionInternals<T>>, core.$ZodUnion<T> {
@@ -452,7 +447,7 @@ export interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$Zo
 }
 export declare const ZodUnion: core.$constructor<ZodUnion>;
 export declare function union<const T extends readonly core.SomeType[]>(options: T, params?: string | core.$ZodUnionParams): ZodUnion<T>;
-export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[]> extends ZodUnion<Options> {
+export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[]> extends ZodUnion<Options>, core.$ZodDiscriminatedUnion<Options> {
     _zod: core.$ZodDiscriminatedUnionInternals<Options>;
 }
 export declare const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion>;
@@ -481,7 +476,7 @@ export interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends
 }
 export declare const ZodMap: core.$constructor<ZodMap>;
 export declare function map<Key extends core.SomeType, Value extends core.SomeType>(keyType: Key, valueType: Value, params?: string | core.$ZodMapParams): ZodMap<Key, Value>;
-export interface ZodSet<T extends core.SomeType = core.$ZodType> extends _ZodType<core.$ZodSetInternals<T>>, core.$ZodSet<T> {
+export interface ZodSet<T extends core.SomeType = core.$ZodType> extends ZodType<any, any, core.$ZodSetInternals<T>>, core.$ZodSet<T> {
     min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
     /** */
     nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
@@ -490,7 +485,7 @@ export interface ZodSet<T extends core.SomeType = core.$ZodType> extends _ZodTyp
 }
 export declare const ZodSet: core.$constructor<ZodSet>;
 export declare function set<Value extends core.SomeType>(valueType: Value, params?: string | core.$ZodSetParams): ZodSet<Value>;
-export interface ZodEnum<T extends util.EnumLike = util.EnumLike> extends _ZodType<core.$ZodEnumInternals<T>>, core.$ZodEnum<T> {
+export interface ZodEnum<out T extends util.EnumLike = util.EnumLike> extends _ZodType<core.$ZodEnumInternals<T>>, core.$ZodEnum<T> {
     enum: T;
     options: Array<T[keyof T]>;
     extract<const U extends readonly (keyof T)[]>(values: U, params?: string | core.$ZodEnumParams): ZodEnum<util.Flatten<Pick<T, U[number]>>>;

package/dist/types/v4/core/schemas.d.ts

@@ -82,8 +82,7 @@ export interface _$ZodType<T extends _$ZodTypeInternals = _$ZodTypeInternals> {
     _zod: T;
 }
 export type SomeType = _$ZodType;
-export interface $ZodType<O = unknown, I = unknown> extends _$ZodType {
-    _zod: $ZodTypeInternals<O, I>;
+export interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> extends _$ZodType<Internals> {
     "~standard": $ZodStandardSchema<this>;
 }
 export declare const $ZodType: core.$constructor<$ZodType>;
@@ -585,8 +584,7 @@ export type $catchall<T extends _$ZodType> = {
 };
 export interface $ZodObject<
 /** @ts-ignore Cast variance */
-out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodType {
-    _zod: $ZodObjectInternals<Shape, Params>;
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
     "~standard": $ZodStandardSchema<this>;
 }
 export declare const $ZodObject: core.$constructor<$ZodObject>;

package/dist/types/v4/mini/schemas.d.ts

@@ -1,22 +1,23 @@
 import * as core from "zod/v4/core";
 import { util } from "zod/v4/core";
 type SomeType = core.SomeType;
-export interface ZodMiniType<out Output = unknown, out Input = unknown> extends core.$ZodType<Output, Input> {
+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> {
     check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
-    clone(def?: this["_zod"]["def"], params?: {
+    clone(def?: Internals["def"], params?: {
         parent: boolean;
     }): this;
     register<R extends core.$ZodRegistry>(registry: R, ...meta: this extends R["_schema"] ? undefined extends R["_meta"] ? [core.$replace<R["_meta"], this>?] : [core.$replace<R["_meta"], this>] : ["Incompatible schema"]): this;
     brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : this & Record<"_zod", Record<"output", core.output<this> & core.$brand<T>>>;
-    def: this["_zod"]["def"];
+    def: Internals["def"];
     parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
     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>>>;
 }
+interface _ZodMiniType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals> extends ZodMiniType<Internals["output"], Internals["input"], Internals> {
+}
 export declare const ZodMiniType: core.$constructor<ZodMiniType>;
-export interface ZodMiniString<Input = unknown> extends ZodMiniType {
-    _zod: core.$ZodStringInternals<Input>;
+export interface ZodMiniString<Input = unknown> extends _ZodMiniType<core.$ZodStringInternals<Input>>, core.$ZodString<Input> {
 }
 export declare const ZodMiniString: core.$constructor<ZodMiniString>;
 export declare function string(params?: string | core.$ZodStringParams): ZodMiniString<string>;
@@ -195,16 +196,14 @@ export interface ZodMiniDate<T = unknown> extends ZodMiniType {
 }
 export declare const ZodMiniDate: core.$constructor<ZodMiniDate>;
 export declare function date(params?: string | core.$ZodDateParams): ZodMiniDate<Date>;
-export interface ZodMiniArray<T extends SomeType = core.$ZodType> extends ZodMiniType {
-    _zod: core.$ZodArrayInternals<T>;
+export interface ZodMiniArray<T extends SomeType = core.$ZodType> extends _ZodMiniType<core.$ZodArrayInternals<T>>, core.$ZodArray<T> {
 }
 export declare const ZodMiniArray: core.$constructor<ZodMiniArray>;
 export declare function array<T extends SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodMiniArray<T>;
 export declare function keyof<T extends ZodMiniObject>(schema: T): ZodMiniLiteral<keyof T["shape"]>;
 export interface ZodMiniObject<
 /** @ts-ignore Cast variance */
-out Shape extends core.$ZodShape = core.$ZodShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends ZodMiniType {
-    _zod: core.$ZodObjectInternals<Shape, Config>;
+out Shape extends core.$ZodShape = core.$ZodShape, out Config extends core.$ZodObjectConfig = core.$ZodObjectConfig> extends ZodMiniType<any, any, core.$ZodObjectInternals<Shape, Config>>, core.$ZodObject<Shape, Config> {
     shape: Shape;
 }
 export declare const ZodMiniObject: core.$constructor<ZodMiniObject>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.25.50-beta.0",
+  "version": "3.25.50",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",