@psnext/slingcli 3.0.20260820-2 → 3.1.20260904-1

package/node_modules/zod/src/v4/mini/tests/error.test.ts

@@ -11,12 +11,31 @@ test("no locale by default", () => {
 test("error inheritance", () => {
   const e1 = z.string().safeParse(123).error!;
   expect(e1).toBeInstanceOf(z.core.$ZodError);
-  // expect(e1).not.toBeInstanceOf(Error);
+  expect(e1).toBeInstanceOf(Error);
 
+  let e2: unknown;
   try {
     z.string().parse(123);
-  } catch (e2) {
-    expect(e2).toBeInstanceOf(z.core.$ZodRealError);
-    expect(e2).toBeInstanceOf(Error);
+  } catch (err) {
+    e2 = err;
   }
+  expect(e2).toBeInstanceOf(z.core.$ZodRealError);
+  expect(e2).toBeInstanceOf(Error);
+});
+
+test("a thrown error carries a stack rooted at the parse call site", () => {
+  function callSite() {
+    z.parse(z.string(), 123);
+  }
+
+  let thrown: unknown;
+  try {
+    callSite();
+  } catch (err) {
+    thrown = err;
+  }
+  expect(thrown).toBeInstanceOf(Error);
+  const stack = (thrown as Error).stack!;
+  expect(stack.startsWith("$ZodError: [")).toBe(true);
+  expect(stack).toContain("callSite");
 });

package/node_modules/zod/src/v4/mini/tests/functions.test.ts

@@ -1,5 +1,14 @@
 import { expect, test } from "vitest";
+import * as z from "zod/mini";
 
 test("z.function", () => {
   expect(true).toEqual(true);
 });
+
+test("implement exposes the function schema at runtime", () => {
+  const schema = z.function({ input: [z.string()], output: z.number() });
+  const fn = schema.implement((s) => s.length);
+
+  expect((fn as any)._zod).toBe(schema._zod);
+  expect(fn("asdf")).toBe(4);
+});

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

@@ -247,9 +247,42 @@ test("z.union([]) / z.xor([]) / z.discriminatedUnion(_, []) construct and reject
   }
 });
 
