zod 3.25.13 → 3.25.15

package/dist/v4/classic/tests/primitive.test.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+const literalStringSchema = z.literal("asdf");
+const literalNumberSchema = z.literal(12);
+const literalBooleanSchema = z.literal(true);
+const literalBigIntSchema = z.literal(BigInt(42));
+const stringSchema = z.string();
+const numberSchema = z.number();
+const bigintSchema = z.bigint();
+const booleanSchema = z.boolean();
+const dateSchema = z.date();
+const symbolSchema = z.symbol();
+const nullSchema = z.null();
+const undefinedSchema = z.undefined();
+const stringSchemaOptional = z.string().optional();
+const stringSchemaNullable = z.string().nullable();
+const numberSchemaOptional = z.number().optional();
+const numberSchemaNullable = z.number().nullable();
+const bigintSchemaOptional = z.bigint().optional();
+const bigintSchemaNullable = z.bigint().nullable();
+const booleanSchemaOptional = z.boolean().optional();
+const booleanSchemaNullable = z.boolean().nullable();
+const dateSchemaOptional = z.date().optional();
+const dateSchemaNullable = z.date().nullable();
+const symbolSchemaOptional = z.symbol().optional();
+const symbolSchemaNullable = z.symbol().nullable();
+(0, vitest_1.test)("literal string schema", () => {
+    (0, vitest_1.expect)(literalStringSchema.parse("asdf")).toBe("asdf");
+    (0, vitest_1.expect)(() => literalStringSchema.parse("not_asdf")).toThrow();
+    (0, vitest_1.expect)(() => literalStringSchema.parse(123)).toThrow();
+    (0, vitest_1.expect)(() => literalStringSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => literalStringSchema.parse({})).toThrow();
+});
+(0, vitest_1.test)("literal number schema", () => {
+    (0, vitest_1.expect)(literalNumberSchema.parse(12)).toBe(12);
+    (0, vitest_1.expect)(() => literalNumberSchema.parse(13)).toThrow();
+    (0, vitest_1.expect)(() => literalNumberSchema.parse("foo")).toThrow();
+    (0, vitest_1.expect)(() => literalNumberSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => literalNumberSchema.parse({})).toThrow();
+});
+(0, vitest_1.test)("literal boolean schema", () => {
+    (0, vitest_1.expect)(literalBooleanSchema.parse(true)).toBe(true);
+    (0, vitest_1.expect)(() => literalBooleanSchema.parse(false)).toThrow();
+    (0, vitest_1.expect)(() => literalBooleanSchema.parse("asdf")).toThrow();
+    (0, vitest_1.expect)(() => literalBooleanSchema.parse(123)).toThrow();
+    (0, vitest_1.expect)(() => literalBooleanSchema.parse({})).toThrow();
+});
+(0, vitest_1.test)("literal bigint schema", () => {
+    (0, vitest_1.expect)(literalBigIntSchema.parse(BigInt(42))).toBe(BigInt(42));
+    (0, vitest_1.expect)(() => literalBigIntSchema.parse(BigInt(43))).toThrow();
+    (0, vitest_1.expect)(() => literalBigIntSchema.parse("asdf")).toThrow();
+    (0, vitest_1.expect)(() => literalBigIntSchema.parse(123)).toThrow();
+    (0, vitest_1.expect)(() => literalBigIntSchema.parse({})).toThrow();
+});
+(0, vitest_1.test)("string schema", () => {
+    stringSchema.parse("foo");
+    (0, vitest_1.expect)(() => stringSchema.parse(Math.random())).toThrow();
+    (0, vitest_1.expect)(() => stringSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => stringSchema.parse(undefined)).toThrow();
+    (0, vitest_1.expect)(() => stringSchema.parse(null)).toThrow();
+});
+(0, vitest_1.test)("number schema", () => {
+    numberSchema.parse(Math.random());
+    (0, vitest_1.expect)(() => numberSchema.parse("foo")).toThrow();
+    (0, vitest_1.expect)(() => numberSchema.parse(BigInt(17))).toThrow();
+    (0, vitest_1.expect)(() => numberSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => numberSchema.parse(undefined)).toThrow();
+    (0, vitest_1.expect)(() => numberSchema.parse(null)).toThrow();
+});
+(0, vitest_1.test)("bigint schema", () => {
+    bigintSchema.parse(BigInt(17));
+    (0, vitest_1.expect)(() => bigintSchema.parse("foo")).toThrow();
+    (0, vitest_1.expect)(() => bigintSchema.parse(Math.random())).toThrow();
+    (0, vitest_1.expect)(() => bigintSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => bigintSchema.parse(undefined)).toThrow();
+    (0, vitest_1.expect)(() => bigintSchema.parse(null)).toThrow();
+});
+(0, vitest_1.test)("boolean schema", () => {
+    booleanSchema.parse(true);
+    (0, vitest_1.expect)(() => booleanSchema.parse("foo")).toThrow();
+    (0, vitest_1.expect)(() => booleanSchema.parse(Math.random())).toThrow();
+    (0, vitest_1.expect)(() => booleanSchema.parse(undefined)).toThrow();
+    (0, vitest_1.expect)(() => booleanSchema.parse(null)).toThrow();
+});
+(0, vitest_1.test)("date schema", async () => {
+    dateSchema.parse(new Date());
+    (0, vitest_1.expect)(() => dateSchema.parse("foo")).toThrow();
+    (0, vitest_1.expect)(() => dateSchema.parse(Math.random())).toThrow();
+    (0, vitest_1.expect)(() => dateSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => dateSchema.parse(undefined)).toThrow();
+    (0, vitest_1.expect)(() => dateSchema.parse(null)).toThrow();
+    (0, vitest_1.expect)(await dateSchema.safeParseAsync(new Date("invalid"))).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "expected": "date",
+        "code": "invalid_type",
+        "received": "Invalid Date",
+        "path": [],
+        "message": "Invalid input: expected date, received Date"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+(0, vitest_1.test)("symbol schema", () => {
+    symbolSchema.parse(Symbol("foo"));
+    (0, vitest_1.expect)(() => symbolSchema.parse("foo")).toThrow();
+    (0, vitest_1.expect)(() => symbolSchema.parse(Math.random())).toThrow();
+    (0, vitest_1.expect)(() => symbolSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => symbolSchema.parse(new Date())).toThrow();
+    (0, vitest_1.expect)(() => symbolSchema.parse(undefined)).toThrow();
+    (0, vitest_1.expect)(() => symbolSchema.parse(null)).toThrow();
+});
+(0, vitest_1.test)("undefined schema", () => {
+    undefinedSchema.parse(undefined);
+    (0, vitest_1.expect)(() => undefinedSchema.parse("foo")).toThrow();
+    (0, vitest_1.expect)(() => undefinedSchema.parse(Math.random())).toThrow();
+    (0, vitest_1.expect)(() => undefinedSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => undefinedSchema.parse(null)).toThrow();
+});
+(0, vitest_1.test)("null schema", () => {
+    nullSchema.parse(null);
+    (0, vitest_1.expect)(() => nullSchema.parse("foo")).toThrow();
+    (0, vitest_1.expect)(() => nullSchema.parse(Math.random())).toThrow();
+    (0, vitest_1.expect)(() => nullSchema.parse(true)).toThrow();
+    (0, vitest_1.expect)(() => nullSchema.parse(undefined)).toThrow();
+});
+(0, vitest_1.test)("primitive inference", () => {
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("get literal values", () => {
+    (0, vitest_1.expect)(literalStringSchema.values).toEqual(new Set(["asdf"]));
+    (0, vitest_1.expect)(literalStringSchema._zod.def.values).toEqual(["asdf"]);
+});

package/dist/v4/classic/tests/promise.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v4/classic/tests/promise.test.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+const promSchema = z.promise(z.object({
+    name: z.string(),
+    age: z.number(),
+}));
+(0, vitest_1.test)("promise inference", () => {
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.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 }));
+    (0, vitest_1.expect)(pr).toBeInstanceOf(Promise);
+    const result = await pr;
+    (0, vitest_1.expect)(result).toMatchInlineSnapshot(`
+    {
+      "age": 10,
+      "name": "Bobby",
+    }
+  `);
+});
+(0, vitest_1.test)("promise parsing fail", async () => {
+    const bad = await promSchema.safeParseAsync(Promise.resolve({ name: "Bobby", age: "10" }));
+    (0, vitest_1.expect)(bad.success).toBe(false);
+    (0, vitest_1.expect)(bad.error).toBeInstanceOf(z.ZodError);
+});
+(0, vitest_1.test)("promise parsing fail 2", async () => {
+    const result = await promSchema.safeParseAsync(Promise.resolve({ name: "Bobby", age: "10" }));
+    (0, vitest_1.expect)(result.success).toBe(false);
+    (0, vitest_1.expect)(result.error).toBeInstanceOf(z.ZodError);
+});
+(0, vitest_1.test)("promise parsing fail", () => {
+    const bad = () => promSchema.parse({ then: () => { }, catch: {} });
+    (0, vitest_1.expect)(bad).toThrow();
+});
+(0, vitest_1.test)("sync promise parsing", () => {
+    (0, vitest_1.expect)(() => z.promise(z.string()).parse(Promise.resolve("asfd"))).toThrow();
+});
+const asyncFunction = z.function({
+    input: z.tuple([]),
+    output: promSchema,
+});
+(0, vitest_1.test)("async function pass", async () => {
+    const validatedFunction = asyncFunction.implementAsync(async () => {
+        return { name: "jimmy", age: 14 };
+    });
+    await (0, vitest_1.expect)(validatedFunction()).resolves.toEqual({
+        name: "jimmy",
+        age: 14,
+    });
+});
+(0, vitest_1.test)("async function fail", async () => {
+    const validatedFunction = asyncFunction.implementAsync(() => {
+        return Promise.resolve("asdf");
+    });
+    await (0, vitest_1.expect)(validatedFunction()).rejects.toBeInstanceOf(z.core.$ZodError);
+});
+(0, vitest_1.test)("async promise parsing", () => {
+    const res = z.promise(z.number()).parseAsync(Promise.resolve(12));
+    (0, vitest_1.expect)(res).toBeInstanceOf(Promise);
+});
+(0, vitest_1.test)("resolves", () => {
+    const foo = z.literal("foo");
+    const res = z.promise(foo);
+    (0, vitest_1.expect)(res.unwrap()).toEqual(foo);
+});

package/dist/v4/classic/tests/readonly.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v4/classic/tests/readonly.test.js

@@ -0,0 +1,241 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v4"));
+var testEnum;
+(function (testEnum) {
+    testEnum[testEnum["A"] = 0] = "A";
+    testEnum[testEnum["B"] = 1] = "B";
+})(testEnum || (testEnum = {}));
+(0, vitest_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();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+// 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?: {};
+//               };
+//             };
+//           };
+//         };
+//       };
+//     }
+//   >>();
+// });
+(0, vitest_1.test)("object freezing", async () => {
+    (0, vitest_1.expect)(Object.isFrozen(z.array(z.string()).readonly().parse(["a"]))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.tuple([z.string(), z.number()]).readonly().parse(["a", 1]))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z
+        .map(z.string(), z.date())
+        .readonly()
+        .parse(new Map([["a", new Date()]])))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.record(z.string(), z.string()).readonly().parse({ a: "b" }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.record(z.string(), z.number()).readonly().parse({ a: 1 }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.object({ a: z.string(), 1: z.number() }).readonly().parse({ a: "b", 1: 2 }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z
+        .set(z.promise(z.string()))
+        .readonly()
+        .parseAsync(new Set([Promise.resolve("a")])))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
+});
+(0, vitest_1.test)("async object freezing", async () => {
+    (0, vitest_1.expect)(Object.isFrozen(await z.array(z.string()).readonly().parseAsync(["a"]))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.tuple([z.string(), z.number()]).readonly().parseAsync(["a", 1]))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z
+        .map(z.string(), z.date())
+        .readonly()
+        .parseAsync(new Map([["a", new Date()]])))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z
+        .set(z.promise(z.string()))
+        .readonly()
+        .parseAsync(new Set([Promise.resolve("a")])))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.record(z.string(), z.string()).readonly().parseAsync({ a: "b" }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.record(z.string(), z.number()).readonly().parseAsync({ a: 1 }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.object({ a: z.string(), 1: z.number() }).readonly().parseAsync({ a: "b", 1: 2 }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
+});
+(0, vitest_1.test)("readonly inference", () => {
+    const readonlyStringArray = z.string().array().readonly();
+    const readonlyStringTuple = z.tuple([z.string()]).readonly();
+    const deepReadonly = z.object({ a: z.string() }).readonly();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+});
+(0, vitest_1.test)("readonly parse", () => {
+    const schema = z.array(z.string()).readonly();
+    const readonlyArray = ["a", "b", "c"];
+    const mutableArray = ["a", "b", "c"];
+    const result1 = schema.parse(readonlyArray);
+    const result2 = schema.parse(mutableArray);
+    (0, vitest_1.expect)(result1).toEqual(readonlyArray);
+    (0, vitest_1.expect)(result2).toEqual(mutableArray);
+});
+(0, vitest_1.test)("readonly parse with tuples", () => {
+    const schema = z.tuple([z.string(), z.number()]).readonly();
+    schema.parse(["a", 1]);
+});
+(0, vitest_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();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    // expectTypeOf<z.infer<typeof readonlyFunction>>().toEqualTypeOf<
+    //   (args_0: string, args_1: number, ...args_2: unknown[]) => unknown
+    // >();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expectTypeOf)().toEqualTypeOf();
+    (0, vitest_1.expect)(readonlyString.parse("asdf")).toEqual("asdf");
+    (0, vitest_1.expect)(readonlyNumber1.parse(1234)).toEqual(1234);
+    (0, vitest_1.expect)(readonlyNumber2.parse(1234)).toEqual(1234);
+    const bigIntVal = BigInt(1);
+    (0, vitest_1.expect)(readonlyBigInt.parse(bigIntVal)).toEqual(bigIntVal);
+    (0, vitest_1.expect)(readonlyBoolean.parse(true)).toEqual(true);
+    const dateVal = new Date();
+    (0, vitest_1.expect)(readonlyDate.parse(new Date())).toEqual(dateVal);
+    (0, vitest_1.expect)(readonlyUndefined.parse(undefined)).toEqual(undefined);
+    (0, vitest_1.expect)(readonlyNull.parse(null)).toEqual(null);
+    (0, vitest_1.expect)(readonlyAny.parse("whatever")).toEqual("whatever");
+    (0, vitest_1.expect)(readonlyUnknown.parse("whatever")).toEqual("whatever");
+    (0, vitest_1.expect)(readonlyVoid.parse(undefined)).toEqual(undefined);
+    // expect(readonlyFunction.parse(() => void 0)).toEqual(() => void 0);
+    (0, vitest_1.expect)(readonlyStringArray.parse(["asdf"])).toEqual(["asdf"]);
+    (0, vitest_1.expect)(readonlyTuple.parse(["asdf", 1234])).toEqual(["asdf", 1234]);
+});

package/dist/v4/classic/tests/record.test.d.ts

@@ -0,0 +1 @@
+export {};