aws-runtime-bridge 1.9.71 → 1.9.72

package/package/cc-switch-sdk/node_modules/zod/src/v4/classic/tests/pickomit.test.ts

@@ -1,211 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const fish = z.object({
-  name: z.string(),
-  age: z.number(),
-  nested: z.object({}),
-});
-
-test("pick type inference", () => {
-  const nameonlyFish = fish.pick({ name: true });
-  type nameonlyFish = z.infer<typeof nameonlyFish>;
-  expectTypeOf<nameonlyFish>().toEqualTypeOf<{ name: string }>();
-});
-
-test("pick parse - success", () => {
-  const nameonlyFish = fish.pick({ name: true });
-  nameonlyFish.parse({ name: "bob" });
-
-  // @ts-expect-error checking runtime picks `name` only.
-  const anotherNameonlyFish = fish.pick({ name: true, age: false });
-  anotherNameonlyFish.parse({ name: "bob" });
-});
-
-test("pick parse - fail", () => {
-  fish.pick({ name: true }).parse({ name: "12" } as any);
-  fish.pick({ name: true }).parse({ name: "bob", age: 12 } as any);
-  fish.pick({ age: true }).parse({ age: 12 } as any);
-
-  const nameonlyFish = fish.pick({ name: true }).strict();
-  const bad1 = () => nameonlyFish.parse({ name: 12 } as any);
-  const bad2 = () => nameonlyFish.parse({ name: "bob", age: 12 } as any);
-  const bad3 = () => nameonlyFish.parse({ age: 12 } as any);
-
-  // @ts-expect-error checking runtime picks `name` only.
-  const anotherNameonlyFish = fish.pick({ name: true, age: false }).strict();
-  const bad4 = () => anotherNameonlyFish.parse({ name: "bob", age: 12 } as any);
-
-  expect(bad1).toThrow();
-  expect(bad2).toThrow();
-  expect(bad3).toThrow();
-  expect(bad4).toThrow();
-});
-
-test("pick - remove optional", () => {
-  const schema = z.object({ a: z.string(), b: z.string().optional() });
-  expect("a" in schema._zod.def.shape).toEqual(true);
-  expect("b" in schema._zod.def.shape!).toEqual(true);
-  const picked = schema.pick({ a: true });
-  expect("a" in picked._zod.def.shape).toEqual(true);
-  expect("b" in picked._zod.def.shape!).toEqual(false);
-});
-
-test("omit type inference", () => {
-  const nonameFish = fish.omit({ name: true });
-  type nonameFish = z.infer<typeof nonameFish>;
-
-  expectTypeOf<nonameFish>().toEqualTypeOf<{ age: number; nested: Record<string, never> }>();
-});
-
-test("omit parse - success", () => {
-  const nonameFish = fish.omit({ name: true });
-  nonameFish.parse({ age: 12, nested: {} });
-
-  // @ts-expect-error checking runtime omits `name` only.
-  const anotherNonameFish = fish.omit({ name: true, age: false });
-  anotherNonameFish.parse({ age: 12, nested: {} });
-});
-
-test("omit parse - fail", () => {
-  const nonameFish = fish.omit({ name: true });
-  const bad1 = () => nonameFish.parse({ name: 12 } as any);
-  const bad2 = () => nonameFish.parse({ age: 12 } as any);
-  const bad3 = () => nonameFish.parse({} as any);
-
-  // @ts-expect-error checking runtime omits `name` only.
-  const anotherNonameFish = fish.omit({ name: true, age: false });
-  const bad4 = () => anotherNonameFish.parse({ nested: {} } as any);
-
-  expect(bad1).toThrow();
-  expect(bad2).toThrow();
-  expect(bad3).toThrow();
-  expect(bad4).toThrow();
-});
-
-test("omit - remove optional", () => {
-  const schema = z.object({ a: z.string(), b: z.string().optional() });
-  expect("a" in schema._zod.def.shape).toEqual(true);
-  const omitted = schema.omit({ a: true });
-  expect("a" in omitted._zod.def.shape).toEqual(false);
-});
-
-test("nonstrict inference", () => {
-  const laxfish = fish.pick({ name: true }).catchall(z.any());
-  type laxfish = z.infer<typeof laxfish>;
-  expectTypeOf<laxfish>().toEqualTypeOf<{ name: string; [k: string]: any }>();
-});
-
-test("nonstrict parsing - pass", () => {
-  const laxfish = fish.passthrough().pick({ name: true });
-  laxfish.parse({ name: "asdf", whatever: "asdf" });
-  laxfish.parse({ name: "asdf", age: 12, nested: {} });
-});
-
-test("nonstrict parsing - fail", () => {
-  const laxfish = fish.passthrough().pick({ name: true });
-  const bad = () => laxfish.parse({ whatever: "asdf" } as any);
-  expect(bad).toThrow();
-});
-
-test("pick/omit/required/partial - do not allow unknown keys", () => {
-  const schema = z.object({
-    name: z.string(),
-    age: z.number(),
-  });
-
-  // Mixed valid + invalid keys
-  // @ts-expect-error
-  expect(() => schema.pick({ name: true, asdf: true }).safeParse({})).toThrow();
-  // @ts-expect-error
-  expect(() => schema.omit({ name: true, asdf: true }).safeParse({})).toThrow();
-  // @ts-expect-error
-  expect(() => schema.partial({ name: true, asdf: true }).safeParse({})).toThrow();
-  // @ts-expect-error
-  expect(() => schema.required({ name: true, asdf: true }).safeParse({})).toThrow();
-
-  // Only invalid keys
-  // @ts-expect-error
-  expect(() => schema.pick({ $unknown: true }).safeParse({})).toThrow();
-  // @ts-expect-error
-  expect(() => schema.omit({ $unknown: true }).safeParse({})).toThrow();
-  // @ts-expect-error
-  expect(() => schema.required({ $unknown: true }).safeParse({})).toThrow();
-  // @ts-expect-error
-  expect(() => schema.partial({ $unknown: true }).safeParse({})).toThrow();
-});
-
-test("pick - throws error on schema with refinements", () => {
-  const baseSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    items: z.string().array(),
-  });
-
-  const refinedSchema = baseSchema.superRefine((val, ctx) => {
-    if (val.items.length === 0) {
-      ctx.addIssue({
-        message: "Must have at least one item",
-        code: "custom",
-        path: ["items"],
-      });
-    }
-  });
-
-  expect(() => refinedSchema.pick({ name: true })).toThrow(
-    ".pick() cannot be used on object schemas containing refinements"
-  );
-});
-
-test("omit - throws error on schema with refinements", () => {
-  const baseSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    items: z.string().array(),
-  });
-
-  const refinedSchema = baseSchema.superRefine((val, ctx) => {
-    if (val.items.length === 0) {
-      ctx.addIssue({
-        message: "Must have at least one item",
-        code: "custom",
-        path: ["items"],
-      });
-    }
-  });
-
-  expect(() => refinedSchema.omit({ id: true })).toThrow(
-    ".omit() cannot be used on object schemas containing refinements"
-  );
-});
-
-test("pick - throws error on schema with refine", () => {
-  const baseSchema = z.object({
-    password: z.string(),
-    confirmPassword: z.string(),
-  });
-
-  const refinedSchema = baseSchema.refine((data) => data.password === data.confirmPassword, {
-    message: "Passwords must match",
-  });
-
-  expect(() => refinedSchema.pick({ password: true })).toThrow(
-    ".pick() cannot be used on object schemas containing refinements"
-  );
-});
-
-test("omit - throws error on schema with refine", () => {
-  const baseSchema = z.object({
-    password: z.string(),
-    confirmPassword: z.string(),
-    email: z.string(),
-  });
-
-  const refinedSchema = baseSchema.refine((data) => data.password === data.confirmPassword, {
-    message: "Passwords must match",
-  });
-
-  expect(() => refinedSchema.omit({ email: true })).toThrow(
-    ".omit() cannot be used on object schemas containing refinements"
-  );
-});

