zod 3.18.0 → 3.19.1

package/README.md

@@ -63,7 +63,7 @@
 - [Nullables](#nullables)
 - [Objects](#objects)
   - [.shape](#shape)
-  - [.enum](#enum)
+  - [.keyof](#keyof)
   - [.extend](#extend)
   - [.merge](#merge)
   - [.pick/.omit](#pickomit)
@@ -90,7 +90,6 @@
 - [Instanceof](#instanceof)
 - [Function schemas](#function-schemas)
 - [Preprocess](#preprocess)
-- [Branded types](#branded-types)
 - [Schema methods](#schema-methods)
   - [.parse](#parse)
   - [.parseAsync](#parseasync)
@@ -107,6 +106,7 @@
   - [.promise](#promise)
   - [.or](#or)
   - [.and](#and)
+  - [.brand](#brand)
 - [Guides and concepts](#guides-and-concepts)
   - [Type inference](#type-inference)
   - [Writing generic functions](#writing-generic-functions)
@@ -306,9 +306,9 @@ 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.
+- [`@anatine/zod-openapi`](https://github.com/anatine/zod-plugins/tree/main/packages/zod-openapi): Converts a Zod schema to an OpenAPI v3.x `SchemaObject`.
+- [`@anatine/zod-mock`](https://github.com/anatine/zod-plugins/tree/main/packages/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/packages/zod-nestjs): Helper methods for using Zod in a NestJS project.
 - [`zod-mocking`](https://github.com/dipasqualew/zod-mocking): Generate mock data from your Zod schemas.
 - [`zod-fast-check`](https://github.com/DavidTimms/zod-fast-check): Generate `fast-check` arbitraries from Zod schemas.
 - [`zod-endpoints`](https://github.com/flock-community/zod-endpoints): Contract-first strictly typed endpoints with Zod. OpenAPI compatible.
@@ -330,6 +330,7 @@ There are a growing number of tools that are built atop or support Zod natively!
 - [`remix-domains`](https://github.com/SeasonedSoftware/remix-domains/): Improves end-to-end type safety in [Remix](https://remix.run/) by leveraging Zod to parse the framework's inputs such as FormData, URLSearchParams, etc.
 - [`@zodios/core`](https://github.com/ecyrbe/zodios): A typescript API client with runtime and compile time validation backed by axios and zod.
 - [`@runtyping/zod`](https://github.com/johngeorgewright/runtyping/tree/master/packages/zod): Generate zod from static types & JSON schema.
+- [`slonik`](https://github.com/gajus/slonik/tree/gajus/add-zod-validation-backwards-compatible#runtime-validation-and-static-type-inference): Node.js Postgres client with strong Zod integration
 
 #### Form integrations
 
@@ -799,7 +800,7 @@ Dog.shape.age; // => number schema
 
 ### `.keyof`
 
-Use `.key` to create a `ZodEnum` schema from the keys of an object schema.
+Use `.keyof` to create a `ZodEnum` schema from the keys of an object schema.
 
 ```ts
 const keySchema = Dog.keyof();
@@ -1073,6 +1074,14 @@ type Athlete = z.infer<typeof athleteSchema>;
 // type Athlete = [string, number, { pointsScored: number }]
 ```
 
+A variadic ("rest") argument can be added with the `.rest` method.
+
+```ts
+const variadicTuple = z.tuple([z.string()]).rest(z.number());
+const result = variadicTuple.parse(["hello", 1, 2, 3]);
+// => [string, ...number[]];
+```
+
 ## Unions
 
 Zod includes a built-in `z.union` method for composing "OR" types.
@@ -1683,34 +1692,33 @@ const Strings = z.array(z.string()).superRefine((val, ctx) => {
 });
 ```
 
-You can add as many issues as you like. If `ctx.addIssue` is NOT called during the execution of the function, validation passes.
+You can add as many issues as you like. If `ctx.addIssue` is _not_ called during the execution of the function, validation passes.
 
 Normally refinements always create issues with a `ZodIssueCode.custom` error code, but with `superRefine` you can create any issue of any code. Each issue code is described in detail in the Error Handling guide: [ERROR_HANDLING.md](ERROR_HANDLING.md).
 
 #### Abort early
 
-By default, parsing will continue even after a refinement check fails. For instance, if you chain together multiple refinements, they will all be executed. However, it may be desirable to _abort early_ to prevent later refinements from being executed. To achieve this, pass the `fatal` flag to `ctx.addIssue`:
+By default, parsing will continue even after a refinement check fails. For instance, if you chain together multiple refinements, they will all be executed. However, it may be desirable to _abort early_ to prevent later refinements from being executed. To achieve this, pass the `fatal` flag to `ctx.addIssue` and return `z.NEVER`.
 
 ```ts
-const Strings = z
-  .number()
-  .superRefine((val, ctx) => {
-    if (val < 10) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "foo",
-        fatal: true,
-      });
-    }
-  })
-  .superRefine((val, ctx) => {
-    if (val !== " ") {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: "bar",
-      });
-    }
-  });
+const schema = z.number().superRefine((val, ctx) => {
+  if (val < 10) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "should be >= 10",
+      fatal: true,
+    });
+
+    return z.NEVER;
+  }
+
+  if (val !== 12) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "should be twelve",
+    });
+  }
+});
 ```
 
 ### `.transform`
@@ -1722,8 +1730,6 @@ const stringToNumber = z.string().transform((val) => val.length);
 stringToNumber.parse("string"); // => 6
 ```
 
-> ⚠️ Transform functions must not throw. Make sure to use refinements before the transform or addIssue within the transform to make sure the input can be parsed by the transform.
-
 #### Chaining order
 
 Note that `stringToNumber` above is an instance of the `ZodEffects` subclass. It is NOT an instance of `ZodString`. If you want to use the built-in methods of `ZodString` (e.g. `.email()`) you must apply those methods _before_ any transforms.
@@ -1739,7 +1745,9 @@ emailToDomain.parse("colinhacks@example.com"); // => example.com
 
 #### Validating during transform
 
-Similar to `superRefine`, `transform` can optionally take a `ctx`. This allows you to simultaneously validate and transform the value, which can be simpler than chaining `refine` and `validate`. When calling `ctx.addIssue` make sure to still return a value of the correct type otherwise the inferred type will include `undefined`.
+The `.transform` method can simultaneously validate and transform the value. This is often simpler and less duplicative than chaining `refine` and `validate`.
+
+As with `.superRefine`, the transform function receives a `ctx` object with a `addIssue` method that can be used to register validation issues.
 
 ```ts
 const Strings = z.string().transform((val, ctx) => {
@@ -1749,6 +1757,12 @@ const Strings = z.string().transform((val, ctx) => {
       code: z.ZodIssueCode.custom,
       message: "Not a number",
     });
+
+    // This is a special symbol you can use to
+    // return early from the transform function.
+    // It has type `never` so it does not affect the
+    // inferred return type.
+    return z.NEVER;
   }
   return parsed;
 });

package/lib/ZodError.d.ts

@@ -142,16 +142,11 @@ export declare type IssueData = stripPath<ZodIssueOptionalMessage> & {
     fatal?: boolean;
 };
 export declare type MakeErrorData = IssueData;
-declare type ErrorMapCtx = {
+export declare type ErrorMapCtx = {
     defaultError: string;
     data: any;
 };
-export declare type ZodErrorMap = typeof defaultErrorMap;
-export declare const defaultErrorMap: (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
-    message: string;
-};
-export declare function setErrorMap(map: ZodErrorMap): void;
-export declare function getErrorMap(): (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+export declare type ZodErrorMap = (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
     message: string;
 };
 export {};

package/lib/ZodError.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMap = exports.setErrorMap = exports.defaultErrorMap = exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
-const parseUtil_1 = require("./helpers/parseUtil");
+exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
 const util_1 = require("./helpers/util");
 exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_type",
@@ -102,7 +101,7 @@ class ZodError extends Error {
         return this.message;
     }
     get message() {
-        return JSON.stringify(this.issues, parseUtil_1.jsonStringifyReplacer, 2);
+        return JSON.stringify(this.issues, util_1.util.jsonStringifyReplacer, 2);
     }
     get isEmpty() {
         return this.issues.length === 0;
@@ -130,106 +129,3 @@ ZodError.create = (issues) => {
     const error = new ZodError(issues);
     return error;
 };
-const defaultErrorMap = (issue, _ctx) => {
-    let message;
-    switch (issue.code) {
-        case exports.ZodIssueCode.invalid_type:
-            if (issue.received === util_1.ZodParsedType.undefined) {
-                message = "Required";
-            }
-            else {
-                message = `Expected ${issue.expected}, received ${issue.received}`;
-            }
-            break;
-        case exports.ZodIssueCode.invalid_literal:
-            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, parseUtil_1.jsonStringifyReplacer)}`;
-            break;
-        case exports.ZodIssueCode.unrecognized_keys:
-            message = `Unrecognized key(s) in object: ${util_1.util.joinValues(issue.keys, ", ")}`;
-            break;
-        case exports.ZodIssueCode.invalid_union:
-            message = `Invalid input`;
-            break;
-        case exports.ZodIssueCode.invalid_union_discriminator:
-            message = `Invalid discriminator value. Expected ${util_1.util.joinValues(issue.options)}`;
-            break;
-        case exports.ZodIssueCode.invalid_enum_value:
-            message = `Invalid enum value. Expected ${util_1.util.joinValues(issue.options)}, received '${issue.received}'`;
-            break;
-        case exports.ZodIssueCode.invalid_arguments:
-            message = `Invalid function arguments`;
-            break;
-        case exports.ZodIssueCode.invalid_return_type:
-            message = `Invalid function return type`;
-            break;
-        case exports.ZodIssueCode.invalid_date:
-            message = `Invalid date`;
-            break;
-        case exports.ZodIssueCode.invalid_string:
-            if (typeof issue.validation === "object") {
-                if ("startsWith" in issue.validation) {
-                    message = `Invalid input: must start with "${issue.validation.startsWith}"`;
-                }
-                else if ("endsWith" in issue.validation) {
-                    message = `Invalid input: must end with "${issue.validation.endsWith}"`;
-                }
-                else {
-                    util_1.util.assertNever(issue.validation);
-                }
-            }
-            else if (issue.validation !== "regex") {
-                message = `Invalid ${issue.validation}`;
-            }
-            else {
-                message = "Invalid";
-            }
-            break;
-        case exports.ZodIssueCode.too_small:
-            if (issue.type === "array")
-                message = `Array must contain ${issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
-            else if (issue.type === "string")
-                message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
-            else if (issue.type === "number")
-                message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
-            else if (issue.type === "date")
-                message = `Date must be greater than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.minimum)}`;
-            else
-                message = "Invalid input";
-            break;
-        case exports.ZodIssueCode.too_big:
-            if (issue.type === "array")
-                message = `Array must contain ${issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
-            else if (issue.type === "string")
-                message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
-            else if (issue.type === "number")
-                message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
-            else if (issue.type === "date")
-                message = `Date must be smaller than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.maximum)}`;
-            else
-                message = "Invalid input";
-            break;
-        case exports.ZodIssueCode.custom:
-            message = `Invalid input`;
-            break;
-        case exports.ZodIssueCode.invalid_intersection_types:
-            message = `Intersection results could not be merged`;
-            break;
-        case exports.ZodIssueCode.not_multiple_of:
-            message = `Number must be a multiple of ${issue.multipleOf}`;
-            break;
-        default:
-            message = _ctx.defaultError;
-            util_1.util.assertNever(issue);
-    }
-    return { message };
-};
-exports.defaultErrorMap = defaultErrorMap;
-let overrideErrorMap = exports.defaultErrorMap;
-function setErrorMap(map) {
-    overrideErrorMap = map;
-}
-exports.setErrorMap = setErrorMap;
-function getErrorMap() {
-    return overrideErrorMap;
-}
-exports.getErrorMap = getErrorMap;

package/lib/errors.d.ts

@@ -0,0 +1,5 @@
+import defaultErrorMap from "./locales/en";
+import type { ZodErrorMap } from "./ZodError";
+export { defaultErrorMap };
+export declare function setErrorMap(map: ZodErrorMap): void;
+export declare function getErrorMap(): ZodErrorMap;

package/lib/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMap = exports.setErrorMap = exports.defaultErrorMap = void 0;
+const en_1 = __importDefault(require("./locales/en"));
+exports.defaultErrorMap = en_1.default;
+let overrideErrorMap = en_1.default;
+function setErrorMap(map) {
+    overrideErrorMap = map;
+}
+exports.setErrorMap = setErrorMap;
+function getErrorMap() {
+    return overrideErrorMap;
+}
+exports.getErrorMap = getErrorMap;

package/lib/external.d.ts

@@ -1,3 +1,4 @@
+export * from "./errors";
 export * from "./helpers/parseUtil";
 export * from "./helpers/typeAliases";
 export { getParsedType, ZodParsedType } from "./helpers/util";

package/lib/external.js

@@ -11,6 +11,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZodParsedType = exports.getParsedType = void 0;
+__exportStar(require("./errors"), exports);
 __exportStar(require("./helpers/parseUtil"), exports);
 __exportStar(require("./helpers/typeAliases"), exports);
 var util_1 = require("./helpers/util");

package/lib/helpers/parseUtil.d.ts

@@ -76,4 +76,3 @@ export declare const isAborted: (x: ParseReturnType<any>) => x is INVALID;
 export declare const isDirty: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
 export declare const isValid: <T>(x: ParseReturnType<T>) => x is OK<T> | DIRTY<T>;
 export declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;
-export declare const jsonStringifyReplacer: (_: string, value: any) => any;

package/lib/helpers/parseUtil.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jsonStringifyReplacer = exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.addIssueToContext = exports.EMPTY_PATH = exports.makeIssue = void 0;
-const ZodError_1 = require("../ZodError");
+exports.isAsync = exports.isValid = exports.isDirty = exports.isAborted = exports.OK = exports.DIRTY = exports.INVALID = exports.ParseStatus = exports.addIssueToContext = exports.EMPTY_PATH = exports.makeIssue = void 0;
+const errors_1 = require("../errors");
+const en_1 = __importDefault(require("../locales/en"));
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
     const fullPath = [...path, ...(issueData.path || [])];
@@ -33,8 +37,8 @@ function addIssueToContext(ctx, issueData) {
         errorMaps: [
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
-            ZodError_1.getErrorMap(),
-            ZodError_1.defaultErrorMap,
+            errors_1.getErrorMap(),
+            en_1.default,
         ].filter((x) => !!x),
     });
     ctx.common.issues.push(issue);
@@ -108,10 +112,3 @@ const isValid = (x) => x.status === "valid";
 exports.isValid = isValid;
 const isAsync = (x) => typeof Promise !== undefined && x instanceof Promise;
 exports.isAsync = isAsync;
-const jsonStringifyReplacer = (_, value) => {
-    if (typeof value === "bigint") {
-        return value.toString();
-    }
-    return value;
-};
-exports.jsonStringifyReplacer = jsonStringifyReplacer;

package/lib/helpers/util.d.ts

@@ -18,6 +18,7 @@ export declare namespace util {
     export type noUndefined<T> = T extends undefined ? never : T;
     export const isInteger: NumberConstructor["isInteger"];
     export function joinValues<T extends any[]>(array: T, separator?: string): string;
+    export const jsonStringifyReplacer: (_: string, value: any) => any;
     export {};
 }
 export declare const ZodParsedType: {

package/lib/helpers/util.js

@@ -57,6 +57,12 @@ var util;
             .join(separator);
     }
     util.joinValues = joinValues;
+    util.jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return value;
+    };
 })(util = exports.util || (exports.util = {}));
 exports.ZodParsedType = util.arrayToEnum([
     "string",

package/lib/index.mjs

@@ -54,6 +54,12 @@ var util;
             .join(separator);
     }
     util.joinValues = joinValues;
+    util.jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return value;
+    };
 })(util || (util = {}));
 const ZodParsedType = util.arrayToEnum([
     "string",
@@ -218,7 +224,7 @@ class ZodError extends Error {
         return this.message;
     }
     get message() {
-        return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
+        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
     }
     get isEmpty() {
         return this.issues.length === 0;
@@ -245,7 +251,8 @@ ZodError.create = (issues) => {
     const error = new ZodError(issues);
     return error;
 };
-const defaultErrorMap = (issue, _ctx) => {
+
+const errorMap = (issue, _ctx) => {
     let message;
     switch (issue.code) {
         case ZodIssueCode.invalid_type:
@@ -257,7 +264,7 @@ const defaultErrorMap = (issue, _ctx) => {
             }
             break;
         case ZodIssueCode.invalid_literal:
-            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, jsonStringifyReplacer)}`;
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
             break;
         case ZodIssueCode.unrecognized_keys:
             message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
@@ -338,7 +345,8 @@ const defaultErrorMap = (issue, _ctx) => {
     }
     return { message };
 };
-let overrideErrorMap = defaultErrorMap;
+
+let overrideErrorMap = errorMap;
 function setErrorMap(map) {
     overrideErrorMap = map;
 }
@@ -377,7 +385,7 @@ function addIssueToContext(ctx, issueData) {
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
             getErrorMap(),
-            defaultErrorMap,
+            errorMap,
         ].filter((x) => !!x),
     });
     ctx.common.issues.push(issue);
@@ -443,12 +451,6 @@ const isAborted = (x) => x.status === "aborted";
 const isDirty = (x) => x.status === "dirty";
 const isValid = (x) => x.status === "valid";
 const isAsync = (x) => typeof Promise !== undefined && x instanceof Promise;
-const jsonStringifyReplacer = (_, value) => {
-    if (typeof value === "bigint") {
-        return value.toString();
-    }
-    return value;
-};
 
 var errorUtil;
 (function (errorUtil) {
@@ -484,7 +486,7 @@ function processCreateParams(params) {
         return {};
     const { errorMap, invalid_type_error, required_error, description } = params;
     if (errorMap && (invalid_type_error || required_error)) {
-        throw new Error(`Can't use "invalid" or "required" in conjunction with custom error map.`);
+        throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
     }
     if (errorMap)
         return { errorMap: errorMap, description };
@@ -1605,9 +1607,12 @@ class ZodObject extends ZodType {
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
         const extraKeys = [];
-        for (const key in ctx.data) {
-            if (!shapeKeys.includes(key)) {
-                extraKeys.push(key);
+        if (!(this._def.catchall instanceof ZodNever &&
+            this._def.unknownKeys === "strip")) {
+            for (const key in ctx.data) {
+                if (!shapeKeys.includes(key)) {
+                    extraKeys.push(key);
+                }
             }
         }
         const pairs = [];
@@ -2175,6 +2180,9 @@ class ZodTuple extends ZodType {
     }
 }
 ZodTuple.create = (schemas, params) => {
+    if (!Array.isArray(schemas)) {
+        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+    }
     return new ZodTuple({
         items: schemas,
         typeName: ZodFirstPartyTypeKind.ZodTuple,
@@ -2403,7 +2411,7 @@ class ZodFunction extends ZodType {
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
                     getErrorMap(),
-                    defaultErrorMap,
+                    errorMap,
                 ].filter((x) => !!x),
                 issueData: {
                     code: ZodIssueCode.invalid_arguments,
@@ -2419,7 +2427,7 @@ class ZodFunction extends ZodType {
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
                     getErrorMap(),
-                    defaultErrorMap,
+                    errorMap,
                 ].filter((x) => !!x),
                 issueData: {
                     code: ZodIssueCode.invalid_return_type,
@@ -2489,17 +2497,17 @@ class ZodFunction extends ZodType {
         const validatedFunc = this.parse(func);
         return validatedFunc;
     }
+    static create(args, returns, params) {
+        return new ZodFunction({
+            args: (args
+                ? args
+                : ZodTuple.create([]).rest(ZodUnknown.create())),
+            returns: returns || ZodUnknown.create(),
+            typeName: ZodFirstPartyTypeKind.ZodFunction,
+            ...processCreateParams(params),
+        });
+    }
 }
-ZodFunction.create = (args, returns, params) => {
-    return new ZodFunction({
-        args: (args
-            ? args.rest(ZodUnknown.create())
-            : ZodTuple.create([]).rest(ZodUnknown.create())),
-        returns: returns || ZodUnknown.create(),
-        typeName: ZodFirstPartyTypeKind.ZodFunction,
-        ...processCreateParams(params),
-    });
-};
 class ZodLazy extends ZodType {
     get schema() {
         return this._def.getter();
@@ -2944,6 +2952,12 @@ var ZodFirstPartyTypeKind;
     ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
     ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+// new approach that works for abstract classes
+// but required TS 4.4+
+// abstract class Class {
+//   constructor(..._: any[]) {}
+// }
+// const instanceOfType = <T extends typeof Class>(
 const instanceOfType = (cls, params = {
     message: `Input not instance of ${cls.name}`,
 }) => custom((data) => data instanceof cls, params, true);
@@ -2982,11 +2996,15 @@ const preprocessType = ZodEffects.createWithPreprocess;
 const ostring = () => stringType().optional();
 const onumber = () => numberType().optional();
 const oboolean = () => booleanType().optional();
+const NEVER = INVALID;
 
 var mod = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getParsedType: getParsedType,
     ZodParsedType: ZodParsedType,
+    defaultErrorMap: errorMap,
+    setErrorMap: setErrorMap,
+    getErrorMap: getErrorMap,
     makeIssue: makeIssue,
     EMPTY_PATH: EMPTY_PATH,
     addIssueToContext: addIssueToContext,
@@ -2998,7 +3016,6 @@ var mod = /*#__PURE__*/Object.freeze({
     isDirty: isDirty,
     isValid: isValid,
     isAsync: isAsync,
-    jsonStringifyReplacer: jsonStringifyReplacer,
     ZodType: ZodType,
     ZodString: ZodString,
     ZodNumber: ZodNumber,
@@ -3077,12 +3094,10 @@ var mod = /*#__PURE__*/Object.freeze({
     union: unionType,
     unknown: unknownType,
     'void': voidType,
+    NEVER: NEVER,
     ZodIssueCode: ZodIssueCode,
     quotelessJson: quotelessJson,
-    ZodError: ZodError,
-    defaultErrorMap: defaultErrorMap,
-    setErrorMap: setErrorMap,
-    getErrorMap: getErrorMap
+    ZodError: ZodError
 });
 
-export { BRAND, DIRTY, EMPTY_PATH, INVALID, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodBranded, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodError, ZodFirstPartyTypeKind, ZodFunction, ZodIntersection, ZodIssueCode, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodParsedType, ZodPromise, ZodRecord, ZodType as ZodSchema, ZodSet, ZodString, ZodEffects as ZodTransformer, ZodTuple, ZodType, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, addIssueToContext, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, custom, dateType as date, mod as default, defaultErrorMap, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getErrorMap, getParsedType, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, jsonStringifyReplacer, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, mod as z };
+export { BRAND, DIRTY, EMPTY_PATH, INVALID, NEVER, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, ZodBranded, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodEffects, ZodEnum, ZodError, ZodFirstPartyTypeKind, ZodFunction, ZodIntersection, ZodIssueCode, ZodLazy, ZodLiteral, ZodMap, ZodNaN, ZodNativeEnum, ZodNever, ZodNull, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodParsedType, ZodPromise, ZodRecord, ZodType as ZodSchema, ZodSet, ZodString, ZodEffects as ZodTransformer, ZodTuple, ZodType, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, addIssueToContext, anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, custom, dateType as date, mod as default, errorMap as defaultErrorMap, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, getErrorMap, getParsedType, instanceOfType as instanceof, intersectionType as intersection, isAborted, isAsync, isDirty, isValid, late, lazyType as lazy, literalType as literal, makeIssue, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, objectUtil, oboolean, onumber, optionalType as optional, ostring, preprocessType as preprocess, promiseType as promise, quotelessJson, recordType as record, setType as set, setErrorMap, strictObjectType as strictObject, stringType as string, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, mod as z };

package/lib/index.umd.js

@@ -60,6 +60,12 @@
                 .join(separator);
         }
         util.joinValues = joinValues;
+        util.jsonStringifyReplacer = (_, value) => {
+            if (typeof value === "bigint") {
+                return value.toString();
+            }
+            return value;
+        };
     })(util || (util = {}));
     const ZodParsedType = util.arrayToEnum([
         "string",
@@ -224,7 +230,7 @@
             return this.message;
         }
         get message() {
-            return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
+            return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
         }
         get isEmpty() {
             return this.issues.length === 0;
@@ -251,7 +257,8 @@
         const error = new ZodError(issues);
         return error;
     };
-    const defaultErrorMap = (issue, _ctx) => {
+
+    const errorMap = (issue, _ctx) => {
         let message;
         switch (issue.code) {
             case ZodIssueCode.invalid_type:
@@ -263,7 +270,7 @@
                 }
                 break;
             case ZodIssueCode.invalid_literal:
-                message = `Invalid literal value, expected ${JSON.stringify(issue.expected, jsonStringifyReplacer)}`;
+                message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
                 break;
             case ZodIssueCode.unrecognized_keys:
                 message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
@@ -344,7 +351,8 @@
         }
         return { message };
     };
-    let overrideErrorMap = defaultErrorMap;
+
+    let overrideErrorMap = errorMap;
     function setErrorMap(map) {
         overrideErrorMap = map;
     }
@@ -383,7 +391,7 @@
                 ctx.common.contextualErrorMap,
                 ctx.schemaErrorMap,
                 getErrorMap(),
-                defaultErrorMap,
+                errorMap,
             ].filter((x) => !!x),
         });
         ctx.common.issues.push(issue);
@@ -449,12 +457,6 @@
     const isDirty = (x) => x.status === "dirty";
     const isValid = (x) => x.status === "valid";
     const isAsync = (x) => typeof Promise !== undefined && x instanceof Promise;
-    const jsonStringifyReplacer = (_, value) => {
-        if (typeof value === "bigint") {
-            return value.toString();
-        }
-        return value;
-    };
 
     var errorUtil;
     (function (errorUtil) {
@@ -490,7 +492,7 @@
             return {};
         const { errorMap, invalid_type_error, required_error, description } = params;
         if (errorMap && (invalid_type_error || required_error)) {
-            throw new Error(`Can't use "invalid" or "required" in conjunction with custom error map.`);
+            throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
         }
         if (errorMap)
             return { errorMap: errorMap, description };
@@ -1611,9 +1613,12 @@
             const { status, ctx } = this._processInputParams(input);
             const { shape, keys: shapeKeys } = this._getCached();
             const extraKeys = [];
-            for (const key in ctx.data) {
-                if (!shapeKeys.includes(key)) {
-                    extraKeys.push(key);
+            if (!(this._def.catchall instanceof ZodNever &&
+                this._def.unknownKeys === "strip")) {
+                for (const key in ctx.data) {
+                    if (!shapeKeys.includes(key)) {
+                        extraKeys.push(key);
+                    }
                 }
             }
             const pairs = [];
@@ -2181,6 +2186,9 @@
         }
     }
     ZodTuple.create = (schemas, params) => {
+        if (!Array.isArray(schemas)) {
+            throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+        }
         return new ZodTuple({
             items: schemas,
             typeName: exports.ZodFirstPartyTypeKind.ZodTuple,
@@ -2409,7 +2417,7 @@
                         ctx.common.contextualErrorMap,
                         ctx.schemaErrorMap,
                         getErrorMap(),
-                        defaultErrorMap,
+                        errorMap,
                     ].filter((x) => !!x),
                     issueData: {
                         code: ZodIssueCode.invalid_arguments,
@@ -2425,7 +2433,7 @@
                         ctx.common.contextualErrorMap,
                         ctx.schemaErrorMap,
                         getErrorMap(),
-                        defaultErrorMap,
+                        errorMap,
                     ].filter((x) => !!x),
                     issueData: {
                         code: ZodIssueCode.invalid_return_type,
@@ -2495,17 +2503,17 @@
             const validatedFunc = this.parse(func);
             return validatedFunc;
         }
+        static create(args, returns, params) {
+            return new ZodFunction({
+                args: (args
+                    ? args
+                    : ZodTuple.create([]).rest(ZodUnknown.create())),
+                returns: returns || ZodUnknown.create(),
+                typeName: exports.ZodFirstPartyTypeKind.ZodFunction,
+                ...processCreateParams(params),
+            });
+        }
     }
-    ZodFunction.create = (args, returns, params) => {
-        return new ZodFunction({
-            args: (args
-                ? args.rest(ZodUnknown.create())
-                : ZodTuple.create([]).rest(ZodUnknown.create())),
-            returns: returns || ZodUnknown.create(),
-            typeName: exports.ZodFirstPartyTypeKind.ZodFunction,
-            ...processCreateParams(params),
-        });
-    };
     class ZodLazy extends ZodType {
         get schema() {
             return this._def.getter();
@@ -2950,6 +2958,12 @@
         ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
         ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
     })(exports.ZodFirstPartyTypeKind || (exports.ZodFirstPartyTypeKind = {}));
+    // new approach that works for abstract classes
+    // but required TS 4.4+
+    // abstract class Class {
+    //   constructor(..._: any[]) {}
+    // }
+    // const instanceOfType = <T extends typeof Class>(
     const instanceOfType = (cls, params = {
         message: `Input not instance of ${cls.name}`,
     }) => custom((data) => data instanceof cls, params, true);
@@ -2988,11 +3002,15 @@
     const ostring = () => stringType().optional();
     const onumber = () => numberType().optional();
     const oboolean = () => booleanType().optional();
+    const NEVER = INVALID;
 
     var mod = /*#__PURE__*/Object.freeze({
         __proto__: null,
         getParsedType: getParsedType,
         ZodParsedType: ZodParsedType,
+        defaultErrorMap: errorMap,
+        setErrorMap: setErrorMap,
+        getErrorMap: getErrorMap,
         makeIssue: makeIssue,
         EMPTY_PATH: EMPTY_PATH,
         addIssueToContext: addIssueToContext,
@@ -3004,7 +3022,6 @@
         isDirty: isDirty,
         isValid: isValid,
         isAsync: isAsync,
-        jsonStringifyReplacer: jsonStringifyReplacer,
         ZodType: ZodType,
         ZodString: ZodString,
         ZodNumber: ZodNumber,
@@ -3083,18 +3100,17 @@
         union: unionType,
         unknown: unknownType,
         'void': voidType,
+        NEVER: NEVER,
         ZodIssueCode: ZodIssueCode,
         quotelessJson: quotelessJson,
-        ZodError: ZodError,
-        defaultErrorMap: defaultErrorMap,
-        setErrorMap: setErrorMap,
-        getErrorMap: getErrorMap
+        ZodError: ZodError
     });
 
     exports.BRAND = BRAND;
     exports.DIRTY = DIRTY;
     exports.EMPTY_PATH = EMPTY_PATH;
     exports.INVALID = INVALID;
+    exports.NEVER = NEVER;
     exports.OK = OK;
     exports.ParseStatus = ParseStatus;
     exports.Schema = ZodType;
@@ -3144,7 +3160,7 @@
     exports.custom = custom;
     exports.date = dateType;
     exports["default"] = mod;
-    exports.defaultErrorMap = defaultErrorMap;
+    exports.defaultErrorMap = errorMap;
     exports.discriminatedUnion = discriminatedUnionType;
     exports.effect = effectsType;
     exports["enum"] = enumType;
@@ -3157,7 +3173,6 @@
     exports.isAsync = isAsync;
     exports.isDirty = isDirty;
     exports.isValid = isValid;
-    exports.jsonStringifyReplacer = jsonStringifyReplacer;
     exports.late = late;
     exports.lazy = lazyType;
     exports.literal = literalType;

package/lib/locales/en.d.ts

@@ -0,0 +1,3 @@
+import { ZodErrorMap } from "../ZodError";
+declare const errorMap: ZodErrorMap;
+export default errorMap;

package/lib/locales/en.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../helpers/util");
+const ZodError_1 = require("../ZodError");
+const errorMap = (issue, _ctx) => {
+    let message;
+    switch (issue.code) {
+        case ZodError_1.ZodIssueCode.invalid_type:
+            if (issue.received === util_1.ZodParsedType.undefined) {
+                message = "Required";
+            }
+            else {
+                message = `Expected ${issue.expected}, received ${issue.received}`;
+            }
+            break;
+        case ZodError_1.ZodIssueCode.invalid_literal:
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util_1.util.jsonStringifyReplacer)}`;
+            break;
+        case ZodError_1.ZodIssueCode.unrecognized_keys:
+            message = `Unrecognized key(s) in object: ${util_1.util.joinValues(issue.keys, ", ")}`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_union:
+            message = `Invalid input`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_union_discriminator:
+            message = `Invalid discriminator value. Expected ${util_1.util.joinValues(issue.options)}`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_enum_value:
+            message = `Invalid enum value. Expected ${util_1.util.joinValues(issue.options)}, received '${issue.received}'`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_arguments:
+            message = `Invalid function arguments`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_return_type:
+            message = `Invalid function return type`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_date:
+            message = `Invalid date`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_string:
+            if (typeof issue.validation === "object") {
+                if ("startsWith" in issue.validation) {
+                    message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+                }
+                else if ("endsWith" in issue.validation) {
+                    message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+                }
+                else {
+                    util_1.util.assertNever(issue.validation);
+                }
+            }
+            else if (issue.validation !== "regex") {
+                message = `Invalid ${issue.validation}`;
+            }
+            else {
+                message = "Invalid";
+            }
+            break;
+        case ZodError_1.ZodIssueCode.too_small:
+            if (issue.type === "array")
+                message = `Array must contain ${issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
+            else if (issue.type === "string")
+                message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
+            else if (issue.type === "number")
+                message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
+            else if (issue.type === "date")
+                message = `Date must be greater than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.minimum)}`;
+            else
+                message = "Invalid input";
+            break;
+        case ZodError_1.ZodIssueCode.too_big:
+            if (issue.type === "array")
+                message = `Array must contain ${issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
+            else if (issue.type === "string")
+                message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
+            else if (issue.type === "number")
+                message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
+            else if (issue.type === "date")
+                message = `Date must be smaller than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.maximum)}`;
+            else
+                message = "Invalid input";
+            break;
+        case ZodError_1.ZodIssueCode.custom:
+            message = `Invalid input`;
+            break;
+        case ZodError_1.ZodIssueCode.invalid_intersection_types:
+            message = `Intersection results could not be merged`;
+            break;
+        case ZodError_1.ZodIssueCode.not_multiple_of:
+            message = `Number must be a multiple of ${issue.multipleOf}`;
+            break;
+        default:
+            message = _ctx.defaultError;
+            util_1.util.assertNever(issue);
+    }
+    return { message };
+};
+exports.default = errorMap;

package/lib/types.d.ts

@@ -58,9 +58,9 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
     spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
-    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, RefinedOutput>;
+    refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, Input>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
-    refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, RefinedOutput>;
+    refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, Input>;
     refinement(check: (arg: Output) => boolean, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, Output, Input>;
     _refinement(refinement: RefinementEffect<Output>["refinement"]): ZodEffects<this, Output, Input>;
     superRefine: (refinement: RefinementEffect<Output>["refinement"]) => ZodEffects<this, Output, Input>;
@@ -379,7 +379,7 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
      * inferred type of merged objects. Please
      * upgrade if you are experiencing issues.
      */
-    merge<Incoming extends AnyZodObject>(merging: Incoming): ZodObject<extendShape<T, ReturnType<Incoming["_def"]["shape"]>>, UnknownKeys, Catchall>;
+    merge<Incoming extends AnyZodObject>(merging: Incoming): ZodObject<extendShape<T, ReturnType<Incoming["_def"]["shape"]>>, Incoming["_def"]["unknownKeys"], Incoming["_def"]["catchall"]>;
     catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
     pick<Mask extends {
         [k in keyof T]?: true;
@@ -470,6 +470,10 @@ export interface ZodTupleDef<T extends ZodTupleItems | [] = ZodTupleItems, Rest
     rest: Rest;
     typeName: ZodFirstPartyTypeKind.ZodTuple;
 }
+export declare type AnyZodTuple = ZodTuple<[
+    ZodTypeAny,
+    ...ZodTypeAny[]
+] | [], ZodTypeAny | null>;
 export declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [ZodTypeAny, ...ZodTypeAny[]], Rest extends ZodTypeAny | null = null> extends ZodType<OutputTypeOfTupleWithRest<T, Rest>, ZodTupleDef<T, Rest>, InputTypeOfTupleWithRest<T, Rest>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
@@ -536,7 +540,10 @@ export declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extend
     implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
     strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
     validate: <F extends InnerTypeOfFunction<Args, Returns>>(func: F) => ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
-    static create: <T extends ZodTuple<any, any> = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args?: T | undefined, returns?: U | undefined, params?: RawCreateParams) => ZodFunction<T, U>;
+    static create(): ZodFunction<ZodTuple<[], ZodUnknown>, ZodUnknown>;
+    static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>>(args: T): ZodFunction<T, ZodUnknown>;
+    static create<T extends AnyZodTuple, U extends ZodTypeAny>(args: T, returns: U): ZodFunction<T, U>;
+    static create<T extends AnyZodTuple = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args: T, returns: U, params?: RawCreateParams): ZodFunction<T, U>;
 }
 export interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     getter: () => T;
@@ -624,7 +631,7 @@ export declare class ZodEffects<T extends ZodTypeAny, Output = T["_output"], Inp
     innerType(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], I["_input"]>;
-    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], I["_input"]>;
+    static createWithPreprocess: <I extends ZodTypeAny>(preprocess: (arg: unknown) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
 }
 export { ZodEffects as ZodTransformer };
 export interface ZodOptionalDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
@@ -741,7 +748,7 @@ declare const tupleType: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas:
 declare const recordType: typeof ZodRecord.create;
 declare const mapType: <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(keyType: Key, valueType: Value, params?: RawCreateParams) => ZodMap<Key, Value>;
 declare const setType: <Value extends ZodTypeAny = ZodTypeAny>(valueType: Value, params?: RawCreateParams) => ZodSet<Value>;
-declare const functionType: <T extends ZodTuple<any, any> = ZodTuple<[], ZodUnknown>, U extends ZodTypeAny = ZodUnknown>(args?: T | undefined, returns?: U | undefined, params?: RawCreateParams) => ZodFunction<T, U>;
+declare const functionType: typeof ZodFunction.create;
 declare const lazyType: <T extends ZodTypeAny>(getter: () => T, params?: RawCreateParams) => ZodLazy<T>;
 declare const literalType: <T extends string | number | bigint | boolean | null | undefined>(value: T, params?: RawCreateParams) => ZodLiteral<T>;
 declare const enumType: typeof createZodEnum;
@@ -750,8 +757,9 @@ declare const promiseType: <T extends ZodTypeAny>(schema: T, params?: RawCreateP
 declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"], I["_input"]>;
 declare const optionalType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodOptional<T>;
 declare const nullableType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodNullable<T>;
-declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], I["_input"]>;
+declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
 declare const ostring: () => ZodOptional<ZodString>;
 declare const onumber: () => ZodOptional<ZodNumber>;
 declare const oboolean: () => ZodOptional<ZodBoolean>;
 export { anyType as any, arrayType as array, bigIntType as bigint, booleanType as boolean, dateType as date, discriminatedUnionType as discriminatedUnion, effectsType as effect, enumType as enum, functionType as function, instanceOfType as instanceof, intersectionType as intersection, lazyType as lazy, literalType as literal, mapType as map, nanType as nan, nativeEnumType as nativeEnum, neverType as never, nullType as null, nullableType as nullable, numberType as number, objectType as object, oboolean, onumber, optionalType as optional, ostring, preprocessType as preprocess, promiseType as promise, recordType as record, setType as set, strictObjectType as strictObject, stringType as string, effectsType as transformer, tupleType as tuple, undefinedType as undefined, unionType as union, unknownType as unknown, voidType as void, };
+export declare const NEVER: never;

package/lib/types.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.function = exports.enum = exports.effect = exports.discriminatedUnion = exports.date = exports.boolean = exports.bigint = exports.array = exports.any = exports.ZodFirstPartyTypeKind = exports.late = exports.ZodSchema = exports.Schema = exports.custom = exports.ZodBranded = exports.BRAND = exports.ZodNaN = exports.ZodDefault = exports.ZodNullable = exports.ZodOptional = exports.ZodTransformer = exports.ZodEffects = exports.ZodPromise = exports.ZodNativeEnum = exports.ZodEnum = exports.ZodLiteral = exports.ZodLazy = exports.ZodFunction = exports.ZodSet = exports.ZodMap = exports.ZodRecord = exports.ZodTuple = exports.ZodIntersection = exports.ZodDiscriminatedUnion = exports.ZodUnion = exports.ZodObject = exports.objectUtil = exports.ZodArray = exports.ZodVoid = exports.ZodNever = exports.ZodUnknown = exports.ZodAny = exports.ZodNull = exports.ZodUndefined = exports.ZodDate = exports.ZodBoolean = exports.ZodBigInt = exports.ZodNumber = exports.ZodString = exports.ZodType = void 0;
-exports.void = exports.unknown = exports.union = exports.undefined = exports.tuple = exports.transformer = exports.string = exports.strictObject = exports.set = exports.record = exports.promise = exports.preprocess = exports.ostring = exports.optional = exports.onumber = exports.oboolean = exports.object = exports.number = exports.nullable = exports.null = exports.never = exports.nativeEnum = exports.nan = exports.map = exports.literal = exports.lazy = exports.intersection = exports.instanceof = void 0;
+exports.NEVER = exports.void = exports.unknown = exports.union = exports.undefined = exports.tuple = exports.transformer = exports.string = exports.strictObject = exports.set = exports.record = exports.promise = exports.preprocess = exports.ostring = exports.optional = exports.onumber = exports.oboolean = exports.object = exports.number = exports.nullable = exports.null = exports.never = exports.nativeEnum = exports.nan = exports.map = exports.literal = exports.lazy = exports.intersection = exports.instanceof = void 0;
+const errors_1 = require("./errors");
 const errorUtil_1 = require("./helpers/errorUtil");
 const parseUtil_1 = require("./helpers/parseUtil");
 const util_1 = require("./helpers/util");
@@ -34,7 +35,7 @@ function processCreateParams(params) {
         return {};
     const { errorMap, invalid_type_error, required_error, description } = params;
     if (errorMap && (invalid_type_error || required_error)) {
-        throw new Error(`Can't use "invalid" or "required" in conjunction with custom error map.`);
+        throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
     }
     if (errorMap)
         return { errorMap: errorMap, description };
@@ -1170,9 +1171,12 @@ class ZodObject extends ZodType {
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
         const extraKeys = [];
-        for (const key in ctx.data) {
-            if (!shapeKeys.includes(key)) {
-                extraKeys.push(key);
+        if (!(this._def.catchall instanceof ZodNever &&
+            this._def.unknownKeys === "strip")) {
+            for (const key in ctx.data) {
+                if (!shapeKeys.includes(key)) {
+                    extraKeys.push(key);
+                }
             }
         }
         const pairs = [];
@@ -1746,6 +1750,9 @@ class ZodTuple extends ZodType {
 }
 exports.ZodTuple = ZodTuple;
 ZodTuple.create = (schemas, params) => {
+    if (!Array.isArray(schemas)) {
+        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+    }
     return new ZodTuple({
         items: schemas,
         typeName: ZodFirstPartyTypeKind.ZodTuple,
@@ -1976,8 +1983,8 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    ZodError_1.getErrorMap(),
-                    ZodError_1.defaultErrorMap,
+                    errors_1.getErrorMap(),
+                    errors_1.defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {
                     code: ZodError_1.ZodIssueCode.invalid_arguments,
@@ -1992,8 +1999,8 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    ZodError_1.getErrorMap(),
-                    ZodError_1.defaultErrorMap,
+                    errors_1.getErrorMap(),
+                    errors_1.defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {
                     code: ZodError_1.ZodIssueCode.invalid_return_type,
@@ -2063,18 +2070,18 @@ class ZodFunction extends ZodType {
         const validatedFunc = this.parse(func);
         return validatedFunc;
     }
+    static create(args, returns, params) {
+        return new ZodFunction({
+            args: (args
+                ? args
+                : ZodTuple.create([]).rest(ZodUnknown.create())),
+            returns: returns || ZodUnknown.create(),
+            typeName: ZodFirstPartyTypeKind.ZodFunction,
+            ...processCreateParams(params),
+        });
+    }
 }
 exports.ZodFunction = ZodFunction;
-ZodFunction.create = (args, returns, params) => {
-    return new ZodFunction({
-        args: (args
-            ? args.rest(ZodUnknown.create())
-            : ZodTuple.create([]).rest(ZodUnknown.create())),
-        returns: returns || ZodUnknown.create(),
-        typeName: ZodFirstPartyTypeKind.ZodFunction,
-        ...processCreateParams(params),
-    });
-};
 class ZodLazy extends ZodType {
     get schema() {
         return this._def.getter();
@@ -2532,6 +2539,12 @@ var ZodFirstPartyTypeKind;
     ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
     ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
 })(ZodFirstPartyTypeKind = exports.ZodFirstPartyTypeKind || (exports.ZodFirstPartyTypeKind = {}));
+// new approach that works for abstract classes
+// but required TS 4.4+
+// abstract class Class {
+//   constructor(..._: any[]) {}
+// }
+// const instanceOfType = <T extends typeof Class>(
 const instanceOfType = (cls, params = {
     message: `Input not instance of ${cls.name}`,
 }) => exports.custom((data) => data instanceof cls, params, true);
@@ -2607,3 +2620,4 @@ const onumber = () => numberType().optional();
 exports.onumber = onumber;
 const oboolean = () => booleanType().optional();
 exports.oboolean = oboolean;
+exports.NEVER = parseUtil_1.INVALID;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.18.0",
+  "version": "3.19.1",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "main": "./lib/index.js",
   "types": "./index.d.ts",
@@ -12,7 +12,8 @@
       "import": "./lib/index.mjs",
       "types": "./index.d.ts"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locales/*": "./lib/locales/*"
   },
   "files": [
     "/lib",