zod 4.0.0-beta.20250430T185432 → 4.0.0-beta.20250503T014749

package/dist/commonjs/schemas.d.ts

@@ -248,7 +248,7 @@ export interface _ZodNumber<Input = unknown> extends ZodType {
     max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
     /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
     int(params?: string | core.$ZodCheckNumberFormatParams): this;
-    /** @deprecated This is now identical to `.int()` instead. Only numbers in the safe integer range are accepted. */
+    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
     safe(params?: string | core.$ZodCheckNumberFormatParams): this;
     positive(params?: string | core.$ZodCheckGreaterThanParams): this;
     nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
@@ -416,6 +416,7 @@ export interface ZodInterface<out Shape extends core.$ZodLooseShape = core.$ZodL
         defaulted: Params["defaulted"];
         extra: Record<string, T["_zod"]["output"]>;
     }>;
+    /** Consider `z.strictObject({ ...A.shape })` instead. */
     strict(): ZodInterface<Shape, {
         optional: Params["optional"];
         defaulted: Params["defaulted"];
@@ -426,6 +427,7 @@ export interface ZodInterface<out Shape extends core.$ZodLooseShape = core.$ZodL
         defaulted: Params["defaulted"];
         extra: Record<string, unknown>;
     }>;
+    /**  Use `z.looseObject({ ...A.shape })` instead. */
     strip(): ZodInterface<Shape, {
         optional: Params["optional"];
         defaulted: Params["defaulted"];
@@ -459,17 +461,19 @@ export interface ZodObject<out Shape extends core.$ZodShape = core.$ZodShape, Ex
     _zod: core.$ZodObjectInternals<Shape, Extra>;
     shape: Shape;
     keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
+    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
     catchall<T extends core.$ZodType>(schema: T): ZodObject<Shape, Record<string, T["_zod"]["output"]>>;
     /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
     passthrough(): ZodObject<Shape, Record<string, unknown>>;
+    /** Consider `z.looseObject(A.shape)` instead */
     loose(): ZodObject<Shape, Record<string, unknown>>;
-    /** The `z.strictObject()` API is preferred. */
+    /** Consider `z.strictObject(A.shape)` instead */
     strict(): ZodObject<Shape, {}>;
-    /** @deprecated This is the default behavior. This method call is likely unnecessary. */
+    /** This is the default behavior. This method call is likely unnecessary. */
     strip(): ZodObject<Shape, {}>;
     extend<const U extends ZodObject>(schema: U): ZodObject<util.Extend<Shape, U["_zod"]["def"]["shape"]>, Extra>;
     extend<U extends core.$ZodShape>(shape: U): ZodObject<util.Extend<Shape, U>, Extra>;
-    /** @deprecated Use `A.extend(B)` */
+    /** @deprecated Use `A.extend(B.shape)` */
     merge<U extends ZodObject<any, any>>(other: U): ZodObject<util.Flatten<util.Extend<Shape, U["_zod"]["def"]["shape"]>>, Extra>;
     pick<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Extra>;
     omit<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Extra>;

package/dist/esm/schemas.d.ts

@@ -248,7 +248,7 @@ export interface _ZodNumber<Input = unknown> extends ZodType {
     max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
     /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
     int(params?: string | core.$ZodCheckNumberFormatParams): this;
-    /** @deprecated This is now identical to `.int()` instead. Only numbers in the safe integer range are accepted. */
+    /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
     safe(params?: string | core.$ZodCheckNumberFormatParams): this;
     positive(params?: string | core.$ZodCheckGreaterThanParams): this;
     nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
@@ -416,6 +416,7 @@ export interface ZodInterface<out Shape extends core.$ZodLooseShape = core.$ZodL
         defaulted: Params["defaulted"];
         extra: Record<string, T["_zod"]["output"]>;
     }>;
+    /** Consider `z.strictObject({ ...A.shape })` instead. */
     strict(): ZodInterface<Shape, {
         optional: Params["optional"];
         defaulted: Params["defaulted"];
@@ -426,6 +427,7 @@ export interface ZodInterface<out Shape extends core.$ZodLooseShape = core.$ZodL
         defaulted: Params["defaulted"];
         extra: Record<string, unknown>;
     }>;
+    /**  Use `z.looseObject({ ...A.shape })` instead. */
     strip(): ZodInterface<Shape, {
         optional: Params["optional"];
         defaulted: Params["defaulted"];
@@ -459,17 +461,19 @@ export interface ZodObject<out Shape extends core.$ZodShape = core.$ZodShape, Ex
     _zod: core.$ZodObjectInternals<Shape, Extra>;
     shape: Shape;
     keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
+    /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
     catchall<T extends core.$ZodType>(schema: T): ZodObject<Shape, Record<string, T["_zod"]["output"]>>;
     /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
     passthrough(): ZodObject<Shape, Record<string, unknown>>;
+    /** Consider `z.looseObject(A.shape)` instead */
     loose(): ZodObject<Shape, Record<string, unknown>>;
-    /** The `z.strictObject()` API is preferred. */
+    /** Consider `z.strictObject(A.shape)` instead */
     strict(): ZodObject<Shape, {}>;
-    /** @deprecated This is the default behavior. This method call is likely unnecessary. */
+    /** This is the default behavior. This method call is likely unnecessary. */
     strip(): ZodObject<Shape, {}>;
     extend<const U extends ZodObject>(schema: U): ZodObject<util.Extend<Shape, U["_zod"]["def"]["shape"]>, Extra>;
     extend<U extends core.$ZodShape>(shape: U): ZodObject<util.Extend<Shape, U>, Extra>;
-    /** @deprecated Use `A.extend(B)` */
+    /** @deprecated Use `A.extend(B.shape)` */
     merge<U extends ZodObject<any, any>>(other: U): ZodObject<util.Flatten<util.Extend<Shape, U["_zod"]["def"]["shape"]>>, Extra>;
     pick<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Extra>;
     omit<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(mask: M): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Extra>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.0.0-beta.20250430T185432",
+  "version": "4.0.0-beta.20250503T014749",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
@@ -70,7 +70,7 @@
     }
   },
   "dependencies": {
-    "@zod/core": "0.10.0"
+    "@zod/core": "0.10.1"
   },
   "scripts": {
     "clean": "rm -rf dist",

package/src/schemas.ts

@@ -665,7 +665,7 @@ export interface _ZodNumber<Input = unknown> extends ZodType {
   max(value: number, params?: string | core.$ZodCheckLessThanParams): this;
   /** Consider `z.int()` instead. This API is considered *legacy*; it will never be removed but a better alternative exists. */
   int(params?: string | core.$ZodCheckNumberFormatParams): this;
-  /** @deprecated This is now identical to `.int()` instead. Only numbers in the safe integer range are accepted. */
+  /** @deprecated This is now identical to `.int()`. Only numbers in the safe integer range are accepted. */
   safe(params?: string | core.$ZodCheckNumberFormatParams): this;
   positive(params?: string | core.$ZodCheckGreaterThanParams): this;
   nonnegative(params?: string | core.$ZodCheckGreaterThanParams): this;
@@ -1089,6 +1089,7 @@ export interface ZodInterface<
       extra: Record<string, T["_zod"]["output"]>;
     }
   >;
+  /** Consider `z.strictObject({ ...A.shape })` instead. */
   strict(): ZodInterface<
     Shape,
     {
@@ -1097,6 +1098,7 @@ export interface ZodInterface<
       extra: {};
     }
   >;
+
   loose(): ZodInterface<
     Shape,
     {
@@ -1105,6 +1107,8 @@ export interface ZodInterface<
       extra: Record<string, unknown>;
     }
   >;
+
+  /**  Use `z.looseObject({ ...A.shape })` instead. */
   strip(): ZodInterface<
     Shape,
     {
@@ -1257,17 +1261,18 @@ export interface ZodObject<
   shape: Shape;
 
   keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
+  /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
   catchall<T extends core.$ZodType>(schema: T): ZodObject<Shape, Record<string, T["_zod"]["output"]>>;
 
   /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
   passthrough(): ZodObject<Shape, Record<string, unknown>>;
-
+  /** Consider `z.looseObject(A.shape)` instead */
   loose(): ZodObject<Shape, Record<string, unknown>>;
 
-  /** The `z.strictObject()` API is preferred. */
+  /** Consider `z.strictObject(A.shape)` instead */
   strict(): ZodObject<Shape, {}>;
 
-  /** @deprecated This is the default behavior. This method call is likely unnecessary. */
+  /** This is the default behavior. This method call is likely unnecessary. */
   strip(): ZodObject<Shape, {}>;
 
   extend<const U extends ZodObject>(schema: U): ZodObject<util.Extend<Shape, U["_zod"]["def"]["shape"]>, Extra>;
@@ -1279,7 +1284,7 @@ export interface ZodObject<
   >;
 
   // merge
-  /** @deprecated Use `A.extend(B)` */
+  /** @deprecated Use `A.extend(B.shape)` */
   merge<U extends ZodObject<any, any>>(
     other: U
   ): ZodObject<util.Flatten<util.Extend<Shape, U["_zod"]["def"]["shape"]>>, Extra>;