package/package/cc-switch-sdk/node_modules/zod/src/v4/classic/tests/promise.test.ts

@@ -1,81 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-const promSchema = z.promise(
-  z.object({
-    name: z.string(),
-    age: z.number(),
-  })
-);
-
-test("promise inference", () => {
-  type promSchemaType = z.infer<typeof promSchema>;
-  expectTypeOf<promSchemaType>().toEqualTypeOf<Promise<{ name: string; age: number }>>();
-});
-
-test("promise parsing success", async () => {
-  // expect(() => promSchema.parse(Promise.resolve({ name: "Bobby", age: 10 }))).toThrow();
-  const pr = promSchema.parseAsync(Promise.resolve({ name: "Bobby", age: 10 }));
-  expect(pr).toBeInstanceOf(Promise);
-  const result = await pr;
-  expect(result).toMatchInlineSnapshot(`
-    {
-      "age": 10,
-      "name": "Bobby",
-    }
-  `);
-});
-
-test("promise parsing fail", async () => {
-  const bad = await promSchema.safeParseAsync(Promise.resolve({ name: "Bobby", age: "10" }));
-  expect(bad.success).toBe(false);
-  expect(bad.error).toBeInstanceOf(z.ZodError);
-});
-
-test("promise parsing fail 2", async () => {
-  const result = await promSchema.safeParseAsync(Promise.resolve({ name: "Bobby", age: "10" }));
-  expect(result.success).toBe(false);
-  expect(result.error).toBeInstanceOf(z.ZodError);
-});
-
-test("promise parsing fail", () => {
-  const bad = () => promSchema.parse({ then: () => {}, catch: {} });
-  expect(bad).toThrow();
-});
-
-test("sync promise parsing", () => {
-  expect(() => z.promise(z.string()).parse(Promise.resolve("asfd"))).toThrow();
-});
-
-const asyncFunction = z.function({
-  input: z.tuple([]),
-  output: promSchema,
-});
-
-test("async function pass", async () => {
-  const validatedFunction = asyncFunction.implementAsync(async () => {
-    return { name: "jimmy", age: 14 };
-  });
-  await expect(validatedFunction()).resolves.toEqual({
-    name: "jimmy",
-    age: 14,
-  });
-});
-
-test("async function fail", async () => {
-  const validatedFunction = asyncFunction.implementAsync(() => {
-    return Promise.resolve("asdf" as any);
-  });
-  await expect(validatedFunction()).rejects.toBeInstanceOf(z.core.$ZodError);
-});
-
-test("async promise parsing", () => {
-  const res = z.promise(z.number()).parseAsync(Promise.resolve(12));
-  expect(res).toBeInstanceOf(Promise);
-});
-
-test("resolves", () => {
-  const foo = z.literal("foo");
-  const res = z.promise(foo);
-  expect(res.unwrap()).toEqual(foo);
-});

