aws-runtime-bridge 1.9.70 → 1.9.72

package/node_modules/zod/package.json

@@ -0,0 +1,135 @@
+{
+  "name": "zod",
+  "version": "4.1.12",
+  "type": "module",
+  "license": "MIT",
+  "author": "Colin McDonnell <zod@colinhacks.com>",
+  "description": "TypeScript-first schema declaration and validation library with static type inference",
+  "homepage": "https://zod.dev",
+  "llms": "https://zod.dev/llms.txt",
+  "llmsFull": "https://zod.dev/llms-full.txt",
+  "mcpServer": "https://mcp.inkeep.com/zod/mcp",
+  "funding": "https://github.com/sponsors/colinhacks",
+  "sideEffects": false,
+  "files": [
+    "src",
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.cjs",
+    "**/*.d.ts",
+    "**/*.d.mts",
+    "**/*.d.cts",
+    "**/package.json"
+  ],
+  "keywords": [
+    "typescript",
+    "schema",
+    "validation",
+    "type",
+    "inference"
+  ],
+  "main": "./index.cjs",
+  "types": "./index.d.cts",
+  "module": "./index.js",
+  "zshy": {
+    "exports": {
+      "./package.json": "./package.json",
+      ".": "./src/index.ts",
+      "./mini": "./src/mini/index.ts",
+      "./locales": "./src/locales/index.ts",
+      "./v3": "./src/v3/index.ts",
+      "./v4": "./src/v4/index.ts",
+      "./v4-mini": "./src/v4-mini/index.ts",
+      "./v4/mini": "./src/v4/mini/index.ts",
+      "./v4/core": "./src/v4/core/index.ts",
+      "./v4/locales": "./src/v4/locales/index.ts",
+      "./v4/locales/*": "./src/v4/locales/*"
+    },
+    "conditions": {
+      "@zod/source": "src"
+    }
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@zod/source": "./src/index.ts",
+      "types": "./index.d.cts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
+    "./mini": {
+      "@zod/source": "./src/mini/index.ts",
+      "types": "./mini/index.d.cts",
+      "import": "./mini/index.js",
+      "require": "./mini/index.cjs"
+    },
+    "./locales": {
+      "@zod/source": "./src/locales/index.ts",
+      "types": "./locales/index.d.cts",
+      "import": "./locales/index.js",
+      "require": "./locales/index.cjs"
+    },
+    "./v3": {
+      "@zod/source": "./src/v3/index.ts",
+      "types": "./v3/index.d.cts",
+      "import": "./v3/index.js",
+      "require": "./v3/index.cjs"
+    },
+    "./v4": {
+      "@zod/source": "./src/v4/index.ts",
+      "types": "./v4/index.d.cts",
+      "import": "./v4/index.js",
+      "require": "./v4/index.cjs"
+    },
+    "./v4-mini": {
+      "@zod/source": "./src/v4-mini/index.ts",
+      "types": "./v4-mini/index.d.cts",
+      "import": "./v4-mini/index.js",
+      "require": "./v4-mini/index.cjs"
+    },
+    "./v4/mini": {
+      "@zod/source": "./src/v4/mini/index.ts",
+      "types": "./v4/mini/index.d.cts",
+      "import": "./v4/mini/index.js",
+      "require": "./v4/mini/index.cjs"
+    },
+    "./v4/core": {
+      "@zod/source": "./src/v4/core/index.ts",
+      "types": "./v4/core/index.d.cts",
+      "import": "./v4/core/index.js",
+      "require": "./v4/core/index.cjs"
+    },
+    "./v4/locales": {
+      "@zod/source": "./src/v4/locales/index.ts",
+      "types": "./v4/locales/index.d.cts",
+      "import": "./v4/locales/index.js",
+      "require": "./v4/locales/index.cjs"
+    },
+    "./v4/locales/*": {
+      "@zod/source": "./src/v4/locales/*",
+      "types": "./v4/locales/*",
+      "import": "./v4/locales/*",
+      "require": "./v4/locales/*"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/colinhacks/zod.git"
+  },
+  "bugs": {
+    "url": "https://github.com/colinhacks/zod/issues"
+  },
+  "support": {
+    "backing": {
+      "npm-funding": true
+    }
+  },
+  "scripts": {
+    "clean": "git clean -xdf . -e node_modules",
+    "build": "zshy --project tsconfig.build.json",
+    "postbuild": "tsx ../../scripts/write-stub-package-jsons.ts && pnpm biome check --write .",
+    "test:watch": "pnpm vitest",
+    "test": "pnpm vitest run",
+    "prepublishOnly": "tsx ../../scripts/check-versions.ts"
+  }
+}

package/node_modules/zod/src/mini/index.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";

package/node_modules/zod/src/v3/tests/complex.test.ts

@@ -0,0 +1,56 @@
+import { test } from "vitest";
+import * as z from "zod/v3";
+
+const crazySchema = z.object({
+  tuple: z.tuple([
+    z.string().nullable().optional(),
+    z.number().nullable().optional(),
+    z.boolean().nullable().optional(),
+    z.null().nullable().optional(),
+    z.undefined().nullable().optional(),
+    z.literal("1234").nullable().optional(),
+  ]),
+  merged: z
+    .object({
+      k1: z.string().optional(),
+    })
+    .merge(z.object({ k1: z.string().nullable(), k2: z.number() })),
+  union: z.array(z.union([z.literal("asdf"), z.literal(12)])).nonempty(),
+  array: z.array(z.number()),
+  // sumTransformer: z.transformer(z.array(z.number()), z.number(), (arg) => {
+  //   return arg.reduce((a, b) => a + b, 0);
+  // }),
+  sumMinLength: z.array(z.number()).refine((arg) => arg.length > 5),
+  intersection: z.intersection(z.object({ p1: z.string().optional() }), z.object({ p1: z.number().optional() })),
+  enum: z.intersection(z.enum(["zero", "one"]), z.enum(["one", "two"])),
+  nonstrict: z.object({ points: z.number() }).nonstrict(),
+  numProm: z.promise(z.number()),
+  lenfun: z.function(z.tuple([z.string()]), z.boolean()),
+});
+
+// const asyncCrazySchema = crazySchema.extend({
+//   // async_transform: z.transformer(
+//   //   z.array(z.number()),
+//   //   z.number(),
+//   //   async (arg) => {
+//   //     return arg.reduce((a, b) => a + b, 0);
+//   //   }
+//   // ),
+//   async_refine: z.array(z.number()).refine(async (arg) => arg.length > 5),
+// });
+
+test("parse", () => {
+  crazySchema.parse({
+    tuple: ["asdf", 1234, true, null, undefined, "1234"],
+    merged: { k1: "asdf", k2: 12 },
+    union: ["asdf", 12, "asdf", 12, "asdf", 12],
+    array: [12, 15, 16],
+    // sumTransformer: [12, 15, 16],
+    sumMinLength: [12, 15, 16, 98, 24, 63],
+    intersection: {},
+    enum: "one",
+    nonstrict: { points: 1234 },
+    numProm: Promise.resolve(12),
+    lenfun: (x: string) => x.length,
+  });
+});

package/node_modules/zod/src/v3/tests/function.test.ts

@@ -0,0 +1,257 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+const args1 = z.tuple([z.string()]);
+const returns1 = z.number();
+const func1 = z.function(args1, returns1);
+
+test("function parsing", () => {
+  const parsed = func1.parse((arg: any) => arg.length);
+  parsed("asdf");
+});
+
+test("parsed function fail 1", () => {
+  const parsed = func1.parse((x: string) => x);
+  expect(() => parsed("asdf")).toThrow();
+});
+
+test("parsed function fail 2", () => {
+  const parsed = func1.parse((x: string) => x);
+  expect(() => parsed(13 as any)).toThrow();
+});
+
+test("function inference 1", () => {
+  type func1 = z.TypeOf<typeof func1>;
+  util.assertEqual<func1, (k: string) => number>(true);
+});
+
+test("method parsing", () => {
+  const methodObject = z.object({
+    property: z.number(),
+    method: z.function().args(z.string()).returns(z.number()),
+  });
+  const methodInstance = {
+    property: 3,
+    method: function (s: string) {
+      return s.length + this.property;
+    },
+  };
+  const parsed = methodObject.parse(methodInstance);
+  expect(parsed.method("length=8")).toBe(11); // 8 length + 3 property
+});
+
+test("async method parsing", async () => {
+  const methodObject = z.object({
+    property: z.number(),
+    method: z.function().args(z.string()).returns(z.promise(z.number())),
+  });
+  const methodInstance = {
+    property: 3,
+    method: async function (s: string) {
+      return s.length + this.property;
+    },
+  };
+  const parsed = methodObject.parse(methodInstance);
+  expect(await parsed.method("length=8")).toBe(11); // 8 length + 3 property
+});
+
+test("args method", () => {
+  const t1 = z.function();
+  type t1 = z.infer<typeof t1>;
+  util.assertEqual<t1, (...args_1: unknown[]) => unknown>(true);
+
+  const t2 = t1.args(z.string());
+  type t2 = z.infer<typeof t2>;
+  util.assertEqual<t2, (arg: string, ...args_1: unknown[]) => unknown>(true);
+
+  const t3 = t2.returns(z.boolean());
+  type t3 = z.infer<typeof t3>;
+  util.assertEqual<t3, (arg: string, ...args_1: unknown[]) => boolean>(true);
+});
+
+const args2 = z.tuple([
+  z.object({
+    f1: z.number(),
+    f2: z.string().nullable(),
+    f3: z.array(z.boolean().optional()).optional(),
+  }),
+]);
+const returns2 = z.union([z.string(), z.number()]);
+
+const func2 = z.function(args2, returns2);
+
+test("function inference 2", () => {
+  type func2 = z.TypeOf<typeof func2>;
+  util.assertEqual<
+    func2,
+    (arg: {
+      f1: number;
+      f2: string | null;
+      f3?: (boolean | undefined)[] | undefined;
+    }) => string | number
+  >(true);
+});
+
+test("valid function run", () => {
+  const validFunc2Instance = func2.validate((_x) => {
+    return "adf" as any;
+  });
+
+  const checker = () => {
+    validFunc2Instance({
+      f1: 21,
+      f2: "asdf",
+      f3: [true, false],
+    });
+  };
+
+  checker();
+});
+
+test("input validation error", () => {
+  const invalidFuncInstance = func2.validate((_x) => {
+    return "adf" as any;
+  });
+
+  const checker = () => {
+    invalidFuncInstance("Invalid_input" as any);
+  };
+
+  expect(checker).toThrow();
+});
+
+test("output validation error", () => {
+  const invalidFuncInstance = func2.validate((_x) => {
+    return ["this", "is", "not", "valid", "output"] as any;
+  });
+
+  const checker = () => {
+    invalidFuncInstance({
+      f1: 21,
+      f2: "asdf",
+      f3: [true, false],
+    });
+  };
+
+  expect(checker).toThrow();
+});
+
+z.function(z.tuple([z.string()])).args()._def.args;
+
+test("special function error codes", () => {
+  const checker = z.function(z.tuple([z.string()]), z.boolean()).implement((arg) => {
+    return arg.length as any;
+  });
+  try {
+    checker("12" as any);
+  } catch (err) {
+    const zerr = err as z.ZodError;
+    const first = zerr.issues[0];
+    if (first.code !== z.ZodIssueCode.invalid_return_type) throw new Error();
+
+    expect(first.returnTypeError).toBeInstanceOf(z.ZodError);
+  }
+
+  try {
+    checker(12 as any);
+  } catch (err) {
+    const zerr = err as z.ZodError;
+    const first = zerr.issues[0];
+    if (first.code !== z.ZodIssueCode.invalid_arguments) throw new Error();
+    expect(first.argumentsError).toBeInstanceOf(z.ZodError);
+  }
+});
+
+test("function with async refinements", async () => {
+  const func = z
+    .function()
+    .args(z.string().refine(async (val) => val.length > 10))
+    .returns(z.promise(z.number().refine(async (val) => val > 10)))
+    .implement(async (val) => {
+      return val.length;
+    });
+  const results = [];
+  try {
+    await func("asdfasdf");
+    results.push("success");
+  } catch (_err) {
+    results.push("fail");
+  }
+  try {
+    await func("asdflkjasdflkjsf");
+    results.push("success");
+  } catch (_err) {
+    results.push("fail");
+  }
+
+  expect(results).toEqual(["fail", "success"]);
+});
+
+test("non async function with async refinements should fail", async () => {
+  const func = z
+    .function()
+    .args(z.string().refine(async (val) => val.length > 10))
+    .returns(z.number().refine(async (val) => val > 10))
+    .implement((val) => {
+      return val.length;
+    });
+
+  const results = [];
+  try {
+    await func("asdasdfasdffasdf");
+    results.push("success");
+  } catch (_err) {
+    results.push("fail");
+  }
+
+  expect(results).toEqual(["fail"]);
+});
+
+test("allow extra parameters", () => {
+  const maxLength5 = z
+    .function()
+    .args(z.string())
+    .returns(z.boolean())
+    .implement((str, _arg, _qewr) => {
+      return str.length <= 5;
+    });
+
+  const filteredList = ["apple", "orange", "pear", "banana", "strawberry"].filter(maxLength5);
+  expect(filteredList.length).toEqual(2);
+});
+
+test("params and returnType getters", () => {
+  const func = z.function().args(z.string()).returns(z.string());
+
+  func.parameters().items[0].parse("asdf");
+  func.returnType().parse("asdf");
+});
+
+test("inference with transforms", () => {
+  const funcSchema = z
+    .function()
+    .args(z.string().transform((val) => val.length))
+    .returns(z.object({ val: z.number() }));
+  const myFunc = funcSchema.implement((val) => {
+    return { val, extra: "stuff" };
+  });
+  myFunc("asdf");
+
+  util.assertEqual<typeof myFunc, (arg: string, ...args_1: unknown[]) => { val: number; extra: string }>(true);
+});
+
+test("fallback to OuterTypeOfFunction", () => {
+  const funcSchema = z
+    .function()
+    .args(z.string().transform((val) => val.length))
+    .returns(z.object({ arg: z.number() }).transform((val) => val.arg));
+
+  const myFunc = funcSchema.implement((val) => {
+    return { arg: val, arg2: false };
+  });
+
+  util.assertEqual<typeof myFunc, (arg: string, ...args_1: unknown[]) => number>(true);
+});

package/node_modules/zod/src/v3/tests/nan.test.ts

@@ -0,0 +1,21 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+const schema = z.nan();
+
+test("passing validations", () => {
+  schema.parse(Number.NaN);
+  schema.parse(Number("Not a number"));
+});
+
+test("failing validations", () => {
+  expect(() => schema.parse(5)).toThrow();
+  expect(() => schema.parse("John")).toThrow();
+  expect(() => schema.parse(true)).toThrow();
+  expect(() => schema.parse(null)).toThrow();
+  expect(() => schema.parse(undefined)).toThrow();
+  expect(() => schema.parse({})).toThrow();
+  expect(() => schema.parse([])).toThrow();
+});

package/node_modules/zod/src/v4/classic/checks.ts

@@ -0,0 +1,31 @@
+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,
+  type $RefinementCtx as RefinementCtx,
+} from "../core/index.js";

