zod 3.17.4 → 3.17.7

package/README.md

@@ -313,6 +313,7 @@ There are a growing number of tools that are built atop or support Zod natively!
 - [`prisma-zod-generator`](https://github.com/omar-dulaimi/prisma-zod-generator): Emit Zod schemas from your Prisma schema.
 - [`prisma-trpc-generator`](https://github.com/omar-dulaimi/prisma-trpc-generator): Emit fully implemented tRPC routers and their validation schemas using Zod.
 - [`nestjs-graphql-zod`](https://github.com/incetarik/nestjs-graphql-zod): Generates NestJS GraphQL model classes from Zod schemas dynamically and provides GraphQL method decorators working with Zod schemas.
+- [`zod-xlsx`](https://github.com/sidwebworks/zod-xlsx): A xlsx based resource validator using Zod schemas.
 - [`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.
 
 #### Form integrations
@@ -351,7 +352,7 @@ pnpm add zod          # pnpm
 
 ### Deno
 
-Unlike Node, Deno relies on direct URL imports instead of a package manager like npm. Zod is available on [deno.land/x](deno.land/x). The latest version can be imported like so:
+Unlike Node, Deno relies on direct URL imports instead of a package manager like NPM. Zod is available on [deno.land/x](https://deno.land/x). The latest version can be imported like so:
 
 ```ts
 import { z } from "https://deno.land/x/zod/mod.ts";
@@ -360,7 +361,7 @@ import { z } from "https://deno.land/x/zod/mod.ts";
 You can also specify a particular version:
 
 ```ts
-import { z } from from "https://deno.land/x/zod@v3.16.1/mod.ts"
+import { z } from "https://deno.land/x/zod@v3.16.1/mod.ts";
 ```
 
 > The rest of this README assumes you are using npm and importing directly from the `"zod"` package.
@@ -438,7 +439,7 @@ const tru = z.literal(true);
 tuna.value; // "tuna"
 ```
 
-> Currently there is no support for Date or bigint literals in Zod. If you have a use case for this feature, please file an issue.
+> Currently there is no support for Date literals in Zod. If you have a use case for this feature, please file an issue.
 
 ## Strings
 
@@ -453,6 +454,8 @@ z.string().url();
 z.string().uuid();
 z.string().cuid();
 z.string().regex(regex);
+z.string().startsWith(string);
+z.string().endsWith(string);
 
 // trim whitespace
 z.string().trim();
@@ -484,6 +487,8 @@ z.string().length(5, { message: "Must be exactly 5 characters long" });
 z.string().email({ message: "Invalid email address" });
 z.string().url({ message: "Invalid url" });
 z.string().uuid({ message: "Invalid UUID" });
+z.string().startsWith("https://", { message: "Must provide secure URL" });
+z.string().endsWith(".com", { message: "Only .com domains allowed" });
 ```
 
 ## Numbers

package/lib/ZodError.d.ts

@@ -68,7 +68,11 @@ export interface ZodInvalidReturnTypeIssue extends ZodIssueBase {
 export interface ZodInvalidDateIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_date;
 }
-export declare type StringValidation = "email" | "url" | "uuid" | "regex" | "cuid";
+export declare type StringValidation = "email" | "url" | "uuid" | "regex" | "cuid" | {
+    startsWith: string;
+} | {
+    endsWith: string;
+};
 export interface ZodInvalidStringIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_string;
     validation: StringValidation;
@@ -146,8 +150,8 @@ export declare type ZodErrorMap = typeof defaultErrorMap;
 export declare const defaultErrorMap: (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
     message: string;
 };
-export declare let overrideErrorMap: (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
+export declare function setErrorMap(map: ZodErrorMap): void;
+export declare function getErrorMap(): (issue: ZodIssueOptionalMessage, _ctx: ErrorMapCtx) => {
     message: string;
 };
-export declare const setErrorMap: (map: ZodErrorMap) => void;
 export {};

package/lib/ZodError.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setErrorMap = exports.overrideErrorMap = exports.defaultErrorMap = exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+exports.getErrorMap = exports.setErrorMap = exports.defaultErrorMap = exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+const parseUtil_1 = require("./helpers/parseUtil");
 const util_1 = require("./helpers/util");
 exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_type",
@@ -101,7 +102,7 @@ class ZodError extends Error {
         return this.message;
     }
     get message() {
-        return JSON.stringify(this.issues, null, 2);
+        return JSON.stringify(this.issues, parseUtil_1.jsonStringifyReplacer, 2);
     }
     get isEmpty() {
         return this.issues.length === 0;
@@ -141,7 +142,7 @@ const defaultErrorMap = (issue, _ctx) => {
             }
             break;
         case exports.ZodIssueCode.invalid_literal:
-            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+            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, ", ")}`;
@@ -165,10 +166,23 @@ const defaultErrorMap = (issue, _ctx) => {
             message = `Invalid date`;
             break;
         case exports.ZodIssueCode.invalid_string:
-            if (issue.validation !== "regex")
+            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 start with "${issue.validation.endsWith}"`;
+                }
+                else {
+                    util_1.util.assertNever(issue.validation);
+                }
+            }
+            else if (issue.validation !== "regex") {
                 message = `Invalid ${issue.validation}`;
-            else
+            }
+            else {
                 message = "Invalid";
+            }
             break;
         case exports.ZodIssueCode.too_small:
             if (issue.type === "array")
@@ -206,8 +220,12 @@ const defaultErrorMap = (issue, _ctx) => {
     return { message };
 };
 exports.defaultErrorMap = defaultErrorMap;
-exports.overrideErrorMap = exports.defaultErrorMap;
-const setErrorMap = (map) => {
-    exports.overrideErrorMap = map;
-};
+let overrideErrorMap = exports.defaultErrorMap;
+function setErrorMap(map) {
+    overrideErrorMap = map;
+}
 exports.setErrorMap = setErrorMap;
+function getErrorMap() {
+    return overrideErrorMap;
+}
+exports.getErrorMap = getErrorMap;

package/lib/helpers/parseUtil.d.ts

@@ -76,3 +76,4 @@ 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,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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");
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
@@ -33,7 +33,7 @@ function addIssueToContext(ctx, issueData) {
         errorMaps: [
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
-            ZodError_1.overrideErrorMap,
+            ZodError_1.getErrorMap(),
             ZodError_1.defaultErrorMap,
         ].filter((x) => !!x),
     });
@@ -108,3 +108,10 @@ 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

@@ -1,5 +1,6 @@
 export declare namespace util {
     type AssertEqual<T, Expected> = [T] extends [Expected] ? [Expected] extends [T] ? true : false : false;
+    function assertEqual<A, B>(_cond: AssertEqual<A, B>): void;
     function assertNever(_x: never): never;
     type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
     type OmitKeys<T, K extends string> = Pick<T, Exclude<keyof T, K>>;

package/lib/helpers/util.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getParsedType = exports.ZodParsedType = exports.util = void 0;
 var util;
 (function (util) {
+    function assertEqual(_cond) { }
+    util.assertEqual = assertEqual;
     function assertNever(_x) {
         throw new Error();
     }

package/lib/index.mjs

@@ -1,5 +1,7 @@
 var util;
 (function (util) {
+    function assertEqual(_cond) { }
+    util.assertEqual = assertEqual;
     function assertNever(_x) {
         throw new Error();
     }
@@ -215,7 +217,7 @@ class ZodError extends Error {
         return this.message;
     }
     get message() {
-        return JSON.stringify(this.issues, null, 2);
+        return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
     }
     get isEmpty() {
         return this.issues.length === 0;
@@ -254,7 +256,7 @@ const defaultErrorMap = (issue, _ctx) => {
             }
             break;
         case ZodIssueCode.invalid_literal:
-            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, jsonStringifyReplacer)}`;
             break;
         case ZodIssueCode.unrecognized_keys:
             message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
@@ -278,10 +280,23 @@ const defaultErrorMap = (issue, _ctx) => {
             message = `Invalid date`;
             break;
         case ZodIssueCode.invalid_string:
-            if (issue.validation !== "regex")
+            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 start with "${issue.validation.endsWith}"`;
+                }
+                else {
+                    util.assertNever(issue.validation);
+                }
+            }
+            else if (issue.validation !== "regex") {
                 message = `Invalid ${issue.validation}`;
-            else
+            }
+            else {
                 message = "Invalid";
+            }
             break;
         case ZodIssueCode.too_small:
             if (issue.type === "array")
@@ -319,9 +334,12 @@ const defaultErrorMap = (issue, _ctx) => {
     return { message };
 };
 let overrideErrorMap = defaultErrorMap;
-const setErrorMap = (map) => {
+function setErrorMap(map) {
     overrideErrorMap = map;
-};
+}
+function getErrorMap() {
+    return overrideErrorMap;
+}
 
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
@@ -353,7 +371,7 @@ function addIssueToContext(ctx, issueData) {
         errorMaps: [
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
-            overrideErrorMap,
+            getErrorMap(),
             defaultErrorMap,
         ].filter((x) => !!x),
     });
@@ -420,6 +438,12 @@ 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) {
@@ -823,6 +847,28 @@ class ZodString extends ZodType {
             else if (check.kind === "trim") {
                 input.data = input.data.trim();
             }
+            else if (check.kind === "startsWith") {
+                if (!input.data.startsWith(check.value)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.invalid_string,
+                        validation: { startsWith: check.value },
+                        message: check.message,
+                    });
+                    status.dirty();
+                }
+            }
+            else if (check.kind === "endsWith") {
+                if (!input.data.endsWith(check.value)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.invalid_string,
+                        validation: { endsWith: check.value },
+                        message: check.message,
+                    });
+                    status.dirty();
+                }
+            }
             else {
                 util.assertNever(check);
             }
