@psnext/slingcli 3.1.20260904-1 → 3.3.20260914-1

package/node_modules/zod/src/v4/core/util.ts

@@ -98,11 +98,29 @@ type ToZodKeyMismatch<Expected, Received> = schemas.$ZodType & {
   "types do not match": { expected: Expected; received: Received };
 };
 
+// An enum reference and the union of exactly its members are mutually assignable but not identical, so `AssertEqual` alone rejects `z.enum(SomeEnum)` against a `SomeEnum` target. Unioning each side with a private dummy forces the union to be rebuilt, which collapses that one difference and nothing else — plain literals against an enum, member subsets, brands and `any` all still fail. The symbol is not exported, so no user type can smuggle it in and cancel a real difference.
+declare const toZodDummy: unique symbol;
+
+// Homomorphic, so `readonly` and optional modifiers survive the rebuild and only leaves are normalized. An intersection flattens here, which is why an intersection target and the flat object with the same keys match each other. A callable stops the walk because `keyof` a function is `never`, so mapping one would erase its signature and make every function compare equal.
+type ToZodNormalize<T> = [T] extends [(...args: any[]) => any]
+  ? T
+  : [T] extends [object]
+    ? { [K in keyof T]: ToZodNormalize<T[K]> }
+    : T | typeof toZodDummy;
+
+type ToZodEqual<Output, T> = AssertEqual<Output, T> extends true
+  ? true
+  : IsAny<Output> extends true
+    ? false
+    : IsAny<T> extends true
+      ? false
+      : AssertEqual<ToZodNormalize<Output>, ToZodNormalize<T>>;
+
 // Rebuilds the shape with a marker on each key that disagrees, so the diagnostic names the key instead of failing the whole schema at the top level. A key the target lacks reports `expected: never`; a key the schema lacks reports `received: never`.
 type ToZodShape<Shape, T> = {
   [K in keyof Shape]: Shape[K] extends schemas.$ZodType
     ? K extends keyof T
-      ? AssertEqual<Shape[K]["_zod"]["output"], T[K]> extends true
+      ? ToZodEqual<Shape[K]["_zod"]["output"], T[K]> extends true
         ? Shape[K]
         : ToZodKeyMismatch<T[K], Shape[K]["_zod"]["output"]>
       : ToZodKeyMismatch<never, Shape[K]["_zod"]["output"]>
@@ -129,6 +147,17 @@ export type MakeRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K
 export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
 export type NoUndefined<T> = T extends undefined ? never : T;
 export type Whatever = {} | undefined | null;
+// literal inputs widen to their primitive so a property check over `"https:"` accepts a `string` property
+export type Widen<T> = T extends string
+  ? string
+  : T extends number
+    ? number
+    : T extends boolean
+      ? boolean
+      : T extends bigint
+        ? bigint
+        : T;
+
 export type LoosePartial<T extends object> = InexactPartial<T> & {
   [k: string]: unknown;
 };
@@ -232,7 +261,7 @@ export function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<
 }
 
 export function toZod<T>(): <S extends schemas.$ZodType>(
-  schema: AssertEqual<S["_zod"]["output"], T> extends true ? S : ToZodTarget<S, T>
+  schema: ToZodEqual<S["_zod"]["output"], T> extends true ? S : ToZodTarget<S, T>
 ) => S {
   return (schema) => schema as any;
 }
@@ -261,18 +290,28 @@ export function jsonStringifyReplacer(_: string, value: any): any {
   return value;
 }
 
+// the accessor lives on a shared prototype: an own accessor makes every box a dictionary-mode object (~360 B and a slow load per read against ~100 B and an inlined getter here)
+class Cached<T> {
+  _getter: (() => T) | undefined;
+  _value: T | undefined;
+
+  constructor(getter: () => T) {
+    this._getter = getter;
+    this._value = undefined;
+  }
+
+  get value(): T {
+    const getter = this._getter;
+    if (getter !== undefined) {
+      this._value = getter();
+      this._getter = undefined;
+    }
+    return this._value as T;
+  }
+}
+
 export function cached<T>(getter: () => T): { value: T } {
-  const set = false;
-  return {
-    get value() {
-      if (!set) {
-        const value = getter();
-        Object.defineProperty(this, "value", { value });
-        return value;
-      }
-      throw new Error("cached value already set");
-    },
-  };
+  return new Cached(getter);
 }
 
 export function nullish(input: any): boolean {
@@ -338,6 +377,80 @@ export function assignProp<T extends object, K extends PropertyKey>(
   });
 }
 