package/package/cc-switch-sdk/node_modules/zod/src/v4/classic/tests/readonly.test.ts

@@ -1,252 +0,0 @@
-import { expect, expectTypeOf, test } from "vitest";
-import * as z from "zod/v4";
-
-enum testEnum {
-  A = 0,
-  B = 1,
-}
-
-test("flat inference", () => {
-  const readonlyString = z.string().readonly();
-  const readonlyNumber = z.number().readonly();
-  const readonlyNaN = z.nan().readonly();
-  const readonlyBigInt = z.bigint().readonly();
-  const readonlyBoolean = z.boolean().readonly();
-  const readonlyDate = z.date().readonly();
-  const readonlyUndefined = z.undefined().readonly();
-  const readonlyNull = z.null().readonly();
-  const readonlyAny = z.any().readonly();
-  const readonlyUnknown = z.unknown().readonly();
-  const readonlyVoid = z.void().readonly();
-  const readonlyStringArray = z.array(z.string()).readonly();
-  const readonlyTuple = z.tuple([z.string(), z.number()]).readonly();
-  const readonlyMap = z.map(z.string(), z.date()).readonly();
-  const readonlySet = z.set(z.string()).readonly();
-  const readonlyStringRecord = z.record(z.string(), z.string()).readonly();
-  const readonlyNumberRecord = z.record(z.string(), z.number()).readonly();
-  const readonlyObject = z.object({ a: z.string(), 1: z.number() }).readonly();
-  const readonlyEnum = z.nativeEnum(testEnum).readonly();
-  const readonlyPromise = z.promise(z.string()).readonly();
-
-  expectTypeOf<typeof readonlyString._output>().toEqualTypeOf<string>();
-  expectTypeOf<typeof readonlyNumber._output>().toEqualTypeOf<number>();
-  expectTypeOf<typeof readonlyNaN._output>().toEqualTypeOf<number>();
-  expectTypeOf<typeof readonlyBigInt._output>().toEqualTypeOf<bigint>();
-  expectTypeOf<typeof readonlyBoolean._output>().toEqualTypeOf<boolean>();
-  expectTypeOf<typeof readonlyDate._output>().toEqualTypeOf<Date>();
-  expectTypeOf<typeof readonlyUndefined._output>().toEqualTypeOf<undefined>();
-  expectTypeOf<typeof readonlyNull._output>().toEqualTypeOf<null>();
-  expectTypeOf<typeof readonlyAny._output>().toEqualTypeOf<any>();
-  expectTypeOf<typeof readonlyUnknown._output>().toEqualTypeOf<Readonly<unknown>>();
-  expectTypeOf<typeof readonlyVoid._output>().toEqualTypeOf<void>();
-  expectTypeOf<typeof readonlyStringArray._output>().toEqualTypeOf<readonly string[]>();
-  expectTypeOf<typeof readonlyTuple._output>().toEqualTypeOf<readonly [string, number]>();
-  expectTypeOf<typeof readonlyMap._output>().toEqualTypeOf<ReadonlyMap<string, Date>>();
-  expectTypeOf<typeof readonlySet._output>().toEqualTypeOf<ReadonlySet<string>>();
-  expectTypeOf<typeof readonlyStringRecord._output>().toEqualTypeOf<Readonly<Record<string, string>>>();
-  expectTypeOf<typeof readonlyNumberRecord._output>().toEqualTypeOf<Readonly<Record<string, number>>>();
-  expectTypeOf<typeof readonlyObject._output>().toEqualTypeOf<{ readonly a: string; readonly 1: number }>();
-  expectTypeOf<typeof readonlyEnum._output>().toEqualTypeOf<Readonly<testEnum>>();
-  expectTypeOf<typeof readonlyPromise._output>().toEqualTypeOf<Promise<string>>();
-});
-
-// test("deep inference", () => {
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[0]>>().toEqualTypeOf<string>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[1]>>().toEqualTypeOf<number>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[2]>>().toEqualTypeOf<number>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[3]>>().toEqualTypeOf<bigint>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[4]>>().toEqualTypeOf<boolean>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[5]>>().toEqualTypeOf<Date>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[6]>>().toEqualTypeOf<undefined>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[7]>>().toEqualTypeOf<null>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[8]>>().toEqualTypeOf<any>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[9]>
-//   >().toEqualTypeOf<Readonly<unknown>>();
-//   expectTypeOf<z.infer<(typeof deepReadonlySchemas_0)[10]>>().toEqualTypeOf<void>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[11]>
-//   >().toEqualTypeOf<(args_0: string, args_1: number, ...args_2: unknown[]) => unknown>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[12]>
-//   >().toEqualTypeOf<readonly string[]>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[13]>
-//   >().toEqualTypeOf<readonly [string, number]>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[14]>
-//   >().toEqualTypeOf<ReadonlyMap<string, Date>>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[15]>
-//   >().toEqualTypeOf<ReadonlySet<Promise<string>>>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[16]>
-//   >().toEqualTypeOf<Readonly<Record<string, string>>>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[17]>
-//   >().toEqualTypeOf<Readonly<Record<string, number>>>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[18]>
-//   >().toEqualTypeOf<{ readonly a: string; readonly 1: number }>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[19]>
-//   >().toEqualTypeOf<Readonly<testEnum>>();
-//   expectTypeOf<
-//     z.infer<(typeof deepReadonlySchemas_0)[20]>
-//   >().toEqualTypeOf<Promise<string>>();
-
-//   expectTypeOf<
-//     z.infer<typeof crazyDeepReadonlySchema>
-//   >().toEqualTypeOf<ReadonlyMap<
-//     ReadonlySet<readonly [string, number]>,
-//     {
-//       readonly a: {
-//         readonly [x: string]: readonly any[];
-//       };
-//       readonly b: {
-//         readonly c: {
-//           readonly d: {
-//             readonly e: {
-//               readonly f: {
-//                 readonly g?: {};
-//               };
-//             };
-//           };
-//         };
-//       };
-//     }
-//   >>();
-// });
-
-test("object freezing", async () => {
-  expect(Object.isFrozen(z.array(z.string()).readonly().parse(["a"]))).toBe(true);
-  expect(Object.isFrozen(z.tuple([z.string(), z.number()]).readonly().parse(["a", 1]))).toBe(true);
-  expect(
-    Object.isFrozen(
-      z
-        .map(z.string(), z.date())
-        .readonly()
-        .parse(new Map([["a", new Date()]]))
-    )
-  ).toBe(true);
-
-  expect(Object.isFrozen(z.record(z.string(), z.string()).readonly().parse({ a: "b" }))).toBe(true);
-  expect(Object.isFrozen(z.record(z.string(), z.number()).readonly().parse({ a: 1 }))).toBe(true);
-  expect(Object.isFrozen(z.object({ a: z.string(), 1: z.number() }).readonly().parse({ a: "b", 1: 2 }))).toBe(true);
-  expect(
-    Object.isFrozen(
-      await z
-        .set(z.promise(z.string()))
-        .readonly()
-        .parseAsync(new Set([Promise.resolve("a")]))
-    )
-  ).toBe(true);
-  expect(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
-});
-
-test("async object freezing", async () => {
-  expect(Object.isFrozen(await z.array(z.string()).readonly().parseAsync(["a"]))).toBe(true);
-  expect(Object.isFrozen(await z.tuple([z.string(), z.number()]).readonly().parseAsync(["a", 1]))).toBe(true);
-  expect(
-    Object.isFrozen(
-      await z
-        .map(z.string(), z.date())
-        .readonly()
-        .parseAsync(new Map([["a", new Date()]]))
-    )
-  ).toBe(true);
-  expect(
-    Object.isFrozen(
-      await z
-        .set(z.promise(z.string()))
-        .readonly()
-        .parseAsync(new Set([Promise.resolve("a")]))
-    )
-  ).toBe(true);
-  expect(Object.isFrozen(await z.record(z.string(), z.string()).readonly().parseAsync({ a: "b" }))).toBe(true);
-  expect(Object.isFrozen(await z.record(z.string(), z.number()).readonly().parseAsync({ a: 1 }))).toBe(true);
-  expect(
-    Object.isFrozen(await z.object({ a: z.string(), 1: z.number() }).readonly().parseAsync({ a: "b", 1: 2 }))
-  ).toBe(true);
-  expect(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
-});
-
-test("readonly inference", () => {
-  const readonlyStringArray = z.string().array().readonly();
-  const readonlyStringTuple = z.tuple([z.string()]).readonly();
-  const deepReadonly = z.object({ a: z.string() }).readonly();
-
-  type readonlyStringArray = z.infer<typeof readonlyStringArray>;
-  type readonlyStringTuple = z.infer<typeof readonlyStringTuple>;
-  type deepReadonly = z.infer<typeof deepReadonly>;
-
-  expectTypeOf<readonlyStringArray>().toEqualTypeOf<readonly string[]>();
-  expectTypeOf<readonlyStringTuple>().toEqualTypeOf<readonly [string]>();
-  expectTypeOf<deepReadonly>().toEqualTypeOf<{ readonly a: string }>();
-});
-
-test("readonly parse", () => {
-  const schema = z.array(z.string()).readonly();
-  const readonlyArray = ["a", "b", "c"] as const;
-  const mutableArray = ["a", "b", "c"];
-  const result1 = schema.parse(readonlyArray);
-  const result2 = schema.parse(mutableArray);
-  expect(result1).toEqual(readonlyArray);
-  expect(result2).toEqual(mutableArray);
-});
-
-test("readonly parse with tuples", () => {
-  const schema = z.tuple([z.string(), z.number()]).readonly();
-  schema.parse(["a", 1]);
-});
-
-test("readonly and the get method", () => {
-  const readonlyString = z.string().readonly();
-  const readonlyNumber1 = z.number().readonly();
-  const readonlyNumber2 = z.number().readonly();
-  const readonlyBigInt = z.bigint().readonly();
-  const readonlyBoolean = z.boolean().readonly();
-  const readonlyDate = z.date().readonly();
-  const readonlyUndefined = z.undefined().readonly();
-  const readonlyNull = z.null().readonly();
-  const readonlyAny = z.any().readonly();
-  const readonlyUnknown = z.unknown().readonly();
-  const readonlyVoid = z.void().readonly();
-  // const readonlyFunction = z.function(z.tuple([z.string(), z.number()]), z.unknown()).readonly();
-  const readonlyStringArray = z.string().array().readonly();
-  const readonlyTuple = z.tuple([z.string(), z.number()]).readonly();
-
-  expectTypeOf<z.infer<typeof readonlyString>>().toEqualTypeOf<string>();
-  expectTypeOf<z.infer<typeof readonlyNumber1>>().toEqualTypeOf<number>();
-  expectTypeOf<z.infer<typeof readonlyNumber2>>().toEqualTypeOf<number>();
-  expectTypeOf<z.infer<typeof readonlyBigInt>>().toEqualTypeOf<bigint>();
-  expectTypeOf<z.infer<typeof readonlyBoolean>>().toEqualTypeOf<boolean>();
-  expectTypeOf<z.infer<typeof readonlyDate>>().toEqualTypeOf<Date>();
-  expectTypeOf<z.infer<typeof readonlyUndefined>>().toEqualTypeOf<undefined>();
-  expectTypeOf<z.infer<typeof readonlyNull>>().toEqualTypeOf<null>();
-  expectTypeOf<z.infer<typeof readonlyAny>>().toEqualTypeOf<any>();
-  expectTypeOf<z.infer<typeof readonlyUnknown>>().toEqualTypeOf<Readonly<unknown>>();
-  expectTypeOf<z.infer<typeof readonlyVoid>>().toEqualTypeOf<void>();
-  // expectTypeOf<z.infer<typeof readonlyFunction>>().toEqualTypeOf<
-  //   (args_0: string, args_1: number, ...args_2: unknown[]) => unknown
-  // >();
-  expectTypeOf<z.infer<typeof readonlyStringArray>>().toEqualTypeOf<readonly string[]>();
-  expectTypeOf<z.infer<typeof readonlyTuple>>().toEqualTypeOf<readonly [string, number]>();
-
-  expect(readonlyString.parse("asdf")).toEqual("asdf");
-  expect(readonlyNumber1.parse(1234)).toEqual(1234);
-  expect(readonlyNumber2.parse(1234)).toEqual(1234);
-  const bigIntVal = BigInt(1);
-  expect(readonlyBigInt.parse(bigIntVal)).toEqual(bigIntVal);
-  expect(readonlyBoolean.parse(true)).toEqual(true);
-  const dateVal = new Date();
-  expect(readonlyDate.parse(dateVal)).toEqual(dateVal);
-  expect(readonlyUndefined.parse(undefined)).toEqual(undefined);
-  expect(readonlyNull.parse(null)).toEqual(null);
-  expect(readonlyAny.parse("whatever")).toEqual("whatever");
-  expect(readonlyUnknown.parse("whatever")).toEqual("whatever");
-  expect(readonlyVoid.parse(undefined)).toEqual(undefined);
-  // expect(readonlyFunction.parse(() => void 0)).toEqual(() => void 0);
-  expect(readonlyStringArray.parse(["asdf"])).toEqual(["asdf"]);
-  expect(readonlyTuple.parse(["asdf", 1234])).toEqual(["asdf", 1234]);
-});