package/node_modules/zod/src/v4/classic/external.ts

@@ -0,0 +1,50 @@
+export * as core from "../core/index.js";
+export * from "./schemas.js";
+export * from "./checks.js";
+export * from "./errors.js";
+export * from "./parse.js";
+export * from "./compat.js";
+
+// zod-specified
+import { config } from "../core/index.js";
+import en from "../locales/en.js";
+config(en());
+
+export type { infer, output, input } from "../core/index.js";
+export {
+  globalRegistry,
+  type GlobalMeta,
+  registry,
+  config,
+  $output,
+  $input,
+  $brand,
+  clone,
+  regexes,
+  treeifyError,
+  prettifyError,
+  formatError,
+  flattenError,
+  toJSONSchema,
+  TimePrecision,
+  util,
+  NEVER,
+} from "../core/index.js";
+
+export * as locales from "../locales/index.js";
+
+// iso
+// must be exported from top-level
+// https://github.com/colinhacks/zod/issues/4491
+export { ZodISODateTime, ZodISODate, ZodISOTime, ZodISODuration } from "./iso.js";
+export * as iso from "./iso.js";
+
+// coerce
+export type {
+  ZodCoercedString,
+  ZodCoercedNumber,
+  ZodCoercedBigInt,
+  ZodCoercedBoolean,
+  ZodCoercedDate,
+} from "./coerce.js";
+export * as coerce from "./coerce.js";