+/** A def's `shape` accessor, carrying whichever object it currently answers from. */
+export interface ShapeGetter {
+  (): Record<PropertyKey, any>;
+  raw: Record<PropertyKey, any>;
+}
+
+/**
+ * Whichever object a def's `shape` currently answers from: the one the caller passed until the first read, the frozen copy after it.
+ *
+ * Its keys and descriptors read without invoking anything, which is what lets a discriminated union check its discriminator, and the cycle walk read a shape, without resolving a getter that references the schema being constructed. A def that answers `shape` from an accessor of its own has none.
+ */
+export function rawShape(def: any): Record<PropertyKey, any> | undefined {
+  const desc = Object.getOwnPropertyDescriptor(def, "shape");
+  return desc?.get ? (desc.get as ShapeGetter).raw : desc?.value;
+}
+
+// where a builder reads its source's keys and descriptors, resolving only a shape a def answers for itself. A shape resolves by object spread, so only its enumerable keys are ever part of it.
+function sourceShape(schema: schemas.$ZodObject): Record<PropertyKey, any> {
+  return rawShape(schema._zod.def) ?? (schema._zod.def.shape as any);
+}
+
+// a key whose value is not settled yet, self-caching so every read after the first gets the same one
+function deferProp(target: object, key: PropertyKey, getter: () => any): void {
+  Object.defineProperty(target, key, {
+    get(this: any) {
+      const value = getter();
+      assignProp(this, key as any, value);
+      return value;
+    },
+    enumerable: true,
+    configurable: true,
+  });
+}
+
+// Writes a settled key. A plain assignment is much cheaper than `defineProperty` and produces the same descriptor, but it runs whatever setter already answers to the key — an accessor this shape deferred, or an inherited one, which `__proto__` has on every object and prototype pollution can add for any name.
+function putProp(target: any, key: PropertyKey, value: any): void {
+  if (key in target) assignProp(target, key as any, value);
+  else target[key] = value;
+}
+
+/**
+ * Copies `keys` of `source`'s shape onto `target`, each value passed through `wrap`.
+ *
+ * A key the source has resolved is copied through now, so the derived shape states it outright and nothing has to resolve it to learn what it holds. A key the source still defers stays deferred, and reads back through the source's own `shape`, so it resolves once and both shapes get that one schema.
+ */
+function mirrorShape(
+  target: object,
+  source: schemas.$ZodObject,
+  keys: PropertyKey[],
+  wrap?: ((value: any, key: PropertyKey) => any) | null
+): void {
+  const raw = sourceShape(source);
+  for (const key of keys) {
+    const desc = Object.getOwnPropertyDescriptor(raw, key)!;
+    if (!desc.enumerable) continue;
+    if (desc.get) {
+      deferProp(target, key, () => {
+        const value = (source._zod.def.shape as any)[key];
+        return wrap ? wrap(value, key) : value;
+      });
+    } else putProp(target, key, wrap ? wrap(desc.value, key) : desc.value);
+  }
+}
+
+// same, for a plain shape a caller passed rather than a schema's
+function mirrorProps(target: object, source: Record<PropertyKey, any>): void {
+  for (const key of Reflect.ownKeys(source)) {
+    const desc = Object.getOwnPropertyDescriptor(source, key)!;
+    if (!desc.enumerable) continue;
+    if (desc.get) deferProp(target, key, () => source[key as any]);
+    else putProp(target, key, desc.value);
+  }
+}
+
 export function mergeDefs(...defs: Record<string, any>[]): any {
   const mergedDescriptors: Record<string, PropertyDescriptor> = {};
 
@@ -647,25 +760,24 @@ export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>):
     throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
 
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const newShape: Writeable<schemas.$ZodShape> = {};
-      // `for...in` skips symbols, so a symbol in the mask would select nothing
-      for (const key of Reflect.ownKeys(mask)) {
-        if (!Object.prototype.hasOwnProperty.call(currDef.shape, key)) {
-          throw new Error(`Unrecognized key: "${String(key)}"`);
-        }
-        if (!mask[key as string]) continue;
-        assignProp(newShape, key as string, (currDef.shape as any)[key]!);
-      }
+  const newShape: Writeable<schemas.$ZodShape> = {};
+  mirrorShape(newShape, schema, maskedKeys(schema, mask));
 
-      assignProp(this, "shape", newShape); // self-caching
-      return newShape;
-    },
-    checks: [],
-  });
+  return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] })) as any;
+}
 
