zod 4.6.1 → 4.6.3

package/src/v4/core/compile.ts

@@ -18,7 +18,7 @@ import {
   urlHostnameOk,
   urlProtocolOk,
 } from "./schemas.js";
-import type { $ZodProperties, $ZodPropertiesDef, ParseContextInternal, ParsePayload, SomeType } from "./schemas.js";
+import type { ParseContextInternal, ParsePayload, SomeType } from "./schemas.js";
 import * as util from "./util.js";
 
 /** @internal Sentinel the compiled fast path returns when validation fails. */
@@ -89,7 +89,7 @@ type SupportedCheck =
   | checks.$ZodCheckLengthEquals
   | checks.$ZodCheckStringFormat
   | checks.$ZodCheckProperty
-  | $ZodProperties
+  | checks.$ZodCheckProperties
   | checks.$ZodCheckMimeType
   | checks.$ZodCheckOverwrite
   | { _zod: { def: { check: "custom"; fn?: (value: unknown) => boolean }; check?: (payload: unknown) => unknown } };
@@ -455,7 +455,7 @@ function generateChecks(doc: Doc, ctx: CompileContext, schema: SomeType, accesso
         generatePropertyCheck(doc, ctx, def, currentAccessor);
         break;
       case "properties":
-        generatePropertiesChecks(doc, ctx, def, currentAccessor, false);
+        generatePropertiesChecks(doc, ctx, def, currentAccessor);
         break;
       case "overwrite": {
         // Overwrite transforms the value - create new variable for transformed result
@@ -616,20 +616,15 @@ function generateMimeTypeCheck(
 function generatePropertiesChecks(
   doc: Doc,
   ctx: CompileContext,
-  def: $ZodPropertiesDef,
-  accessor: string,
-  schemaRole: boolean
+  def: checks.$ZodCheckPropertiesDef,
+  accessor: string
 ): void {
-  // a custom `when` gates the assertion at runtime; inside a union a wrongly-run branch is absorbed as a branch failure rather than falling back, so refuse at codegen the way the check role does
+  // a custom `when` gates the assertion at runtime; inside a union a wrongly-run branch is absorbed as a branch failure rather than falling back, so refuse at codegen
   if (def.when) {
     throw new ZodCompileUnsupportedError(`check with a custom "when" condition`);
   }
-  // matches the runtime gate for whichever role this is: a schema rejects a primitive outright, a check only a nullish value
-  doc.write(
-    schemaRole
-      ? `if (${accessor} === null || (typeof ${accessor} !== "object" && typeof ${accessor} !== "function")) return INVALID;`
-      : `if (${accessor} == null) return INVALID;`
-  );
+  // matches the runtime gate: the base schema already typed the value, so only a nullish one is rejected
+  doc.write(`if (${accessor} == null) return INVALID;`);
   const shape = def.shape as Record<string | symbol, SomeType>;
   for (const key of Reflect.ownKeys(shape)) {
     // a symbol has no source literal, so it is hoisted as a constant
@@ -934,7 +929,6 @@ type SupportedSchemaType =
   | "lazy"
   | "pipe"
   | "custom"
-  | "properties"
   | "transform"
   | "catch";
 
@@ -1079,10 +1073,6 @@ function generateCheck(
     case "custom":
       typeAccessor = generateCustomCheck(doc, ctx, schema, accessor);
       break;
-    case "properties":
-      generatePropertiesChecks(doc, ctx, (schema as $ZodProperties)._zod.def, accessor, true);
-      typeAccessor = accessor;
-      break;
     case "transform":
       typeAccessor = generateTransformCheck(doc, ctx, schema, accessor);
       break;
@@ -1270,9 +1260,9 @@ function generateObjectCheck(
   }
   // else: strip mode (no catchall) - unknown keys ignored, only include known keys
 
-  // Shape keys in declared order, then unknown keys in for...in order. A middle-rung key is included iff present on the input, else iff its output is not undefined.
+  // defaulted required outputs keep their keys even when undefined
   const outputVar = newVar(ctx);
-  const hasConditionalKeys = allKeys.some((k) => mayOutputUndefined(propShape[k]!) || dropsWhenAbsent(propShape[k]!));
+  const hasConditionalKeys = allKeys.some((k) => mayOmitUndefined(propShape[k]!) || dropsWhenAbsent(propShape[k]!));
 
   // Assert mode: every declared key is validated above, so the output literal and the unknown-key copy are pure waste. A `never` catchall already emitted its rejection loop; a schema catchall still has to validate the values it would otherwise have stored.
   if (!buildsValue) {
@@ -1301,7 +1291,7 @@ function generateObjectCheck(
       const out = propOutputs.get(k);
       if (dropsWhenAbsent(propShape[k]!)) {
         doc.write(`if (${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
-      } else if (mayOutputUndefined(propShape[k]!)) {
+      } else if (mayOmitUndefined(propShape[k]!)) {
         doc.write(`if (${out} !== undefined || ${kx} in ${accessor}) ${outputVar}[${kx}] = ${out};`);
       } else {
         doc.write(`${outputVar}[${kx}] = ${out};`);
@@ -1464,9 +1454,11 @@ function dropsWhenAbsent(schema: SomeType): boolean {
   return schema._zod.optin === "optional" && schema._zod.optout === "optional";
 }
 
-// Whether a schema's success-path output can be `undefined`. Object output
-// assembly gives such props the runtime's value-or-presence inclusion rule;
-// everything else keeps the unconditional object-literal slot.
+function mayOmitUndefined(schema: SomeType): boolean {
+  return (schema._zod.optin !== "defaulted" || schema._zod.optout === "optional") && mayOutputUndefined(schema);
+}
+
+// whether a schema's success-path output can be undefined
 function mayOutputUndefined(schema: SomeType): boolean {
   const def = schema._zod.def as {
     type: string;

package/src/v4/core/json-schema-processors.ts

@@ -16,7 +16,6 @@ import {
   finalize,
   handleUnrepresentable,
   initializeContext,
-  isTransforming,
   processSchema,
 } from "./to-json-schema.js";
 import { BIGINT_FORMAT_RANGES, NUMBER_FORMAT_RANGES, assignProp, getEnumValues } from "./util.js";
@@ -481,54 +480,6 @@ export const objectProcessor: Processor<schemas.$ZodObject> = (schema, ctx, _jso
   }
 };
 
-// asserts named properties in place and passes everything else through, so no additionalProperties constraint is emitted
-export const propertiesProcessor: Processor<schemas.$ZodProperties> = (schema, ctx, _json, params) => {
-  const json = _json as JSONSchema.ObjectSchema;
-  const def = schema._zod.def;
-
-  // dropping a symbol key silently would emit a schema that asserts less than this one does
-  if (
-    Object.getOwnPropertySymbols(def.shape).length &&
-    handleUnrepresentable(schema, ctx, json, params, "Symbol keys cannot be represented in JSON Schema")
-  ) {
-    return;
-  }
-
-  // the parsed value is the input, so an output-mode emission would describe a transformed value this schema never returns
-  if (ctx.io === "output") {
-    for (const key in def.shape) {
-      if (
-        isTransforming(def.shape[key]!) &&
-        handleUnrepresentable(
-          schema,
-          ctx,
-          json,
-          params,
-          `z.properties() returns its input, so the output of a transforming schema at key "${key}" cannot be represented in JSON Schema`
-        )
-      ) {
-        return;
-      }
-    }
-  }
-
-  json.type = "object";
-  json.properties = {};
-  for (const key in def.shape) {
-    assignProp(
-      json.properties,
-      key,
-      processSchema(def.shape[key]!, ctx as any, {
-        ...params,
-        path: [...params.path, "properties", key],
-      })
-    );
-  }
-  // input-side optionality in both modes: the parsed value is the input, so a defaulted key that stays absent must not be required of the output either
-  const required = Object.keys(def.shape).filter((key) => inputOptin(def.shape[key]!) === undefined);
-  if (required.length > 0) json.required = required;
-};
-
 export const unionProcessor: Processor<schemas.$ZodUnion> = (schema, ctx, json, params) => {
   const def = schema._zod.def as schemas.$ZodUnionDef;
   // Exclusive unions (inclusive === false) use oneOf (exactly one match) instead of anyOf (one or more matches). This includes both z.xor() and discriminated unions
@@ -904,7 +855,6 @@ export const allProcessors: Record<string, Processor<any>> = {
   file: fileProcessor,
   success: successProcessor,
   custom: customProcessor,
-  properties: propertiesProcessor,
   function: functionProcessor,
   transform: transformProcessor,
   map: mapProcessor,

package/src/v4/core/memoizer.ts

@@ -28,9 +28,9 @@ type WithState = { [STATE]?: State };
 
 const NO_ISSUES: errors.$ZodRawIssue[] = [];
 
-// a value a cycle can close through; callables count, since z.properties asserts on one
+// a value a cycle can close through
 function isRef(value: unknown): value is object {
-  return value !== null && (typeof value === "object" || typeof value === "function");
+  return value !== null && typeof value === "object";
 }
 
 // Receivers prefix paths in place, so the cache and every hand-out need their own copies.
@@ -90,9 +90,6 @@ function isRecursive(inst: $ZodType, stack: Set<object>, resolve: boolean): Answ
       check(def.catchall);
       break;
     }
-    case "properties":
-      merge(shape(def.shape, false));
-      break;
     case "array":
       check(def.element);
       break;

package/src/v4/core/schemas.ts

@@ -96,8 +96,7 @@ export interface $ZodTypeDef {
     | "promise"
     | "lazy"
     | "function"
-    | "custom"
-    | "properties";
+    | "custom";
   error?: errors.$ZodErrorMap<never> | undefined;
   checks?: checks.$ZodCheck<never>[];
 }
@@ -1983,7 +1982,7 @@ function handlePropertyResult(
   }
 
   if (result.value === undefined) {
-    if (isPresent) {
+    if (isPresent || (optin === "defaulted" && !isOptionalOut)) {
       (final.value as any)[key] = undefined;
     }
   } else {
@@ -2314,16 +2313,16 @@ export const $ZodObjectJIT: core.$constructor<$ZodObject> = /*@__PURE__*/ core.$
           doc.write(`
         if (${id}.issues.length) {${prefixStr(id, k)}
         }
-        
-        if (${id}.value === undefined) {
-          if (${isPresent}) {
-            newResult[${k}] = undefined;
-          }
-        } else {
+      `);
+          if (optin === "defaulted") {
+            doc.write(`newResult[${k}] = ${id}.value;`);
+          } else {
+            doc.write(`
+        if (${id}.value !== undefined || ${isPresent}) {
           newResult[${k}] = ${id}.value;
         }
-
       `);
+          }
         }
       }
 
@@ -4077,7 +4076,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> {
+  extends $ZodTypeInternals<core.output<T>, core.input<T> | undefined> {
   def: $ZodPrefaultDef<T>;
   optin: "defaulted";
   optout?: "optional" | undefined;
@@ -5096,101 +5095,6 @@ function handleRefineResult(result: unknown, payload: ParsePayload, input: unkno
   }
 }
 
-////////////////////////////////////////
-////////////////////////////////////////
-//////////                    //////////
-//////////  $ZodProperties    //////////
-//////////                    //////////
-////////////////////////////////////////
-////////////////////////////////////////
-export interface $ZodPropertiesDef<Shape extends $ZodShape = $ZodShape> extends $ZodTypeDef, checks.$ZodCheckDef {
-  type: "properties";
-  check: "properties";
-  shape: Shape;
-}
-
-// both sides infer the INPUT type: the shape is asserted and its results discarded, so a default, catch or transform inside it would make an output-typed inference a lie. The check side widens a literal to its primitive, so spreading over a `string` property still type-checks (#6520).
-export interface $ZodPropertiesInternals<Shape extends $ZodShape = $ZodShape>
-  extends $ZodTypeInternals<$InferObjectInput<Shape, {}>, $InferObjectInput<Shape, {}>>,
-    checks.$ZodCheckInternals<{ -readonly [k in keyof Shape]: util.Widen<core.input<Shape[k]>> }> {
-  def: $ZodPropertiesDef<Shape>;
-  isst: errors.$ZodIssueInvalidType;
-  issc: errors.$ZodIssue;
-}
-
-export interface $ZodProperties<Shape extends $ZodShape = $ZodShape> extends $ZodType {
-  _zod: $ZodPropertiesInternals<Shape>;
-  // yields the schema itself, so pre-4.6 `.check(...z.properties(shape))` spread call sites keep working
-  [Symbol.iterator](): Iterator<this>;
-}
-
-// asserts in place: the child result's value is discarded, matching z.property(), because a nested object or array schema rebuilds its output even when nothing transformed
-function handlePropertiesResult(result: ParsePayload, payload: ParsePayload, key: string | symbol): void {
-  if (result.issues.length) {
-    payload.issues.push(...util.prefixIssues(key, result.issues));
-  }
-}
-
-export const $ZodProperties: core.$constructor<$ZodProperties> = /*@__PURE__*/ core.$constructor(
-  "$ZodProperties",
-  (inst, def) => {
-    // $ZodType.init prepends an instance that already carries the $ZodCheck trait to its own `checks`, which would run the shape a second time and cost the parse context. Initializing the check trait after it keeps the schema role in `parse`, where the context arrives.
-    $ZodType.init(inst, def);
-    checks.$ZodCheck.init(inst, def);
-
-    const memo = core.globalConfig.memoizer;
-    memo?.attach(inst);
-
-    // key and schema snapshotted together: reading one live and the other cached lets a later mutation of the caller's shape object pair a stale key with a missing schema
-    let entries!: [string | symbol, $ZodType][];
-    const runShape = (payload: ParsePayload, ctx: ParseContextInternal): util.MaybeAsync<void> => {
-      entries ??= Reflect.ownKeys(def.shape).map((key) => [key, (def.shape as any)[key] as $ZodType]);
-      const input = payload.value as any;
-      let proms: Promise<any>[] | undefined;
-      for (const [key, schema] of entries) {
-        const result = schema._zod.run({ value: input[key], issues: [] }, ctx);
-        if (result instanceof Promise) {
-          proms ??= [];
-          proms.push(result.then((result) => handlePropertiesResult(result, payload, key)));
-        } else {
-          handlePropertiesResult(result, payload, key);
-        }
-      }
-      if (proms) return Promise.all(proms).then(() => undefined);
-      return undefined;
-    };
-
-    inst._zod.parse = (payload, ctx) => {
-      const input = payload.value;
-      // as a schema this is the type gate, and it infers an object shape, so a primitive is a type error. A function passes: its properties read like any other object's, and z.instanceof allows one.
-      if (input === null || (typeof input !== "object" && typeof input !== "function")) {
-        payload.issues.push({ expected: "object", code: "invalid_type", input, inst });
-        return payload;
-      }
-      // both sides declare the shape's input type, so the assertion runs forward in either direction; encoding the children backward would reject the very type this schema claims to take
-      if (ctx.direction === "backward") ctx = { ...ctx, direction: "forward" };
-      // the input is its own output here, so it registers as its own memo entry: a cycle re-entering this node hits the bucket instead of recursing forever
-      if (memo) memo.alloc(inst, payload, input, ctx);
-      const result = runShape(payload, ctx);
-      return result instanceof Promise ? result.then(() => payload) : payload;
-    };
-
-    // as a check the base schema already typed the value, so this only asserts the properties — which read on a primitive too, matching z.property() on a string's length. It gets no context of its own, so a cycle through a spread schema is not tracked.
-    inst._zod.check = (payload) => {
-      if (payload.value == null) {
-        payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
-        return undefined;
-      }
-      return runShape(payload, {});
-    };
-  },
-  {
-    *[Symbol.iterator]() {
-      yield this;
-    },
-  }
-);
-
 export type $ZodTypes =
   | $ZodString
   | $ZodNumber
@@ -5223,7 +5127,6 @@ export type $ZodTypes =
   | $ZodPrefault
   | $ZodTemplateLiteral
   | $ZodCustom
-  | $ZodProperties
   | $ZodTransform
   | $ZodNonOptional
   | $ZodReadonly

package/src/v4/core/to-json-schema.ts

@@ -757,7 +757,7 @@ export function finalize<T extends schemas.$ZodType>(
   }
 }
 
-export function isTransforming(
+function isTransforming(
   _schema: schemas.$ZodType,
   _ctx?: {
     seen: Set<schemas.$ZodType>;

package/src/v4/core/util.ts

@@ -1125,10 +1125,6 @@ export function members(proto: object, table: object): void {
     // a method materializes bound on first read, which is what keeps a detached member working: `const opt = schema.optional; opt()`
     else defineBound(proto, key, desc.value);
   }
-  // for..in sees no symbol keys, so well-known members like Symbol.iterator install here
-  for (const sym of Object.getOwnPropertySymbols(table)) {
-    defineBound(proto, sym, (table as any)[sym]);
-  }
 }
 
 /** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */

package/src/v4/core/versions.ts

@@ -1,5 +1,5 @@
 export const version = {
   major: 4,
   minor: 6,
-  patch: 1 as number,
+  patch: 3 as number,
 } as const;

package/src/v4/core/visit.ts

@@ -158,17 +158,6 @@ export function visit(schema: schemas.SomeType, fnOrHandlers: VisitFn | VisitHan
         const { _cachedInner, ...rest } = def;
         return clone(s, { ...rest, getter: () => run(original()) });
       }
-      case "properties": {
-        const oldShape = def.shape as Record<string | symbol, AnyZod>;
-        let changed = false;
-        const newShape: Record<string | symbol, AnyZod> = {};
-        for (const k of Reflect.ownKeys(oldShape)) {
-          const mapped = run(oldShape[k]!);
-          if (mapped !== oldShape[k]) changed = true;
-          newShape[k] = mapped;
-        }
-        return changed ? clone(s, { ...def, shape: newShape }) : s;
-      }
       // A leaf by choice: `parts` are regex fragments, not data positions.
       case "template_literal":
       // Leaves.

package/src/v4/mini/checks.ts

@@ -23,6 +23,7 @@ export {
   _startsWith as startsWith,
   _endsWith as endsWith,
   _property as property,
+  _properties as properties,
   _mime as mime,
   _overwrite as overwrite,
   _normalize as normalize,

package/src/v4/mini/schemas.ts

@@ -1597,7 +1597,7 @@ export const ZodMiniPrefault: core.$constructor<ZodMiniPrefault> = /*@__PURE__*/
 // @__NO_SIDE_EFFECTS__
 export function prefault<T extends SomeType>(
   innerType: T,
-  defaultValue: util.NoUndefined<core.input<T>> | (() => util.NoUndefined<core.input<T>>)
+  defaultValue: core.input<T> | (() => core.input<T>)
 ): ZodMiniPrefault<T> {
   return new ZodMiniPrefault({
     type: "prefault",
@@ -1866,25 +1866,6 @@ export const ZodMiniCustom: core.$constructor<ZodMiniCustom> = /*@__PURE__*/ cor
   }
 );
 
-// ZodMiniProperties
-export interface ZodMiniProperties<Shape extends core.$ZodShape = core.$ZodShape>
-  extends _ZodMiniType<core.$ZodPropertiesInternals<Shape>>,
-    core.$ZodProperties<Shape> {}
-export const ZodMiniProperties: core.$constructor<ZodMiniProperties> = /*@__PURE__*/ core.$constructor(
-  "ZodMiniProperties",
-  (inst, def) => {
-    core.$ZodProperties.init(inst, def);
-    ZodMiniType.init(inst, def);
-  }
-);
-
-export function properties<Shape extends core.$ZodShape>(
-  shape: Shape,
-  params?: string | core.$ZodPropertiesParams
-): ZodMiniProperties<Shape> {
-  return core._properties(ZodMiniProperties, shape, params) as any;
-}
-
 // custom checks
 // @__NO_SIDE_EFFECTS__
 export function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O> {

package/src/v4/mini/tests/index.test.ts

@@ -165,6 +165,28 @@ test("z.iso.duration", () => {
   expect(z.safeParse(b, d2).success).toEqual(false);
 });
 
+test("z.prefault preserves undefined output", async () => {
+  const field = z.prefault(z.union([z.string(), z.undefined()]), () => undefined);
+  const schema = z.object({ a: field });
+  expectTypeOf<z.output<typeof field>>().toEqualTypeOf<string | undefined>();
+  expectTypeOf<z.output<typeof schema>>().toEqualTypeOf<{ a: string | undefined }>();
+  expect(z.parse(schema, {})).toStrictEqual({ a: undefined });
+  expect(z.parse(schema, { a: undefined })).toStrictEqual({ a: undefined });
+  expect(z.parse(schema, { a: "value" })).toStrictEqual({ a: "value" });
+  expect(z.safeParse(schema, { a: 123 }).success).toBe(false);
+  expect(await z.parseAsync(schema, {})).toStrictEqual({ a: undefined });
+  expect(z.parse(z.object({ a: z.prefault(z.optional(z.string()), undefined) }), {})).toStrictEqual({ a: undefined });
+  const transformed = z.prefault(
+    z.pipe(
+      z.string(),
+      z.transform(() => undefined)
+    ),
+    "fallback"
+  );
+  expectTypeOf<z.output<typeof transformed>>().toEqualTypeOf<undefined>();
+  expect(z.parse(z.object({ a: transformed }), {})).toStrictEqual({ a: undefined });
+});
+
 test("z.undefined", () => {
   const a = z.undefined();
   expect(z.parse(a, undefined)).toEqual(undefined);

package/v4/classic/checks.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.slugify = exports.toUpperCase = exports.toLowerCase = exports.trim = exports.normalize = exports.overwrite = exports.mime = exports.property = exports.endsWith = exports.startsWith = exports.includes = exports.uppercase = exports.lowercase = exports.regex = exports.length = exports.minLength = exports.maxLength = exports.size = exports.minSize = exports.maxSize = exports.multipleOf = exports.nonnegative = exports.nonpositive = exports.negative = exports.positive = exports.gte = exports.gt = exports.lte = exports.lt = void 0;
+exports.slugify = exports.toUpperCase = exports.toLowerCase = exports.trim = exports.normalize = exports.overwrite = exports.mime = exports.properties = exports.property = exports.endsWith = exports.startsWith = exports.includes = exports.uppercase = exports.lowercase = exports.regex = exports.length = exports.minLength = exports.maxLength = exports.size = exports.minSize = exports.maxSize = exports.multipleOf = exports.nonnegative = exports.nonpositive = exports.negative = exports.positive = exports.gte = exports.gt = exports.lte = exports.lt = void 0;
 var index_js_1 = require("../core/index.cjs");
 Object.defineProperty(exports, "lt", { enumerable: true, get: function () { return index_js_1._lt; } });
 Object.defineProperty(exports, "lte", { enumerable: true, get: function () { return index_js_1._lte; } });
@@ -24,6 +24,7 @@ Object.defineProperty(exports, "includes", { enumerable: true, get: function ()
 Object.defineProperty(exports, "startsWith", { enumerable: true, get: function () { return index_js_1._startsWith; } });
 Object.defineProperty(exports, "endsWith", { enumerable: true, get: function () { return index_js_1._endsWith; } });
 Object.defineProperty(exports, "property", { enumerable: true, get: function () { return index_js_1._property; } });
+Object.defineProperty(exports, "properties", { enumerable: true, get: function () { return index_js_1._properties; } });
 Object.defineProperty(exports, "mime", { enumerable: true, get: function () { return index_js_1._mime; } });
 Object.defineProperty(exports, "overwrite", { enumerable: true, get: function () { return index_js_1._overwrite; } });
 Object.defineProperty(exports, "normalize", { enumerable: true, get: function () { return index_js_1._normalize; } });

package/v4/classic/checks.d.cts

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.cjs";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _properties as properties, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.cjs";

package/v4/classic/checks.d.ts

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.js";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _properties as properties, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, type $RefinementCtx as RefinementCtx, } from "../core/index.js";

package/v4/classic/checks.js

@@ -1 +1 @@
-export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, } from "../core/index.js";
+export { _lt as lt, _lte as lte, _gt as gt, _gte as gte, _positive as positive, _negative as negative, _nonpositive as nonpositive, _nonnegative as nonnegative, _multipleOf as multipleOf, _maxSize as maxSize, _minSize as minSize, _size as size, _maxLength as maxLength, _minLength as minLength, _length as length, _regex as regex, _lowercase as lowercase, _uppercase as uppercase, _includes as includes, _startsWith as startsWith, _endsWith as endsWith, _property as property, _properties as properties, _mime as mime, _overwrite as overwrite, _normalize as normalize, _trim as trim, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, _slugify as slugify, } from "../core/index.js";

package/v4/classic/schemas.cjs

@@ -27,7 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodIntersection = exports.ZodDiscriminatedUnion = exports.ZodXor = exports.ZodUnion = exports.ZodObject = exports.ZodArray = exports.ZodDate = exports.ZodVoid = exports.ZodNever = exports.ZodUnknown = exports.ZodAny = exports.ZodNull = exports.ZodUndefined = exports.ZodSymbol = exports.ZodBigIntFormat = exports.ZodBigInt = exports.ZodBoolean = exports.ZodNumberFormat = exports.ZodNumber = exports.ZodCustomStringFormat = exports.ZodJWT = exports.ZodIBAN = exports.ZodCreditCard = exports.ZodE164 = exports.ZodBase64URL = exports.ZodBase64 = exports.ZodCIDRv6 = exports.ZodCIDRv4 = exports.ZodIPv6 = exports.ZodMAC = exports.ZodIPv4 = exports.ZodKSUID = exports.ZodXID = exports.ZodULID = exports.ZodCUID2 = exports.ZodCUID = exports.ZodNanoID = exports.ZodEmoji = exports.ZodURL = exports.ZodUUID = exports.ZodGUID = exports.ZodEmail = exports.ZodISODuration = exports.ZodISOTime = exports.ZodISODate = exports.ZodISODateTime = exports.ZodStringFormat = exports.ZodString = exports._ZodString = exports.ZodType = void 0;
-exports.stringbool = exports.ZodInstanceOf = exports.meta = exports.describe = exports.ZodProperties = exports.ZodCustom = exports.ZodFunction = exports.ZodPromise = exports.ZodLazy = exports.ZodTemplateLiteral = exports.ZodReadonly = exports.ZodPreprocess = exports.ZodCodec = exports.ZodPipe = exports.ZodNaN = exports.ZodCatch = exports.ZodSuccess = exports.ZodNonOptional = exports.ZodPrefault = exports.ZodDefault = exports.ZodNullable = exports.ZodExactOptional = exports.ZodOptional = exports.ZodTransform = exports.ZodFile = exports.ZodLiteral = exports.ZodEnum = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = void 0;
+exports.stringbool = exports.ZodInstanceOf = exports.meta = exports.describe = exports.ZodCustom = exports.ZodFunction = exports.ZodPromise = exports.ZodLazy = exports.ZodTemplateLiteral = exports.ZodReadonly = exports.ZodPreprocess = exports.ZodCodec = exports.ZodPipe = exports.ZodNaN = exports.ZodCatch = exports.ZodSuccess = exports.ZodNonOptional = exports.ZodPrefault = exports.ZodDefault = exports.ZodNullable = exports.ZodExactOptional = exports.ZodOptional = exports.ZodTransform = exports.ZodFile = exports.ZodLiteral = exports.ZodEnum = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = void 0;
 exports.string = string;
 exports.email = email;
 exports.guid = guid;
@@ -118,7 +118,6 @@ exports._function = _function;
 exports.function = _function;
 exports._function = _function;
 exports.function = _function;
-exports.properties = properties;
 exports.check = check;
 exports.custom = custom;
 exports.refine = refine;
@@ -1577,14 +1576,6 @@ exports.ZodCustom = core.$constructor("ZodCustom", (inst, def) => {
     exports.ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);
 });
-exports.ZodProperties = core.$constructor("ZodProperties", (inst, def) => {
-    _ensureDefaultMemoizer();
-    core.$ZodProperties.init(inst, def);
-    exports.ZodType.init(inst, def);
-});
-function properties(shape, params) {
-    return core._properties(exports.ZodProperties, shape, params);
-}
 // custom checks
 function check(fn) {
     const ch = new core.$ZodCheck({
@@ -1612,7 +1603,7 @@ exports.ZodInstanceOf = core.$constructor("ZodInstanceOf", (inst, def) => {
 }, {
     properties(shape, params) {
         // asserts in place, so the narrowed output type is truthful without a wrapper
-        return this.check(properties(shape, params));
+        return this.check(core._properties(shape, params));
     },
 });
 function _instanceof(cls, params = {}) {

package/v4/classic/schemas.d.cts

@@ -779,11 +779,6 @@ export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodC
     "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
-export interface ZodProperties<Shape extends core.$ZodShape = core.$ZodShape> extends _ZodType<core.$ZodPropertiesInternals<Shape>>, core.$ZodProperties<Shape> {
-    "~standard": ZodStandardSchemaWithJSON<this>;
-}
-export declare const ZodProperties: core.$constructor<ZodProperties>;
-export declare function properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodProperties<Shape>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
@@ -792,7 +787,7 @@ export declare const describe: typeof core.describe;
 export declare const meta: typeof core.meta;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
-    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodCheckPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
 }
 export declare const ZodInstanceOf: core.$constructor<ZodInstanceOf>;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;

package/v4/classic/schemas.d.ts

@@ -779,11 +779,6 @@ export interface ZodCustom<O = unknown, I = unknown> extends _ZodType<core.$ZodC
     "~standard": ZodStandardSchemaWithJSON<this>;
 }
 export declare const ZodCustom: core.$constructor<ZodCustom>;
-export interface ZodProperties<Shape extends core.$ZodShape = core.$ZodShape> extends _ZodType<core.$ZodPropertiesInternals<Shape>>, core.$ZodProperties<Shape> {
-    "~standard": ZodStandardSchemaWithJSON<this>;
-}
-export declare const ZodProperties: core.$constructor<ZodProperties>;
-export declare function properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodProperties<Shape>;
 export declare function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O>;
 export declare function custom<O>(fn?: (data: unknown) => unknown, _params?: string | core.$ZodCustomParams | undefined): ZodCustom<O, O>;
 export declare function refine<T>(fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>, _params?: string | core.$ZodCustomParams): core.$ZodCheck<T>;
@@ -792,7 +787,7 @@ export declare const describe: typeof core.describe;
 export declare const meta: typeof core.meta;
 type ZodInstanceOfParams = core.Params<ZodCustom, core.$ZodIssueCustom, "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path">;
 export interface ZodInstanceOf<T = unknown> extends ZodCustom<T, T> {
-    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
+    properties<Shape extends core.$ZodShape>(shape: Shape, params?: string | core.$ZodCheckPropertiesParams): ZodInstanceOf<T & core.$InferObjectInput<Shape, {}>>;
 }
 export declare const ZodInstanceOf: core.$constructor<ZodInstanceOf>;
 declare function _instanceof<T extends typeof util.Class>(cls: T, params?: ZodInstanceOfParams): ZodInstanceOf<InstanceType<T>>;

package/v4/classic/schemas.js

@@ -1455,14 +1455,6 @@ export const ZodCustom = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def
     ZodType.init(inst, def);
     inst._zod.processJSONSchema = (ctx, json, params) => processors.customProcessor(inst, ctx, json, params);
 });
-export const ZodProperties = /*@__PURE__*/ core.$constructor("ZodProperties", (inst, def) => {
-    _ensureDefaultMemoizer();
-    core.$ZodProperties.init(inst, def);
-    ZodType.init(inst, def);
-});
-export function properties(shape, params) {
-    return core._properties(ZodProperties, shape, params);
-}
 // custom checks
 export function check(fn) {
     const ch = new core.$ZodCheck({
@@ -1490,7 +1482,7 @@ export const ZodInstanceOf = /*@__PURE__*/ core.$constructor("ZodInstanceOf", (i
 }, {
     properties(shape, params) {
         // asserts in place, so the narrowed output type is truthful without a wrapper
-        return this.check(properties(shape, params));
+        return this.check(core._properties(shape, params));
     },
 });
 function _instanceof(cls, params = {}) {

package/v4/core/api.cjs

@@ -831,9 +831,8 @@ function _property(property, schema, params) {
     });
 }
 // @__NO_SIDE_EFFECTS__
-function _properties(Class, shape, params) {
-    return new Class({
-        type: "properties",
+function _properties(shape, params) {
+    return new checks.$ZodCheckProperties({
         check: "properties",
         shape,
         ...util.normalizeParams(params),