@@ -854,6 +900,20 @@ class ZodString extends ZodType {
             ...errorUtil.errToObj(message),
         });
     }
+    startsWith(value, message) {
+        return this._addCheck({
+            kind: "startsWith",
+            value: value,
+            ...errorUtil.errToObj(message),
+        });
+    }
+    endsWith(value, message) {
+        return this._addCheck({
+            kind: "endsWith",
+            value: value,
+            ...errorUtil.errToObj(message),
+        });
+    }
     min(minLength, message) {
         return this._addCheck({
             kind: "min",
@@ -2254,7 +2314,7 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    overrideErrorMap,
+                    getErrorMap(),
                     defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {
@@ -2270,7 +2330,7 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    overrideErrorMap,
+                    getErrorMap(),
                     defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {
@@ -2834,6 +2894,7 @@ var mod = /*#__PURE__*/Object.freeze({
     isDirty: isDirty,
     isValid: isValid,
     isAsync: isAsync,
+    jsonStringifyReplacer: jsonStringifyReplacer,
     ZodType: ZodType,
     ZodString: ZodString,
     ZodNumber: ZodNumber,
@@ -2914,8 +2975,8 @@ var mod = /*#__PURE__*/Object.freeze({
     quotelessJson: quotelessJson,
     ZodError: ZodError,
     defaultErrorMap: defaultErrorMap,
-    get overrideErrorMap () { return overrideErrorMap; },
-    setErrorMap: setErrorMap
+    setErrorMap: setErrorMap,
+    getErrorMap: getErrorMap
 });
 
-export { DIRTY, EMPTY_PATH, INVALID, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, 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, 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, overrideErrorMap, 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 { DIRTY, EMPTY_PATH, INVALID, OK, ParseStatus, ZodType as Schema, ZodAny, ZodArray, ZodBigInt, ZodBoolean, 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 };

package/lib/index.umd.js

@@ -6,6 +6,8 @@
 
     var util;
     (function (util) {
+        function assertEqual(_cond) { }
+        util.assertEqual = assertEqual;
         function assertNever(_x) {
             throw new Error();
         }
@@ -221,7 +223,7 @@
             return this.message;
         }
         get message() {
-            return JSON.stringify(this.issues, null, 2);
+            return JSON.stringify(this.issues, jsonStringifyReplacer, 2);
         }
         get isEmpty() {
             return this.issues.length === 0;
@@ -260,7 +262,7 @@
                 }
                 break;
             case ZodIssueCode.invalid_literal:
-                message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+                message = `Invalid literal value, expected ${JSON.stringify(issue.expected, jsonStringifyReplacer)}`;
                 break;
             case ZodIssueCode.unrecognized_keys:
                 message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
@@ -284,10 +286,23 @@
                 message = `Invalid date`;
                 break;
             case ZodIssueCode.invalid_string:
-                if (issue.validation !== "regex")
+                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 start with "${issue.validation.endsWith}"`;
+                    }
+                    else {
+                        util.assertNever(issue.validation);
+                    }
+                }
+                else if (issue.validation !== "regex") {
                     message = `Invalid ${issue.validation}`;
-                else
+                }
+                else {
                     message = "Invalid";
+                }
                 break;
             case ZodIssueCode.too_small:
                 if (issue.type === "array")
@@ -324,10 +339,13 @@
         }
         return { message };
     };
-    exports.overrideErrorMap = defaultErrorMap;
-    const setErrorMap = (map) => {
-        exports.overrideErrorMap = map;
-    };
+    let overrideErrorMap = defaultErrorMap;
+    function setErrorMap(map) {
+        overrideErrorMap = map;
+    }
+    function getErrorMap() {
+        return overrideErrorMap;
+    }
 
     const makeIssue = (params) => {
         const { data, path, errorMaps, issueData } = params;
@@ -359,7 +377,7 @@
             errorMaps: [
                 ctx.common.contextualErrorMap,
                 ctx.schemaErrorMap,
-                exports.overrideErrorMap,
+                getErrorMap(),
                 defaultErrorMap,
             ].filter((x) => !!x),
         });
@@ -426,6 +444,12 @@
     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) {
@@ -829,6 +853,28 @@
                 else if (check.kind === "trim") {
                     input.data = input.data.trim();
                 }
+                else if (check.kind === "startsWith") {
+                    if (!input.data.startsWith(check.value)) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.invalid_string,
+                            validation: { startsWith: check.value },
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
+                else if (check.kind === "endsWith") {
+                    if (!input.data.endsWith(check.value)) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.invalid_string,
+                            validation: { endsWith: check.value },
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
                 else {
                     util.assertNever(check);
                 }
@@ -860,6 +906,20 @@
                 ...errorUtil.errToObj(message),
             });
         }
+        startsWith(value, message) {
+            return this._addCheck({
+                kind: "startsWith",
+                value: value,
+                ...errorUtil.errToObj(message),
+            });
+        }
+        endsWith(value, message) {
+            return this._addCheck({
+                kind: "endsWith",
+                value: value,
+                ...errorUtil.errToObj(message),
+            });
+        }
         min(minLength, message) {
             return this._addCheck({
                 kind: "min",
@@ -2260,7 +2320,7 @@
                     errorMaps: [
                         ctx.common.contextualErrorMap,
                         ctx.schemaErrorMap,
-                        exports.overrideErrorMap,
+                        getErrorMap(),
                         defaultErrorMap,
                     ].filter((x) => !!x),
                     issueData: {
@@ -2276,7 +2336,7 @@
                     errorMaps: [
                         ctx.common.contextualErrorMap,
                         ctx.schemaErrorMap,
-                        exports.overrideErrorMap,
+                        getErrorMap(),
                         defaultErrorMap,
                     ].filter((x) => !!x),
                     issueData: {
@@ -2840,6 +2900,7 @@
         isDirty: isDirty,
         isValid: isValid,
         isAsync: isAsync,
+        jsonStringifyReplacer: jsonStringifyReplacer,
         ZodType: ZodType,
         ZodString: ZodString,
         ZodNumber: ZodNumber,
@@ -2920,8 +2981,8 @@
         quotelessJson: quotelessJson,
         ZodError: ZodError,
         defaultErrorMap: defaultErrorMap,
-        get overrideErrorMap () { return exports.overrideErrorMap; },
-        setErrorMap: setErrorMap
+        setErrorMap: setErrorMap,
+        getErrorMap: getErrorMap
     });
 
     exports.DIRTY = DIRTY;
@@ -2980,6 +3041,7 @@
     exports.effect = effectsType;
     exports["enum"] = enumType;
     exports["function"] = functionType;
+    exports.getErrorMap = getErrorMap;
     exports.getParsedType = getParsedType;
     exports["instanceof"] = instanceOfType;
     exports.intersection = intersectionType;
@@ -2987,6 +3049,7 @@
     exports.isAsync = isAsync;
     exports.isDirty = isDirty;
     exports.isValid = isValid;
+    exports.jsonStringifyReplacer = jsonStringifyReplacer;
     exports.late = late;
     exports.lazy = lazyType;
     exports.literal = literalType;

package/lib/types.d.ts

@@ -98,6 +98,14 @@ declare type ZodStringCheck = {
 } | {
     kind: "cuid";
     message?: string;
+} | {
+    kind: "startsWith";
+    value: string;
+    message?: string;
+} | {
+    kind: "endsWith";
+    value: string;
+    message?: string;
 } | {
     kind: "regex";
     regex: RegExp;
@@ -121,6 +129,8 @@ export declare class ZodString extends ZodType<string, ZodStringDef> {
     uuid(message?: errorUtil.ErrMessage): ZodString;
     cuid(message?: errorUtil.ErrMessage): ZodString;
     regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
+    startsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
+    endsWith(value: string, message?: errorUtil.ErrMessage): ZodString;
     min(minLength: number, message?: errorUtil.ErrMessage): ZodString;
     max(maxLength: number, message?: errorUtil.ErrMessage): ZodString;
     length(len: number, message?: errorUtil.ErrMessage): ZodString;
@@ -508,9 +518,9 @@ export declare class ZodFunction<Args extends ZodTuple<any, any>, Returns extend
     returnType(): Returns;
     args<Items extends Parameters<typeof ZodTuple["create"]>[0]>(...items: Items): ZodFunction<ZodTuple<Items, ZodUnknown>, Returns>;
     returns<NewReturnType extends ZodType<any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
-    implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): F;
+    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) => F;
+    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>;
 }
 export interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {

package/lib/types.js

@@ -405,6 +405,28 @@ class ZodString extends ZodType {
             else if (check.kind === "trim") {
                 input.data = input.data.trim();
             }
+            else if (check.kind === "startsWith") {
+                if (!input.data.startsWith(check.value)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    parseUtil_1.addIssueToContext(ctx, {
+                        code: ZodError_1.ZodIssueCode.invalid_string,
+                        validation: { startsWith: check.value },
+                        message: check.message,
+                    });
+                    status.dirty();
+                }
+            }
+            else if (check.kind === "endsWith") {
+                if (!input.data.endsWith(check.value)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    parseUtil_1.addIssueToContext(ctx, {
+                        code: ZodError_1.ZodIssueCode.invalid_string,
+                        validation: { endsWith: check.value },
+                        message: check.message,
+                    });
+                    status.dirty();
+                }
+            }
             else {
                 util_1.util.assertNever(check);
             }
@@ -436,6 +458,20 @@ class ZodString extends ZodType {
             ...errorUtil_1.errorUtil.errToObj(message),
         });
     }
+    startsWith(value, message) {
+        return this._addCheck({
+            kind: "startsWith",
+            value: value,
+            ...errorUtil_1.errorUtil.errToObj(message),
+        });
+    }
+    endsWith(value, message) {
+        return this._addCheck({
+            kind: "endsWith",
+            value: value,
+            ...errorUtil_1.errorUtil.errToObj(message),
+        });
+    }
     min(minLength, message) {
         return this._addCheck({
             kind: "min",
@@ -1857,7 +1893,7 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    ZodError_1.overrideErrorMap,
+                    ZodError_1.getErrorMap(),
                     ZodError_1.defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {
@@ -1873,7 +1909,7 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    ZodError_1.overrideErrorMap,
+                    ZodError_1.getErrorMap(),
                     ZodError_1.defaultErrorMap,
                 ].filter((x) => !!x),
                 issueData: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.17.4",
+  "version": "3.17.7",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "main": "./lib/index.js",
   "types": "./index.d.ts",