-  return clone(schema, def) as any;
+// the mask keys that select something, checked against the source's shape without resolving it
+function maskedKeys(schema: schemas.$ZodObject, mask: object): PropertyKey[] {
+  const raw = sourceShape(schema);
+  const keys: PropertyKey[] = [];
+  // `for...in` skips symbols, so a symbol in the mask would select nothing
+  for (const key of Reflect.ownKeys(mask)) {
+    if (!Object.getOwnPropertyDescriptor(raw, key)?.enumerable) {
+      throw new Error(`Unrecognized key: "${String(key)}"`);
+    }
+    if ((mask as any)[key]) keys.push(key);
+  }
+  return keys;
 }
 
 export function omit(schema: schemas.$ZodObject, mask: object): any {
@@ -677,24 +789,15 @@ export function omit(schema: schemas.$ZodObject, mask: object): any {
     throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
 
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
-      for (const key of Reflect.ownKeys(mask)) {
-        if (!Object.prototype.hasOwnProperty.call(currDef.shape, key)) {
-          throw new Error(`Unrecognized key: "${String(key)}"`);
-        }
-        if (!(mask as any)[key]) continue;
-
-        delete newShape[key as string];
-      }
-      assignProp(this, "shape", newShape); // self-caching
-      return newShape;
-    },
-    checks: [],
-  });
+  const omitted = new Set(maskedKeys(schema, mask));
+  const newShape: Writeable<schemas.$ZodShape> = {};
+  mirrorShape(
+    newShape,
+    schema,
+    Reflect.ownKeys(sourceShape(schema)).filter((key) => !omitted.has(key))
+  );
 
-  return clone(schema, def);
+  return clone(schema, mergeDefs(currDef, { shape: newShape, checks: [] }));
 }
 
 export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any {
@@ -706,7 +809,7 @@ export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): an
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     // Only throw if new shape overlaps with existing shape. Use getOwnPropertyDescriptor to check key existence without accessing values
-    const existingShape = schema._zod.def.shape;
+    const existingShape = sourceShape(schema);
     for (const key of Reflect.ownKeys(shape)) {
       if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
@@ -714,28 +817,22 @@ export function extend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): an
     }
   }
 
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
-      assignProp(this, "shape", _shape); // self-caching
-      return _shape;
-    },
-  });
-  return clone(schema, def) as any;
+  return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) })) as any;
+}
+
+// the source's keys, then the caller's overlaid on top
+function extended(schema: schemas.$ZodObject, shape: schemas.$ZodShape): schemas.$ZodShape {
+  const newShape: Writeable<schemas.$ZodShape> = {};
+  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)));
+  mirrorProps(newShape, shape);
+  return newShape;
 }
 
 export function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape): any {
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
-      assignProp(this, "shape", _shape); // self-caching
-      return _shape;
-    },
-  });
-  return clone(schema, def) as any;
+  return clone(schema, mergeDefs(schema._zod.def, { shape: extended(schema, shape) })) as any;
 }
 
 export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