-test("z.discriminatedUnion rejects object options missing the discriminator at type level", () => {
-  // @ts-expect-error missing discriminator property
-  z.discriminatedUnion("type", [z.object({ value: z.string() })]);
+test("z.discriminatedUnion rejects object options missing the discriminator", () => {
+  expect(() => z.discriminatedUnion("type", [z.object({ value: z.string() })])).toThrow(
+    /Invalid discriminated union option at index "0"/
+  );
+
+  // An option whose shape cannot be listed without resolving it is left to the lookup map, on the first object parsed.
+  const viaPipe = z.discriminatedUnion("type", [
+    z.pipe(z.object({ value: z.literal("x") }), z.object({ value: z.literal("x") })),
+  ]);
+  expect(() => z.safeParse(viaPipe, { value: "x" })).toThrow(/Invalid discriminated union option at index "0"/);
+});
+
+test("z.discriminatedUnion infers mutually-recursive getter options", () => {
+  const variantA = z.object({
+    kind: z.literal("a"),
+    get child() {
+      return z.optional(tree);
+    },
+  });
+
+  const variantB = z.object({
+    kind: z.literal("b"),
+    get sibling() {
+      return z.optional(tree);
+    },
+  });
+
+  const tree = z.discriminatedUnion("kind", [variantA, variantB]);
+
+  type _Tree = { kind: "a"; child?: _Tree | undefined } | { kind: "b"; sibling?: _Tree | undefined };
+
+  expectTypeOf<z.input<typeof tree>>().toEqualTypeOf<_Tree>();
+  expectTypeOf<z.input<typeof tree>>().not.toBeAny();
+
+  expect(z.parse(tree, { kind: "a", child: { kind: "b" } })).toEqual({ kind: "a", child: { kind: "b" } });
+  expect(() => z.parse(tree, { kind: "c" })).toThrow();
 });
 
 test("z.intersection", () => {
@@ -344,6 +377,15 @@ test("z.record", () => {
     [Enum.B]: "world",
   });
 
+  const partial = z.partialRecord(z.enum(["__proto__", "b"]), z.string());
+  type partial = z.output<typeof partial>;
+  expectTypeOf<partial>().toEqualTypeOf<Partial<Record<"__proto__" | "b", string>>>();
+  const parsed: any = z.parse(partial, Object.fromEntries([["__proto__", "declared"]]));
+  expect(Object.getPrototypeOf(parsed)).toBe(Object.prototype);
+  expect(Object.prototype.hasOwnProperty.call(parsed, "__proto__")).toBe(false);
+  expect(parsed).toEqual({});
+  expect(z.parse(partial, {})).toEqual({});
+
   // v3-compat single-arg form: z.record(valueType) defaults keyType to z.string()
   const f = (z.record as any)(z.number());
   expect(f._zod.def.keyType._zod.def.type).toEqual("string");
@@ -679,8 +721,7 @@ test("z.custom", () => {
 });
 
 test("z.check", () => {
-  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic
-  // the function should return core.$ZodResult
+  // this is a more flexible version of z.custom that accepts an arbitrary _parse logic the function should return core.$ZodResult
   const a = z.any().check(
     z.check<string>((ctx) => {
       if (typeof ctx.value === "string") return;
@@ -871,12 +912,15 @@ test("z.stringbool", () => {
   expect(z.parse(b, "n")).toEqual(false);
   expect(z.safeParse(b, "true")).toMatchObject({ success: false });
   expect(z.safeParse(b, "false")).toMatchObject({ success: false });
+  expect(b._zod.bag.truthy).toEqual(["y"]);
+  expect(b._zod.bag.falsy).toEqual(["n"]);
 
   const c = z.stringbool({
     case: "sensitive",
   });
   expect(z.parse(c, "true")).toEqual(true);
   expect(z.safeParse(c, "TRUE")).toMatchObject({ success: false });
+  expect(c._zod.bag.case).toEqual("sensitive");
 });
 
 // promise
@@ -991,3 +1035,26 @@ test("type narrowing works with type property", () => {
     expect(arraySchema.def.element).toBeDefined();
   }
 });
+
+test("getDiscriminatedOption", () => {
+  const a = z.object({ type: z.literal("a"), x: z.string() });
+  const b = z.object({ type: z.literal("b"), y: z.number() });
+  const schema = z.discriminatedUnion("type", [a, b]);
+
+  expect(z.getDiscriminatedOption(schema, "a")).toBe(a);
+  expect(z.getDiscriminatedOption(schema, "b")).toBe(b);
+  expectTypeOf(z.getDiscriminatedOption(schema, "a")).toEqualTypeOf<typeof a>();
+});
+
+test("z.partial on a tuple", () => {
+  const schema = z.partial(z.tuple([z.string(), z.number()]));
+  expectTypeOf<z.infer<typeof schema>>().toEqualTypeOf<[(string | undefined)?, (number | undefined)?]>();
+
+  expect(z.safeParse(schema, []).success).toEqual(true);
+  expect(z.safeParse(schema, ["a"]).success).toEqual(true);
+  expect(z.safeParse(schema, ["a", 1]).success).toEqual(true);
+  expect(z.safeParse(schema, ["a", "b"]).success).toEqual(false);
+
+  const refined = z.tuple([z.string(), z.number()]).check(z.refine(([a]) => a.length > 0));
+  expect(() => z.partial(refined)).toThrow("cannot be used on tuple schemas containing refinements");
+});

package/node_modules/zod/src/v4/mini/tests/number.test.ts

@@ -93,3 +93,17 @@ test("z.uint64", () => {
   // expect(() => z.parse(a, BigInt("18446744073709551616"))).toThrow(); // Exceeds max
   // expect(() => z.parse(a, BigInt("-1"))).toThrow(); // Below min
 });
+
+test("number and bigint formats are distinct at the type level", () => {
+  expectTypeOf(z.int()._zod.def.format).toEqualTypeOf<"safeint">();
+  expectTypeOf(z.uint32()._zod.def.format).toEqualTypeOf<"uint32">();
+  expectTypeOf(z.int64()._zod.def.format).toEqualTypeOf<"int64">();
+
+  z.int32() satisfies z.ZodMiniInt32;
+  z.uint64() satisfies z.ZodMiniUInt64;
+
+  // @ts-expect-error a float64 schema is not a ZodMiniFloat32
+  z.float64() satisfies z.ZodMiniFloat32;
+  // @ts-expect-error a uint64 schema is not a ZodMiniInt64
+  z.uint64() satisfies z.ZodMiniInt64;
+});

package/node_modules/zod/src/v4/mini/tests/object.test.ts

@@ -116,6 +116,27 @@ test("z.extend", () => {
   expect(z.safeParse(extendedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
 });
 
+test("z.merge", () => {
+  const mergedSchema = z.merge(userSchema, z.object({ isAdmin: z.boolean() }));
+  type MergedUser = z.infer<typeof mergedSchema>;
+  expectTypeOf<MergedUser>().toEqualTypeOf<{
+    name: string;
+    age: number;
+    email?: string | undefined;
+    isAdmin: boolean;
+  }>();
+  expect(z.safeParse(mergedSchema, { name: "John", age: 30, isAdmin: true }).success).toBe(true);
+
+  // the second schema's catchall wins, matching classic
+  const strict = z.merge(userSchema, z.strictObject({ isAdmin: z.boolean() }));
+  expect(z.safeParse(strict, { name: "John", age: 30, isAdmin: true, extra: 1 }).success).toBe(false);
+
+  expect(() =>
+    // @ts-expect-error second argument is a schema, not a shape
+    z.merge(userSchema, { isAdmin: z.boolean() })
+  ).toThrow("Invalid input to merge");
+});
+
 test("z.safeExtend", () => {
   const extended = z.safeExtend(userSchema, { name: z.string() });
   expect(z.safeParse(extended, { name: "John", age: 30 }).success).toBe(true);
@@ -168,6 +189,50 @@ test("z.partial with mask", () => {
   expect(z.safeParse(partialSchemaWithMask, { name: "John" }).success).toBe(false);
 });
 
+test("z.exactPartial", () => {
+  const partialSchema = z.exactPartial(userSchema);
+  type PartialUser = z.infer<typeof partialSchema>;
+  expectTypeOf<PartialUser>().toEqualTypeOf<{
+    name?: string;
+    age?: number;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchema, { name: "John" }).success).toBe(true);
+  expect(z.safeParse(partialSchema, {}).success).toBe(true);
+  expect(z.safeParse(partialSchema, { name: undefined }).success).toBe(false);
+  expect(z.safeParse(partialSchema, { email: undefined }).success).toBe(true);
+});
+
+test("z.exactPartial with mask", () => {
+  const partialSchemaWithMask = z.exactPartial(userSchema, { name: true });
+  type PartialUserWithMask = z.infer<typeof partialSchemaWithMask>;
+  expectTypeOf<PartialUserWithMask>().toEqualTypeOf<{
+    name?: string;
+    age: number;
+    email?: string | undefined;
+  }>();
+  expect(z.safeParse(partialSchemaWithMask, { age: 30 }).success).toBe(true);
+  expect(z.safeParse(partialSchemaWithMask, { age: 30, name: undefined }).success).toBe(false);
+});
+
+test("z.required", () => {
+  const requiredSchema = z.required(userSchema);
+  type RequiredUser = z.infer<typeof requiredSchema>;
+  expectTypeOf<RequiredUser>().toEqualTypeOf<{ name: string; age: number; email: string }>();
+  expect(requiredSchema.shape.email).toBeInstanceOf(z.ZodMiniNonOptional);
+  expect(z.safeParse(requiredSchema, { name: "John", age: 30 }).success).toBe(false);
+  expect(z.safeParse(requiredSchema, { name: "John", age: 30, email: "john@example.com" }).success).toBe(true);
+});
+
+test("z.required with mask", () => {
+  const schema = z.object({ name: z.optional(z.string()), age: z.optional(z.number()) });
+  const requiredSchemaWithMask = z.required(schema, { name: true });
+  type RequiredWithMask = z.infer<typeof requiredSchemaWithMask>;
+  expectTypeOf<RequiredWithMask>().toEqualTypeOf<{ name: string; age?: number | undefined }>();
+  expect(requiredSchemaWithMask.shape.name).toBeInstanceOf(z.ZodMiniNonOptional);
+  expect(requiredSchemaWithMask.shape.age).toBeInstanceOf(z.ZodMiniOptional);
+});
+
 test("z.pick/omit/partial/required - do not allow unknown keys", () => {
   const schema = z.object({
     name: z.string(),

package/node_modules/zod/src/v4/mini/tests/string.test.ts

@@ -177,6 +177,13 @@ test("z.nanoid", () => {
   expect(() => z.parse(a, "abc")).toThrow();
 });
 
+test("z.nanoid custom length", () => {
+  const a = z.nanoid({ length: 64 });
+  const id = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  expect(z.parse(a, id)).toEqual(id);
+  expect(() => z.parse(a, "8FHZpIxleEK3axQRBNNjN")).toThrow();
+});
+
 test("z.cuid", () => {
   const a = z.cuid();
   expect(z.parse(a, "cixs7y0c0000f7x3b1z6m3w6r")).toEqual("cixs7y0c0000f7x3b1z6m3w6r");
@@ -317,6 +324,20 @@ test("z.e164", () => {
   expect(() => z.parse(a, 123)).toThrow();
 });
 
+test("z.creditCard", () => {
+  const a = z.creditCard();
+  // valid credit card
+  expect(z.parse(a, "4111111111111111")).toEqual("4111111111111111");
+  expect(z.parse(a, "4111 1111 1111 1111")).toEqual("4111 1111 1111 1111");
+  // failed Luhn checksum
+  expect(() => z.parse(a, "4111111111111112")).toThrow();
+  // outside the 12-19 digit range
+  expect(() => z.parse(a, "40000000006")).toThrow();
+  expect(() => z.parse(a, "hello")).toThrow();
+  // wrong type
+  expect(() => z.parse(a, 123)).toThrow();
+});
+
 test("z.jwt", () => {
   const a = z.jwt();
   // valid jwt

package/node_modules/zod/v3/ZodError.cjs

@@ -75,21 +75,31 @@ class ZodError extends Error {
                     while (i < issue.path.length) {
                         const el = issue.path[i];
                         const terminal = i === issue.path.length - 1;
-                        if (!terminal) {
-                            curr[el] = curr[el] || { _errors: [] };
-                            // if (typeof el === "string") {
-                            //   curr[el] = curr[el] || { _errors: [] };
-                            // } else if (typeof el === "number") {
-                            //   const errorArray: any = [];
-                            //   errorArray._errors = [];
-                            //   curr[el] = curr[el] || errorArray;
-                            // }
+                        // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
+                        if (el === "_errors") {
+                            if (terminal)
+                                curr._errors.push(mapper(issue));
+                            i++;
+                            continue;
                         }
-                        else {
-                            curr[el] = curr[el] || { _errors: [] };
-                            curr[el]._errors.push(mapper(issue));
+                        // Create `el` as an own data property. A segment naming an inherited member ("toString", "constructor") would otherwise read through to the prototype, and assigning "__proto__" would hit the setter and walk into Object.prototype.
+                        if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+                            if (el === "__proto__") {
+                                Object.defineProperty(curr, el, {
+                                    value: { _errors: [] },
+                                    writable: true,
+                                    enumerable: true,
+                                    configurable: true,
+                                });
+                            }
+                            else {
+                                curr[el] = { _errors: [] };
+                            }
                         }
                         curr = curr[el];
+                        if (terminal) {
+                            curr._errors.push(mapper(issue));
+                        }
                         i++;
                     }
                 }

package/node_modules/zod/v3/ZodError.d.cts

@@ -10,13 +10,13 @@ export type typeToFlattenedError<T, U = string> = {
     };
 };
 export declare const ZodIssueCode: {
-    custom: "custom";
     invalid_type: "invalid_type";
     too_big: "too_big";
     too_small: "too_small";
     not_multiple_of: "not_multiple_of";
     unrecognized_keys: "unrecognized_keys";
     invalid_union: "invalid_union";
+    custom: "custom";
     invalid_literal: "invalid_literal";
     invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";

package/node_modules/zod/v3/ZodError.d.ts

@@ -10,13 +10,13 @@ export type typeToFlattenedError<T, U = string> = {
     };
 };
 export declare const ZodIssueCode: {
-    custom: "custom";
     invalid_type: "invalid_type";
     too_big: "too_big";
     too_small: "too_small";
     not_multiple_of: "not_multiple_of";
     unrecognized_keys: "unrecognized_keys";
     invalid_union: "invalid_union";
+    custom: "custom";
     invalid_literal: "invalid_literal";
     invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";

package/node_modules/zod/v3/ZodError.js

@@ -71,21 +71,31 @@ export class ZodError extends Error {
                     while (i < issue.path.length) {
                         const el = issue.path[i];
                         const terminal = i === issue.path.length - 1;
-                        if (!terminal) {
-                            curr[el] = curr[el] || { _errors: [] };
-                            // if (typeof el === "string") {
-                            //   curr[el] = curr[el] || { _errors: [] };
-                            // } else if (typeof el === "number") {
-                            //   const errorArray: any = [];
-                            //   errorArray._errors = [];
-                            //   curr[el] = curr[el] || errorArray;
-                            // }
+                        // `_errors` is reserved by this legacy format, so merge a matching path segment into the current node instead of treating its array as a child.
+                        if (el === "_errors") {
+                            if (terminal)
+                                curr._errors.push(mapper(issue));
+                            i++;
+                            continue;
                         }
-                        else {
-                            curr[el] = curr[el] || { _errors: [] };
-                            curr[el]._errors.push(mapper(issue));
+                        // Create `el` as an own data property. A segment naming an inherited member ("toString", "constructor") would otherwise read through to the prototype, and assigning "__proto__" would hit the setter and walk into Object.prototype.
+                        if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+                            if (el === "__proto__") {
+                                Object.defineProperty(curr, el, {
+                                    value: { _errors: [] },
+                                    writable: true,
+                                    enumerable: true,
+                                    configurable: true,
+                                });
+                            }
+                            else {
+                                curr[el] = { _errors: [] };
+                            }
                         }
                         curr = curr[el];
+                        if (terminal) {
+                            curr._errors.push(mapper(issue));
+                        }
                         i++;
                     }
                 }

package/node_modules/zod/v3/types.cjs

@@ -394,7 +394,7 @@ const emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z
 // const emailRegex =
 //   /^[a-z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-z0-9-]+(?:\.[a-z0-9\-]+)*$/i;
 // from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
-const _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+const _emojiRegex = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
 let emojiRegex;
 // faster, simpler, safer
 const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
@@ -2528,7 +2528,11 @@ function mergeValues(a, b) {
         const bKeys = util_js_1.util.objectKeys(b);
         const sharedKeys = util_js_1.util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
         const newObj = { ...a, ...b };
+        if (Object.prototype.hasOwnProperty.call(newObj, "__proto__"))
+            delete newObj.__proto__;
         for (const key of sharedKeys) {
+            if (key === "__proto__")
+                continue;
             const sharedValue = mergeValues(a[key], b[key]);
             if (!sharedValue.valid) {
                 return { valid: false };
@@ -2937,8 +2941,7 @@ class ZodFunction extends ZodType {
         const params = { errorMap: ctx.common.contextualErrorMap };
         const fn = ctx.data;
         if (this._def.returns instanceof ZodPromise) {
-            // Would love a way to avoid disabling this rule, but we need
-            // an alias (using an arrow function was what caused 2651).
+            // Would love a way to avoid disabling this rule, but we need an alias (using an arrow function was what caused 2651).
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const me = this;
             return (0, parseUtil_js_1.OK)(async function (...args) {
@@ -2958,8 +2961,7 @@ class ZodFunction extends ZodType {
             });
         }
         else {
-            // Would love a way to avoid disabling this rule, but we need
-            // an alias (using an arrow function was what caused 2651).
+            // Would love a way to avoid disabling this rule, but we need an alias (using an arrow function was what caused 2651).
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const me = this;
             return (0, parseUtil_js_1.OK)(function (...args) {

package/node_modules/zod/v3/types.js

@@ -385,7 +385,7 @@ const emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z
 // const emailRegex =
 //   /^[a-z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-z0-9-]+(?:\.[a-z0-9\-]+)*$/i;
 // from https://thekevinscott.com/emojis-in-javascript/#writing-a-regular-expression
-const _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
+const _emojiRegex = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
 let emojiRegex;
 // faster, simpler, safer
 const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
@@ -2503,7 +2503,11 @@ function mergeValues(a, b) {
         const bKeys = util.objectKeys(b);
         const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
         const newObj = { ...a, ...b };
+        if (Object.prototype.hasOwnProperty.call(newObj, "__proto__"))
+            delete newObj.__proto__;
         for (const key of sharedKeys) {
+            if (key === "__proto__")
+                continue;
             const sharedValue = mergeValues(a[key], b[key]);
             if (!sharedValue.valid) {
                 return { valid: false };
@@ -2907,8 +2911,7 @@ export class ZodFunction extends ZodType {
         const params = { errorMap: ctx.common.contextualErrorMap };
         const fn = ctx.data;
         if (this._def.returns instanceof ZodPromise) {
-            // Would love a way to avoid disabling this rule, but we need
-            // an alias (using an arrow function was what caused 2651).
+            // Would love a way to avoid disabling this rule, but we need an alias (using an arrow function was what caused 2651).
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const me = this;
             return OK(async function (...args) {
@@ -2928,8 +2931,7 @@ export class ZodFunction extends ZodType {
             });
         }
         else {
-            // Would love a way to avoid disabling this rule, but we need
-            // an alias (using an arrow function was what caused 2651).
+            // Would love a way to avoid disabling this rule, but we need an alias (using an arrow function was what caused 2651).
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const me = this;
             return OK(function (...args) {

package/node_modules/zod/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/node_modules/zod/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/node_modules/zod/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/node_modules/zod/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/node_modules/zod/v4/classic/compat.d.cts

@@ -1,12 +1,11 @@
 import * as core from "../core/index.cjs";
 import type { ZodType } from "./schemas.cjs";
-export type { 
 /** @deprecated Use `z.output<T>` instead. */
-output as TypeOf, 
+export type TypeOf<T> = core.output<T>;
 /** @deprecated Use `z.output<T>` instead. */
-output as Infer, 
-/** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */
-$ZodTypes as ZodFirstPartySchemaTypes, } from "../core/index.cjs";
+export type Infer<T> = core.output<T>;
+/** @deprecated Use `z.core.$ZodTypes` instead */
+export type ZodFirstPartySchemaTypes = core.$ZodTypes;
 /** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
 export declare const ZodIssueCode: {
     readonly invalid_type: "invalid_type";
@@ -21,9 +20,9 @@ export declare const ZodIssueCode: {
     readonly invalid_value: "invalid_value";
     readonly custom: "custom";
 };
-/** @deprecated Use `z.$ZodFlattenedError` */
+/** @deprecated Use `z.core.$ZodFlattenedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
-/** @deprecated Use `z.$ZodFormattedError` */
+/** @deprecated Use `z.core.$ZodFormattedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<core.output<T>, U>;
 /** Use `z.$brand` instead */
 export type BRAND<T extends string | number | symbol = string | number | symbol> = {
@@ -36,13 +35,12 @@ export { $brand, config } from "../core/index.cjs";
 export declare function setErrorMap(map: core.$ZodErrorMap): void;
 /** @deprecated Use `z.config()` instead. */
 export declare function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined;
-export type { 
 /** @deprecated Use z.ZodType (without generics) instead. */
-ZodType as ZodTypeAny, 
+export type ZodTypeAny<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** @deprecated Use `z.ZodType` */
-ZodType as ZodSchema, 
+export type ZodSchema<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** @deprecated Use `z.ZodType` */
-ZodType as Schema, };
+export type Schema<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;
 /** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */

package/node_modules/zod/v4/classic/compat.d.ts

@@ -1,12 +1,11 @@
 import * as core from "../core/index.js";
 import type { ZodType } from "./schemas.js";
-export type { 
 /** @deprecated Use `z.output<T>` instead. */
-output as TypeOf, 
+export type TypeOf<T> = core.output<T>;
 /** @deprecated Use `z.output<T>` instead. */
-output as Infer, 
-/** @deprecated Use `z.core.$$ZodFirstPartyTypes` instead */
-$ZodTypes as ZodFirstPartySchemaTypes, } from "../core/index.js";
+export type Infer<T> = core.output<T>;
+/** @deprecated Use `z.core.$ZodTypes` instead */
+export type ZodFirstPartySchemaTypes = core.$ZodTypes;
 /** @deprecated Use the raw string literal codes instead, e.g. "invalid_type". */
 export declare const ZodIssueCode: {
     readonly invalid_type: "invalid_type";
@@ -21,9 +20,9 @@ export declare const ZodIssueCode: {
     readonly invalid_value: "invalid_value";
     readonly custom: "custom";
 };
-/** @deprecated Use `z.$ZodFlattenedError` */
+/** @deprecated Use `z.core.$ZodFlattenedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFlattenedErrors<T extends core.$ZodType, U = string> = core.$ZodFlattenedError<core.output<T>, U>;
-/** @deprecated Use `z.$ZodFormattedError` */
+/** @deprecated Use `z.core.$ZodFormattedError<z.output<T>>` instead; it takes an inferred type, not a schema. */
 export type inferFormattedError<T extends core.$ZodType<any, any>, U = string> = core.$ZodFormattedError<core.output<T>, U>;
 /** Use `z.$brand` instead */
 export type BRAND<T extends string | number | symbol = string | number | symbol> = {
@@ -36,13 +35,12 @@ export { $brand, config } from "../core/index.js";
 export declare function setErrorMap(map: core.$ZodErrorMap): void;
 /** @deprecated Use `z.config()` instead. */
 export declare function getErrorMap(): core.$ZodErrorMap<core.$ZodIssue> | undefined;
-export type { 
 /** @deprecated Use z.ZodType (without generics) instead. */
-ZodType as ZodTypeAny, 
+export type ZodTypeAny<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** @deprecated Use `z.ZodType` */
-ZodType as ZodSchema, 
+export type ZodSchema<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** @deprecated Use `z.ZodType` */
-ZodType as Schema, };
+export type Schema<Output = unknown, Input = unknown, Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>> = ZodType<Output, Input, Internals>;
 /** Included for Zod 3 compatibility */
 export type ZodRawShape = core.$ZodShape;
 /** @deprecated Do not use. Stub definition, only included for zod-to-json-schema compatibility. */