zod 3.11.6 → 3.13.0

package/README.md

@@ -8,21 +8,29 @@
 <a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
 <a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/zod" alt="stars"></a>
 <a href="./src/__tests__" rel="nofollow"><img src="./coverage.svg" alt="coverage"></a>
-
+<a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
 </p>
 <p align="center">
-by [@colinhacks](https://twitter.com/colinhacks)
+by <a href="https://twitter.com/colinhacks">@colinhacks</a>
 </p>
 
-> Hi! Colin here, creator of Zod. I hope you find it easy to use and powerful enough for all your use cases. If you have any issues or suggestions, please  [open an issue](https://github.com/colinhacks/zod/issues/new)! 
+> Hi! Colin here, creator of Zod. I hope you find it easy to use and powerful enough for all your use cases. If you have any issues or suggestions, please [open an issue](https://github.com/colinhacks/zod/issues/new)!
 >
 > If you like typesafety, check out my other library [tRPC](https://trpc.io). It works in concert with Zod to provide a seamless way to build end-to-end typesafe APIs without GraphQL or code generation — just TypeScript.
 >
 > Colin (AKA [@colinhacks](https://twitter.com/colinhacks))
 
+<h3 align="center">
+    <a href="https://discord.gg/RcG33DQJdf">💬 Chat on Discord</a>
+    ·
+    <a href="https://zod.js.org/">📝 Explore the Docs</a>
+    ·
+    <a href="https://www.npmjs.com/package/zod">✨ Install Zod</a>
+</h3>
+
 <br/>
 
-This docs have been translated into [Chinese](./README_ZH.md).
+These docs have been translated into [Chinese](./README_ZH.md).
 
 # Table of contents
 
@@ -36,9 +44,9 @@ This docs have been translated into [Chinese](./README_ZH.md).
   - [Strings](#strings)
   - [Numbers](#numbers)
   - [Booleans](#booleans)
-  - [Enums](#enums)
-    - [Zod enums](#zod-enums)
-    - [Native enums](#native-enums)
+  - [Dates](#dates)
+  - [Zod enums](#zod-enums)
+  - [Native enums](#native-enums)
   - [Optionals](#optionals)
   - [Nullables](#nullables)
   - [Objects](#objects)
@@ -53,6 +61,7 @@ This docs have been translated into [Chinese](./README_ZH.md).
     - [.strip](#strip)
     - [.catchall](#catchall)
   - [Arrays](#arrays)
+    - [.element](#element)
     - [.nonempty](#nonempty)
     - [.min/.max/.length](#minmaxlength)
   - [Tuples](#tuples)
@@ -60,6 +69,7 @@ This docs have been translated into [Chinese](./README_ZH.md).
   - [Maps](#maps)
   - [Sets](#sets)
   - [Unions](#unions)
+    - [Discriminated Unions](#discriminated-unions)
   - [Recursive types](#recursive-types)
     - [JSON type](#json-type)
     - [Cyclical data](#cyclical-objects)
@@ -105,7 +115,7 @@ Some other great aspects:
 - Zero dependencies
 - Works in Node.js and browsers (including IE 11)
 - Tiny: 8kb minified + zipped
-- Immutable: methods (i.e. `.optional()` return a new instance
+- Immutable: methods (i.e. `.optional()`) return a new instance
 - Concise, chainable interface
 - Functional approach: [parse, don't validate](https://lexi-lambda.github.io/blog/2019/11/05/parse-don-t-validate/)
 - Works with plain JavaScript too! You don't need to use TypeScript.
@@ -147,7 +157,7 @@ Sponsorship at any level is appreciated and encouraged. Zod is maintained by a s
       <span>creator of <a href="https://blitzjs.com">Blitz.js</a></span>
       <br />
     </td>
-    
+
   </tr>
   <tr>
     <td align="center">
@@ -215,6 +225,7 @@ There are a growing number of tools that are built atop or support Zod natively!
 
 - [`tRPC`](https://github.com/trpc/trpc): Build end-to-end typesafe APIs without GraphQL.
 - [`ts-to-zod`](https://github.com/fabien0102/ts-to-zod): Convert TypeScript definitions into Zod schemas.
+- [`zod-to-ts`](https://github.com/sachinraja/zod-to-ts): Generate TypeScript definitions from Zod schemas.
 - [`@anatine/zod-openapi`](https://github.com/anatine/zod-plugins/tree/main/libs/zod-openapi): Converts a Zod schema to an OpenAPI v3.x `SchemaObject`.
 - [`@anatine/zod-mock`](https://github.com/anatine/zod-plugins/tree/main/libs/zod-mock): Generate mock data from a Zod schema. Powered by [faker.js](https://github.com/Marak/Faker.js).
 - [`@anatine/zod-nestjs`](https://github.com/anatine/zod-plugins/tree/main/libs/zod-nestjs): Helper methods for using Zod in a NestJS project.
@@ -223,13 +234,17 @@ There are a growing number of tools that are built atop or support Zod natively!
 - [`zod-endpoints`](https://github.com/flock-community/zod-endpoints): Contract-first strictly typed endpoints with Zod. OpenAPI compatible.
 - [`express-zod-api`](https://github.com/RobinTail/express-zod-api): Build Express-based APIs with I/O schema validation and custom middlewares.
 - [`zod-to-json-schema`](https://github.com/StefanTerdell/zod-to-json-schema): Convert your Zod schemas into [JSON Schemas](https://json-schema.org/).
+- [`json-schema-to-zod`](https://github.com/StefanTerdell/json-schema-to-zod): Convert your [JSON Schemas](https://json-schema.org/) into Zod schemas. Use it live [here](https://StefanTerdell.github.io/json-schema-to-zod-react/).
 - [`json-to-zod`](https://github.com/rsinohara/json-to-zod): Convert JSON objects into Zod schemas. Use it live [here](https://rsinohara.github.io/json-to-zod-react/).
 - [`zod-dto`](https://github.com/kbkk/abitia/tree/master/packages/zod-dto): Generate Nest.js DTOs from a Zod schema.
+- [`soly`](https://github.com/mdbetancourt/soly): Create CLI applications with zod.
+- [`graphql-codegen-typescript-validation-schema`](https://github.com/Code-Hex/graphql-codegen-typescript-validation-schema): GraphQL Code Generator plugin to generate form validation schema from your GraphQL schema
+- [`zod-prisma`](https://github.com/CarterGrimmeisen/zod-prisma): Generate Zod schemas from your Prisma schema.
 
 ### Form integrations
 
 - [`react-hook-form`](https://github.com/react-hook-form/resolvers#zod): A first-party Zod resolver for React Hook Form
-- [`formik`](https://github.com/robertLichtnow/zod-formik-adapter): A community-maintained Formik adapter for Zod
+- [`zod-formik-adapter`](https://github.com/robertLichtnow/zod-formik-adapter): A community-maintained Formik adapter for Zod
 
 # Basic usage
 
@@ -310,15 +325,6 @@ tuna.value; // "tuna"
 
 ## Strings
 
-You can customize certain errors when creating a string schema.
-
-```ts
-const name = z.string({
-  required: "Name is required",
-  invalid: "Invalid name",
-});
-```
-
 Zod includes a handful of string-specific validations.
 
 ```ts
@@ -408,11 +414,30 @@ const isActive = z.boolean({
 });
 ```
 
-## Enums
+## Dates
+z.date() accepts a date, not a date string
+```ts
+z.date().safeParse( new Date() ) // success: true
+z.date().safeParse( '2022-01-12T00:00:00.000Z' ) // success: false
+```
 
-There are two ways to define enums in Zod.
+To allow for dates or date strings, you can use preprocess
+```ts
+const dateSchema = z.preprocess(
+    arg => {
+        if ( typeof arg == 'string' || arg instanceof Date )
+            return new Date( arg )
+    },
+    z.date()
+)
+type DateSchema = z.infer<typeof dateSchema>
+// type DateSchema = Date
 
-### Zod enums
+dateSchema.safeParse( new Date( '1/12/22' ) ) // success: true
+dateSchema.safeParse( '2022-01-12T00:00:00.000Z' ) // success: true
+```
+
+## Zod enums
 
 ```ts
 const FishEnum = z.enum(["Salmon", "Tuna", "Trout"]);
@@ -420,22 +445,20 @@ type FishEnum = z.infer<typeof FishEnum>;
 // 'Salmon' | 'Tuna' | 'Trout'
 ```
 
-You must pass the array of values directly into `z.enum()`. Alternatively, use `as const` to define your enum values as a tuple of strings. See the [const assertion docs](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) for details.
+`z.enum` is a Zod-native way to declare a schema with a fixed set of allowable _string_ values. Pass the array of values directly into `z.enum()`. Alternatively, use `as const` to define your enum values as a tuple of strings. See the [const assertion docs](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-4.html#const-assertions) for details.
 
 ```ts
 const VALUES = ["Salmon", "Tuna", "Trout"] as const;
 const FishEnum = z.enum(VALUES);
 ```
 
-This is not allowed:
+This is not allowed, since Zod isn't able to infer the exact values of each elements.
 
 ```ts
 const fish = ["Salmon", "Tuna", "Trout"];
 const FishEnum = z.enum(fish);
 ```
 
-In that case, the inferred type of `fish` is simply `string[]`, so Zod isn't able to infer the individual enum elements.
-
 **Autocompletion**
 
 To get autocompletion with a Zod enum, use the `.enum` property of your schema:
@@ -444,12 +467,12 @@ To get autocompletion with a Zod enum, use the `.enum` property of your schema:
 FishEnum.enum.Salmon; // => autocompletes
 
 FishEnum.enum;
-/* 
+/*
 => {
   Salmon: "Salmon",
   Tuna: "Tuna",
   Trout: "Trout",
-} 
+}
 */
 ```
 
@@ -459,7 +482,7 @@ You can also retrieve the list of options as a tuple with the `.options` propert
 FishEnum.options; // ["Salmon", "Tuna", "Trout"]);
 ```
 
-### Native enums
+## Native enums
 
 Zod enums are the recommended approach to defining and validating enums. But if you need to validate against an enum from a third-party library (or you don't want to rewrite your existing enums) you can use `z.nativeEnum()` .
 
@@ -684,11 +707,11 @@ You can also specify which properties to make optional:
 const optionalEmail = user.partial({
   email: true,
 });
-/* 
-{ 
-  email?: string | undefined; 
+/*
+{
+  email?: string | undefined;
   username: string
-} 
+}
 */
 ```
 
@@ -708,9 +731,9 @@ const user = z.object({
 
 const deepPartialUser = user.deepPartial();
 
-/* 
+/*
 {
-  username?: string | undefined, 
+  username?: string | undefined,
   location?: {
     latitude?: number | undefined;
     longitude?: number | undefined;
@@ -814,6 +837,14 @@ z.string().optional().array(); // (string | undefined)[]
 z.string().array().optional(); // string[] | undefined
 ```
 
+### `.element`
+
+Use `.element` to access the schema for an element of the array.
+
+```ts
+stringArray.element; // => string schema
+```
+
 ### `.nonempty`
 
 If you want to ensure that an array contains at least one element, use `.nonempty()`.
@@ -882,6 +913,25 @@ For convenience, you can also use the `.or` method:
 const stringOrNumber = z.string().or(z.number());
 ```
 
+### Discriminated unions
+
+If the union consists of object schemas all identifiable by a common property, it is possible to use
+the `z.discriminatedUnion` method.
+
+The advantage is in more efficient evaluation and more human friendly errors. With the basic union method the input is
+tested against each of the provided "options", and in the case of invalidity, issues for all the "options" are shown in
+the zod error. On the other hand, the discriminated union allows for selecting just one of the "options", testing
+against it, and showing only the issues related to this "option".
+
+```ts
+const item = z
+  .discriminatedUnion("type", [
+    z.object({ type: z.literal("a"), a: z.string() }),
+    z.object({ type: z.literal("b"), b: z.string() }),
+  ])
+  .parse({ type: "a", a: "abc" });
+```
+
 ## Records
 
 Record schemas are used to validate types such as `{ [k: string]: number }`.
@@ -936,15 +986,24 @@ Since Zod is trying to bridge the gap between static and runtime types, it doesn
 const stringNumberMap = z.map(z.string(), z.number());
 
 type StringNumberMap = z.infer<typeof stringNumberMap>;
-// type StringNumber = Map<string, number>
+// type StringNumberMap = Map<string, number>
 ```
 
 ## Sets
 
 ```ts
-const numberSet = z.set(z.string());
-type numberSet = z.infer<typeof numberSet>;
-// Set<number>
+const numberSet = z.set(z.number());
+type NumberSet = z.infer<typeof numberSet>;
+// type NumberSet = Set<number>
+```
+
+### `.nonempty/.min/.max/.size`
+
+```ts
+z.set(z.string()).nonempty(); // must contain at least one item
+z.set(z.string()).min(5); // must contain 5 or more items
+z.set(z.string()).max(5); // must contain 5 or fewer items
+z.set(z.string()).size(5); // must contain 5 items exactly
 ```
 
 ## Intersections
@@ -1007,8 +1066,8 @@ interface Category {
   subcategories: Category[];
 }
 
-// cast to z.ZodSchema<Category>
-const Category: z.ZodSchema<Category> = z.lazy(() =>
+// cast to z.ZodType<Category>
+const Category: z.ZodType<Category> = z.lazy(() =>
   z.object({
     name: z.string(),
     subcategories: z.array(Category),
@@ -1045,7 +1104,7 @@ interface Category extends z.infer<typeof BaseCategory> {
 
 // merge the base schema with
 // a new Zod schema containing relations
-const Category: z.ZodSchema<Category> = BaseCategory.merge(
+const Category: z.ZodType<Category> = BaseCategory.merge(
   z.object({
     subcategories: z.lazy(() => z.array(Category)),
   })
@@ -1060,7 +1119,7 @@ If you want to validate any JSON value, you can use the snippet below.
 type Literal = boolean | null | number | string;
 type Json = Literal | { [key: string]: Json } | Json[];
 const literalSchema = z.union([z.string(), z.number(), z.boolean(), z.null()]);
-const jsonSchema: z.ZodSchema<Json> = z.lazy(() =>
+const jsonSchema: z.ZodType<Json> = z.lazy(() =>
   z.union([literalSchema, z.array(jsonSchema), z.record(jsonSchema)])
 );
 
@@ -1071,7 +1130,7 @@ Thanks to [ggoodman](https://github.com/ggoodman) for suggesting this.
 
 #### Cyclical objects
 
-Despite supporting recursive schemas, passing an cyclical data into Zod will cause an infinite loop.
+Despite supporting recursive schemas, passing cyclical data into Zod will cause an infinite loop.
 
 ## Promises
 
@@ -1607,7 +1666,7 @@ A convenience method for creating intersection types.
 z.object({ name: z.string() }).and(z.object({ age: z.number() })); // { name: string } & { age: number }
 
 // equivalent to
-z.intersection(z.string(), z.number());
+z.intersection(z.object({ name: z.string() }), z.object({ age: z.number() }));
 ```
 
 # Type inference

package/lib/ZodError.d.ts

@@ -1,9 +1,11 @@
 import { ZodParsedType } from "./helpers/parseUtil";
+import { Primitive } from "./helpers/typeAliases";
 import { util } from "./helpers/util";
 export declare const ZodIssueCode: {
     invalid_type: "invalid_type";
     custom: "custom";
     invalid_union: "invalid_union";
+    invalid_union_discriminator: "invalid_union_discriminator";
     invalid_enum_value: "invalid_enum_value";
     unrecognized_keys: "unrecognized_keys";
     invalid_arguments: "invalid_arguments";
@@ -33,6 +35,10 @@ export interface ZodInvalidUnionIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_union;
     unionErrors: ZodError[];
 }
+export interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_union_discriminator;
+    options: Primitive[];
+}
 export interface ZodInvalidEnumValueIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_enum_value;
     options: (string | number)[];
@@ -57,13 +63,13 @@ export interface ZodTooSmallIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_small;
     minimum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number";
+    type: "array" | "string" | "number" | "set";
 }
 export interface ZodTooBigIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_big;
     maximum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number";
+    type: "array" | "string" | "number" | "set";
 }
 export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_intersection_types;
@@ -81,7 +87,7 @@ export interface ZodCustomIssue extends ZodIssueBase {
 export declare type DenormalizedError = {
     [k: string]: DenormalizedError | string[];
 };
-export declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
+export declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
 export declare type ZodIssue = ZodIssueOptionalMessage & {
     message: string;
 };
@@ -104,7 +110,13 @@ export declare class ZodError<T = any> extends Error {
     get isEmpty(): boolean;
     addIssue: (sub: ZodIssue) => void;
     addIssues: (subs?: ZodIssue[]) => void;
-    flatten: <U = string>(mapper?: (issue: ZodIssue) => U) => {
+    flatten(mapper?: (issue: ZodIssue) => string): {
+        formErrors: string[];
+        fieldErrors: {
+            [k: string]: string[];
+        };
+    };
+    flatten<U>(mapper?: (issue: ZodIssue) => U): {
         formErrors: U[];
         fieldErrors: {
             [k: string]: U[];
@@ -136,4 +148,3 @@ export declare let overrideErrorMap: (issue: ZodIssueOptionalMessage, _ctx: Erro
 };
 export declare const setErrorMap: (map: ZodErrorMap) => void;
 export {};
-//# sourceMappingURL=ZodError.d.ts.map

package/lib/ZodError.js

@@ -57,6 +57,7 @@ exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_type",
     "custom",
     "invalid_union",
+    "invalid_union_discriminator",
     "invalid_enum_value",
     "unrecognized_keys",
     "invalid_arguments",
@@ -142,32 +143,6 @@ var ZodError = /** @class */ (function (_super) {
             if (subs === void 0) { subs = []; }
             _this.issues = __spreadArray(__spreadArray([], __read(_this.issues), false), __read(subs), false);
         };
-        _this.flatten = function (mapper) {
-            var e_2, _a;
-            if (mapper === void 0) { mapper = function (issue) { return issue.message; }; }
-            var fieldErrors = {};
-            var formErrors = [];
-            try {
-                for (var _b = __values(_this.issues), _c = _b.next(); !_c.done; _c = _b.next()) {
-                    var sub = _c.value;
-                    if (sub.path.length > 0) {
-                        fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                        fieldErrors[sub.path[0]].push(mapper(sub));
-                    }
-                    else {
-                        formErrors.push(mapper(sub));
-                    }
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            return { formErrors: formErrors, fieldErrors: fieldErrors };
-        };
         var actualProto = _newTarget.prototype;
         if (Object.setPrototypeOf) {
             // eslint-disable-next-line ban/ban
@@ -204,6 +179,32 @@ var ZodError = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    ZodError.prototype.flatten = function (mapper) {
+        var e_2, _a;
+        if (mapper === void 0) { mapper = function (issue) { return issue.message; }; }
+        var fieldErrors = {};
+        var formErrors = [];
+        try {
+            for (var _b = __values(this.issues), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var sub = _c.value;
+                if (sub.path.length > 0) {
+                    fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
+                    fieldErrors[sub.path[0]].push(mapper(sub));
+                }
+                else {
+                    formErrors.push(mapper(sub));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return { formErrors: formErrors, fieldErrors: fieldErrors };
+    };
     Object.defineProperty(ZodError.prototype, "formErrors", {
         get: function () {
             return this.flatten();
@@ -226,21 +227,26 @@ var defaultErrorMap = function (issue, _ctx) {
                 message = "Required";
             }
             else {
-                message = "Expected " + issue.expected + ", received " + issue.received;
+                message = "Expected ".concat(issue.expected, ", received ").concat(issue.received);
             }
             break;
         case exports.ZodIssueCode.unrecognized_keys:
-            message = "Unrecognized key(s) in object: " + issue.keys
-                .map(function (k) { return "'" + k + "'"; })
-                .join(", ");
+            message = "Unrecognized key(s) in object: ".concat(issue.keys
+                .map(function (k) { return "'".concat(k, "'"); })
+                .join(", "));
             break;
         case exports.ZodIssueCode.invalid_union:
             message = "Invalid input";
             break;
+        case exports.ZodIssueCode.invalid_union_discriminator:
+            message = "Invalid discriminator value. Expected ".concat(issue.options
+                .map(function (val) { return (typeof val === "string" ? "'".concat(val, "'") : val); })
+                .join(" | "));
+            break;
         case exports.ZodIssueCode.invalid_enum_value:
-            message = "Invalid enum value. Expected " + issue.options
-                .map(function (val) { return (typeof val === "string" ? "'" + val + "'" : val); })
-                .join(" | ") + ", received " + (typeof _ctx.data === "string" ? "'" + _ctx.data + "'" : _ctx.data);
+            message = "Invalid enum value. Expected ".concat(issue.options
+                .map(function (val) { return (typeof val === "string" ? "'".concat(val, "'") : val); })
+                .join(" | "));
             break;
         case exports.ZodIssueCode.invalid_arguments:
             message = "Invalid function arguments";
@@ -253,27 +259,27 @@ var defaultErrorMap = function (issue, _ctx) {
             break;
         case exports.ZodIssueCode.invalid_string:
             if (issue.validation !== "regex")
-                message = "Invalid " + issue.validation;
+                message = "Invalid ".concat(issue.validation);
             else
                 message = "Invalid";
             break;
         case exports.ZodIssueCode.too_small:
             if (issue.type === "array")
-                message = "Should have " + (issue.inclusive ? "at least" : "more than") + " " + issue.minimum + " items";
+                message = "Array must contain ".concat(issue.inclusive ? "at least" : "more than", " ").concat(issue.minimum, " element(s)");
             else if (issue.type === "string")
-                message = "Should be " + (issue.inclusive ? "at least" : "over") + " " + issue.minimum + " characters";
+                message = "String must contain ".concat(issue.inclusive ? "at least" : "over", " ").concat(issue.minimum, " character(s)");
             else if (issue.type === "number")
-                message = "Value should be greater than " + (issue.inclusive ? "or equal to " : "") + issue.minimum;
+                message = "Number must be greater than ".concat(issue.inclusive ? "or equal to " : "").concat(issue.minimum);
             else
                 message = "Invalid input";
             break;
         case exports.ZodIssueCode.too_big:
             if (issue.type === "array")
-                message = "Should have " + (issue.inclusive ? "at most" : "less than") + " " + issue.maximum + " items";
+                message = "Array must contain ".concat(issue.inclusive ? "at most" : "less than", " ").concat(issue.maximum, " element(s)");
             else if (issue.type === "string")
-                message = "Should be " + (issue.inclusive ? "at most" : "under") + " " + issue.maximum + " characters long";
+                message = "String must contain ".concat(issue.inclusive ? "at most" : "under", " ").concat(issue.maximum, " character(s)");
             else if (issue.type === "number")
-                message = "Value should be less than " + (issue.inclusive ? "or equal to " : "") + issue.maximum;
+                message = "Number must be less than ".concat(issue.inclusive ? "or equal to " : "").concat(issue.maximum);
             else
                 message = "Invalid input";
             break;
@@ -284,7 +290,7 @@ var defaultErrorMap = function (issue, _ctx) {
             message = "Intersection results could not be merged";
             break;
         case exports.ZodIssueCode.not_multiple_of:
-            message = "Should be multiple of " + issue.multipleOf;
+            message = "Number must be a multiple of ".concat(issue.multipleOf);
             break;
         default:
             message = _ctx.defaultError;
@@ -298,4 +304,3 @@ var setErrorMap = function (map) {
     exports.overrideErrorMap = map;
 };
 exports.setErrorMap = setErrorMap;
-//# sourceMappingURL=ZodError.js.map

package/lib/benchmarks/discriminatedUnion.d.ts

@@ -0,0 +1,5 @@
+import Benchmark from "benchmark";
+declare const _default: {
+    suites: Benchmark.Suite[];
+};
+export default _default;

package/lib/benchmarks/discriminatedUnion.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var benchmark_1 = __importDefault(require("benchmark"));
+var index_1 = require("../index");
+var doubleSuite = new benchmark_1.default.Suite("z.discriminatedUnion: double");
+var manySuite = new benchmark_1.default.Suite("z.discriminatedUnion: many");
+var aSchema = index_1.z.object({
+    type: index_1.z.literal("a"),
+});
+var objA = {
+    type: "a",
+};
+var bSchema = index_1.z.object({
+    type: index_1.z.literal("b"),
+});
+var objB = {
+    type: "b",
+};
+var cSchema = index_1.z.object({
+    type: index_1.z.literal("c"),
+});
+var objC = {
+    type: "c",
+};
+var dSchema = index_1.z.object({
+    type: index_1.z.literal("d"),
+});
+var double = index_1.z.discriminatedUnion("type", [aSchema, bSchema]);
+var many = index_1.z.discriminatedUnion("type", [aSchema, bSchema, cSchema, dSchema]);
+doubleSuite
+    .add("valid: a", function () {
+    double.parse(objA);
+})
+    .add("valid: b", function () {
+    double.parse(objB);
+})
+    .add("invalid: null", function () {
+    try {
+        double.parse(null);
+    }
+    catch (err) { }
+})
+    .add("invalid: wrong shape", function () {
+    try {
+        double.parse(objC);
+    }
+    catch (err) { }
+})
+    .on("cycle", function (e) {
+    console.log("".concat(doubleSuite.name, ": ").concat(e.target));
+});
+manySuite
+    .add("valid: a", function () {
+    many.parse(objA);
+})
+    .add("valid: c", function () {
+    many.parse(objC);
+})
+    .add("invalid: null", function () {
+    try {
+        many.parse(null);
+    }
+    catch (err) { }
+})
+    .add("invalid: wrong shape", function () {
+    try {
+        many.parse({ type: "unknown" });
+    }
+    catch (err) { }
+})
+    .on("cycle", function (e) {
+    console.log("".concat(manySuite.name, ": ").concat(e.target));
+});
+exports.default = {
+    suites: [doubleSuite, manySuite],
+};

package/lib/benchmarks/index.d.ts

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=index.d.ts.map