@@ -745,12 +842,12 @@ export function merge(a: schemas.$ZodObject, b: schemas.$ZodObject): any {
   if (a._zod.def.checks?.length) {
     throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
   }
+  const newShape: Writeable<schemas.$ZodShape> = {};
+  mirrorShape(newShape, a, Reflect.ownKeys(sourceShape(a)));
+  mirrorShape(newShape, b, Reflect.ownKeys(sourceShape(b)));
+
   const def = mergeDefs(a._zod.def, {
-    get shape() {
-      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
-      assignProp(this, "shape", _shape); // self-caching
-      return _shape;
-    },
+    shape: newShape,
     get catchall() {
       return b._zod.def.catchall;
     },
@@ -773,45 +870,17 @@ export function partial(
     throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
   }
 
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const oldShape = schema._zod.def.shape;
-      const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
-
-      if (mask) {
-        for (const key of Reflect.ownKeys(mask)) {
-          if (!Object.prototype.hasOwnProperty.call(oldShape, key)) {
-            throw new Error(`Unrecognized key: "${String(key)}"`);
-          }
-          if (!(mask as any)[key]) continue;
-          // if (oldShape[key]!._zod.optin === "optional") continue;
-          (shape as any)[key] = Class
-            ? new Class({
-                type: "optional",
-                innerType: (oldShape as any)[key]!,
-              })
-            : (oldShape as any)[key]!;
-        }
-      } else {
-        // the spread copies symbol keys; `for...in` would not reach them
-        for (const key of Reflect.ownKeys(oldShape)) {
-          // if (oldShape[key]!._zod.optin === "optional") continue;
-          (shape as any)[key] = Class
-            ? new Class({
-                type: "optional",
-                innerType: (oldShape as any)[key]!,
-              })
-            : (oldShape as any)[key]!;
-        }
-      }
+  const selected = mask ? new Set(maskedKeys(schema, mask)) : undefined;
+  const newShape: Writeable<schemas.$ZodShape> = {};
+  mirrorShape(
+    newShape,
+    schema,
+    Reflect.ownKeys(sourceShape(schema)),
+    Class &&
+      ((value, key) => (selected && !selected.has(key) ? value : new Class({ type: "optional", innerType: value })))
+  );
 
-      assignProp(this, "shape", shape); // self-caching
-      return shape;
-    },
-    checks: [],
-  });
-
-  return clone(schema, def) as any;
+  return clone(schema, mergeDefs(schema._zod.def, { shape: newShape, checks: [] })) as any;
 }
 
 export function required(
@@ -819,39 +888,14 @@ export function required(
   schema: schemas.$ZodObject,
   mask: object | undefined
 ): any {
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const oldShape = schema._zod.def.shape;
-      const shape: Writeable<schemas.$ZodShape> = { ...oldShape };
-
-      if (mask) {
-        for (const key of Reflect.ownKeys(mask)) {
-          if (!Object.prototype.hasOwnProperty.call(shape, key)) {
-            throw new Error(`Unrecognized key: "${String(key)}"`);
-          }
-          if (!(mask as any)[key]) continue;
-          // overwrite with non-optional
-          (shape as any)[key] = new Class({
-            type: "nonoptional",
-            innerType: (oldShape as any)[key]!,
-          });
-        }
-      } else {
-        for (const key of Reflect.ownKeys(oldShape)) {
-          // overwrite with non-optional
-          (shape as any)[key] = new Class({
-            type: "nonoptional",
-            innerType: (oldShape as any)[key]!,
-          });
-        }
-      }
+  const selected = mask ? new Set(maskedKeys(schema, mask)) : undefined;
+  const newShape: Writeable<schemas.$ZodShape> = {};
+  mirrorShape(newShape, schema, Reflect.ownKeys(sourceShape(schema)), (value, key) =>
+    // overwrite with non-optional
+    selected && !selected.has(key) ? value : new Class({ type: "nonoptional", innerType: value })
+  );
 
-      assignProp(this, "shape", shape); // self-caching
-      return shape;
-    },
-  });
-
-  return clone(schema, def) as any;
+  return clone(schema, mergeDefs(schema._zod.def, { shape: newShape })) as any;
 }
 
 export type Constructor<T, Def extends any[] = any[]> = new (...args: Def) => T;
@@ -920,13 +964,18 @@ export function finalizeIssue(
       unwrapMessage(config.localeError?.(iss)) ??
       "Invalid input");
 
-  const { inst: _inst, schema: _schema, continue: _continue, input: _input, ...rest } = iss as any;
-  rest.path ??= [];
-  rest.message = message;
+  // an explicit own-key copy beats object rest with excluded keys, which v8 routes through a generic runtime call; Object.keys rather than for-in so an issue pushed with a prototype does not leak inherited keys, and an own __proto__ key is dropped rather than assigned through the setter
+  const full: any = {};
+  for (const k of Object.keys(iss)) {
+    if (k === "inst" || k === "schema" || k === "continue" || k === "input" || k === "__proto__") continue;
+    full[k] = (iss as any)[k];
+  }
+  full.path ??= [];
+  full.message = message;
   if (ctx?.reportInput) {
-    rest.input = _input;
+    full.input = iss.input;
   }
-  return rest;
+  return full;
 }
 
 export function getSizableOrigin(input: any): "set" | "map" | "file" | "unknown" {
@@ -1079,17 +1128,39 @@ export function members(proto: object, table: object): void {
 }
 
 /** Shadows a prototype member with an own value, so a getter that builds from the instance runs once. */
-export function own<T>(inst: object, key: string, value: T, enumerable = true): T {
+export function own<T>(inst: object, key: PropertyKey, value: T, enumerable = true): T {
   Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
   return value;
 }
 
 /** Like {@link own}, for a member that was never an own data property and has to stay out of `Object.keys`. */
-export function hide<T>(inst: object, key: string, value: T): T {
+export function hide<T>(inst: object, key: PropertyKey, value: T): T {
   return own(inst, key, value, false);
 }
 
-function defineBound(proto: object, key: string, fn: AnyFunc): void {
+/** Adds members a table derives from the instance: each builds on first read and shadows as own data, and assignment shadows the same way, as when these were own properties. */
+export /*@__NO_SIDE_EFFECTS__*/ function derived<T>(
+  computes: { [K in keyof T]?: (inst: T) => T[K] },
+  table: ProtoOf<T>
+): ProtoOf<T> {
+  for (const key in computes) {
+    const compute = computes[key]!;
+    // an object literal's accessor is configurable and enumerable, and `members` copies the descriptor as written
+    Object.defineProperty(table, key, {
+      configurable: true,
+      enumerable: true,
+      get(this: T) {
+        return own(this as object, key, compute(this));
+      },
+      set(this: T, value: T[typeof key]) {
+        own(this as object, key, value);
+      },
+    });
+  }
+  return table;
+}
+
+function defineBound(proto: object, key: PropertyKey, fn: AnyFunc): void {
   Object.defineProperty(proto, key, {
     configurable: true,
     get(this: any) {

package/node_modules/zod/src/v4/core/versions.ts

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

package/node_modules/zod/src/v4/locales/ar.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "نَص على هيئة JSON",
     e164: "رقم هاتف بمعيار E.164",
     credit_card: "رقم بطاقة الائتمان",
+    currency_code: "رمز العملة",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "مدخل",
   };

package/node_modules/zod/src/v4/locales/az.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON string",
     e164: "E.164 number",
     credit_card: "kredit kartı nömrəsi",
+    currency_code: "valyuta kodu",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "input",
   };

package/node_modules/zod/src/v4/locales/be.ts

@@ -109,6 +109,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON радок",
     e164: "нумар E.164",
     credit_card: "нумар крэдытнай карты",
+    currency_code: "код валюты",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "увод",
   };

package/node_modules/zod/src/v4/locales/bg.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON низ",
     e164: "E.164 номер",
     credit_card: "номер на кредитна карта",
+    currency_code: "код на валута",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "вход",
   };

package/node_modules/zod/src/v4/locales/bn.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON স্ট্রিং",
     e164: "E.164 নম্বর",
     credit_card: "ক্রেডিট কার্ড নম্বর",
+    currency_code: "মুদ্রা কোড",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "ইনপুট",
   };

package/node_modules/zod/src/v4/locales/ca.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "cadena JSON",
     e164: "número E.164",
     credit_card: "número de targeta de crèdit",
+    currency_code: "codi de moneda",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "entrada",
   };

package/node_modules/zod/src/v4/locales/ckb.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "دەقی JSON",
     e164: "ژمارەی E.164",
     credit_card: "ژمارەی کارتی کرێدیت",
+    currency_code: "کۆدی دراو",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "تێکردە",
   };

package/node_modules/zod/src/v4/locales/cs.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "řetězec ve formátu JSON",
     e164: "číslo E.164",
     credit_card: "číslo kreditní karty",
+    currency_code: "kód měny",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "vstup",
   };

package/node_modules/zod/src/v4/locales/da.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON-streng",
     e164: "E.164-nummer",
     credit_card: "kreditkortnummer",
+    currency_code: "valutakode",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "input",
   };

package/node_modules/zod/src/v4/locales/de.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON-String",
     e164: "E.164-Nummer",
     credit_card: "Kreditkartennummer",
+    currency_code: "Währungscode",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "Eingabe",
   };

package/node_modules/zod/src/v4/locales/el.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "συμβολοσειρά JSON",
     e164: "αριθμός E.164",
     credit_card: "αριθμός πιστωτικής κάρτας",
+    currency_code: "κωδικός νομίσματος",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "είσοδος",
   };

package/node_modules/zod/src/v4/locales/en.ts

@@ -45,7 +45,9 @@ const error: () => errors.$ZodErrorMap = () => {
     base64url: "base64url-encoded string",
     json_string: "JSON string",
     e164: "E.164 number",
+    currency_code: "currency code",
     credit_card: "credit card number",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "input",
   };

package/node_modules/zod/src/v4/locales/eo.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON-karaktraro",
     e164: "E.164-nombro",
     credit_card: "kreditkarta numero",
+    currency_code: "valuta kodo",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "enigo",
   };

package/node_modules/zod/src/v4/locales/es.ts

@@ -45,6 +45,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "cadena JSON",
     e164: "número E.164",
     credit_card: "número de tarjeta de crédito",
+    currency_code: "código de moneda",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "entrada",
   };

package/node_modules/zod/src/v4/locales/fa.ts

@@ -46,6 +46,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON رشته",
     e164: "E.164 عدد",
     credit_card: "شماره کارت اعتباری",
+    currency_code: "کد ارز",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "ورودی",
   };

package/node_modules/zod/src/v4/locales/fi.ts

@@ -50,6 +50,8 @@ const error: () => errors.$ZodErrorMap = () => {
     json_string: "JSON-merkkijono",
     e164: "E.164-luku",
     credit_card: "luottokortin numero",
+    currency_code: "valuuttakoodi",
+    iban: "IBAN",
     jwt: "JWT",
     template_literal: "templaattimerkkijono",
   };