zod 3.20.2 → 3.20.3

package/lib/index.umd.js

@@ -478,7 +478,7 @@
     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 isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
     var errorUtil;
     (function (errorUtil) {
@@ -707,28 +707,29 @@
             return this._refinement(refinement);
         }
         optional() {
-            return ZodOptional.create(this);
+            return ZodOptional.create(this, this._def);
         }
         nullable() {
-            return ZodNullable.create(this);
+            return ZodNullable.create(this, this._def);
         }
         nullish() {
-            return this.optional().nullable();
+            return this.nullable().optional();
         }
         array() {
-            return ZodArray.create(this);
+            return ZodArray.create(this, this._def);
         }
         promise() {
-            return ZodPromise.create(this);
+            return ZodPromise.create(this, this._def);
         }
         or(option) {
-            return ZodUnion.create([this, option]);
+            return ZodUnion.create([this, option], this._def);
         }
         and(incoming) {
-            return ZodIntersection.create(this, incoming);
+            return ZodIntersection.create(this, incoming, this._def);
         }
         transform(transform) {
             return new ZodEffects({
+                ...processCreateParams(this._def),
                 schema: this,
                 typeName: exports.ZodFirstPartyTypeKind.ZodEffects,
                 effect: { type: "transform", transform },
@@ -737,6 +738,7 @@
         default(def) {
             const defaultValueFunc = typeof def === "function" ? def : () => def;
             return new ZodDefault({
+                ...processCreateParams(this._def),
                 innerType: this,
                 defaultValue: defaultValueFunc,
                 typeName: exports.ZodFirstPartyTypeKind.ZodDefault,
@@ -746,14 +748,15 @@
             return new ZodBranded({
                 typeName: exports.ZodFirstPartyTypeKind.ZodBranded,
                 type: this,
-                ...processCreateParams(undefined),
+                ...processCreateParams(this._def),
             });
         }
         catch(def) {
-            const defaultValueFunc = typeof def === "function" ? def : () => def;
+            const catchValueFunc = typeof def === "function" ? def : () => def;
             return new ZodCatch({
+                ...processCreateParams(this._def),
                 innerType: this,
-                defaultValue: defaultValueFunc,
+                catchValue: catchValueFunc,
                 typeName: exports.ZodFirstPartyTypeKind.ZodCatch,
             });
         }
@@ -775,12 +778,15 @@
         }
     }
     const cuidRegex = /^c[^\s-]{8,}$/i;
+    const cuid2Regex = /^[a-z][a-z0-9]*$/;
     const uuidRegex = /^([a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[a-f0-9]{4}-[a-f0-9]{12}|00000000-0000-0000-0000-000000000000)$/i;
     // from https://stackoverflow.com/a/46181/1550155
     // old version: too slow, didn't support unicode
     // const emailRegex = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i;
+    //old email regex
+    // const emailRegex = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@((?!-)([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{1,})[^-<>()[\].,;:\s@"]$/i;
     // eslint-disable-next-line
-    const emailRegex = /^(([^<>()[\]\.,;:\s@\"]+(\.[^<>()[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+    const emailRegex = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|([^-]([a-zA-Z0-9-]*\.)+[a-zA-Z]{2,}))$/;
     // interface IsDateStringOptions extends StringDateOptions {
     /**
      * Match any configuration
@@ -791,7 +797,7 @@
     const datetimeRegex = (args) => {
         if (args.precision) {
             if (args.offset) {
-                return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}:\\d{2})|Z)$`);
+                return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
             }
             else {
                 return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}Z$`);
@@ -799,7 +805,7 @@
         }
         else if (args.precision === 0) {
             if (args.offset) {
-                return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}:\\d{2})|Z)$`);
+                return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
             }
             else {
                 return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$`);
@@ -807,7 +813,7 @@
         }
         else {
             if (args.offset) {
-                return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}:\\d{2})|Z)$`);
+                return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
             }
             else {
                 return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`);
@@ -940,6 +946,17 @@
                         status.dirty();
                     }
                 }
+                else if (check.kind === "cuid2") {
+                    if (!cuid2Regex.test(input.data)) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            validation: "cuid2",
+                            code: ZodIssueCode.invalid_string,
+                            message: check.message,
+                        });
+                        status.dirty();
+                    }
+                }
                 else if (check.kind === "url") {
                     try {
                         new URL(input.data);
@@ -1028,6 +1045,9 @@
         cuid(message) {
             return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
         }
+        cuid2(message) {
+            return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
+        }
         datetime(options) {
             var _a;
             if (typeof options === "string") {
@@ -1102,6 +1122,9 @@
         get isCUID() {
             return !!this._def.checks.find((ch) => ch.kind === "cuid");
         }
+        get isCUID2() {
+            return !!this._def.checks.find((ch) => ch.kind === "cuid2");
+        }
         get minLength() {
             let min = null;
             for (const ch of this._def.checks) {
@@ -1342,7 +1365,27 @@
             return max;
         }
         get isInt() {
-            return !!this._def.checks.find((ch) => ch.kind === "int");
+            return !!this._def.checks.find((ch) => ch.kind === "int" ||
+                (ch.kind === "multipleOf" && exports.util.isInteger(ch.value)));
+        }
+        get isFinite() {
+            let max = null, min = null;
+            for (const ch of this._def.checks) {
+                if (ch.kind === "finite" ||
+                    ch.kind === "int" ||
+                    ch.kind === "multipleOf") {
+                    return true;
+                }
+                else if (ch.kind === "min") {
+                    if (min === null || ch.value > min)
+                        min = ch.value;
+                }
+                else if (ch.kind === "max") {
+                    if (max === null || ch.value < max)
+                        max = ch.value;
+                }
+            }
+            return Number.isFinite(min) && Number.isFinite(max);
         }
     }
     ZodNumber.create = (params) => {
@@ -1703,13 +1746,13 @@
                 }
             }
             if (ctx.common.async) {
-                return Promise.all(ctx.data.map((item, i) => {
+                return Promise.all([...ctx.data].map((item, i) => {
                     return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
                 })).then((result) => {
                     return ParseStatus.mergeArray(status, result);
                 });
             }
-            const result = ctx.data.map((item, i) => {
+            const result = [...ctx.data].map((item, i) => {
                 return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
             });
             return ParseStatus.mergeArray(status, result);
@@ -1978,10 +2021,10 @@
         }
         pick(mask) {
             const shape = {};
-            exports.util.objectKeys(mask).map((key) => {
-                // only add to shape if key corresponds to an element of the current shape
-                if (this.shape[key])
+            exports.util.objectKeys(mask).forEach((key) => {
+                if (mask[key] && this.shape[key]) {
                     shape[key] = this.shape[key];
+                }
             });
             return new ZodObject({
                 ...this._def,
@@ -1990,8 +2033,8 @@
         }
         omit(mask) {
             const shape = {};
-            exports.util.objectKeys(this.shape).map((key) => {
-                if (exports.util.objectKeys(mask).indexOf(key) === -1) {
+            exports.util.objectKeys(this.shape).forEach((key) => {
+                if (!mask[key]) {
                     shape[key] = this.shape[key];
                 }
             });
@@ -2005,26 +2048,15 @@
         }
         partial(mask) {
             const newShape = {};
-            if (mask) {
-                exports.util.objectKeys(this.shape).map((key) => {
-                    if (exports.util.objectKeys(mask).indexOf(key) === -1) {
-                        newShape[key] = this.shape[key];
-                    }
-                    else {
-                        newShape[key] = this.shape[key].optional();
-                    }
-                });
-                return new ZodObject({
-                    ...this._def,
-                    shape: () => newShape,
-                });
-            }
-            else {
-                for (const key in this.shape) {
-                    const fieldSchema = this.shape[key];
+            exports.util.objectKeys(this.shape).forEach((key) => {
+                const fieldSchema = this.shape[key];
+                if (mask && !mask[key]) {
+                    newShape[key] = fieldSchema;
+                }
+                else {
                     newShape[key] = fieldSchema.optional();
                 }
-            }
+            });
             return new ZodObject({
                 ...this._def,
                 shape: () => newShape,
@@ -2032,23 +2064,11 @@
         }
         required(mask) {
             const newShape = {};
-            if (mask) {
-                exports.util.objectKeys(this.shape).map((key) => {
-                    if (exports.util.objectKeys(mask).indexOf(key) === -1) {
-                        newShape[key] = this.shape[key];
-                    }
-                    else {
-                        const fieldSchema = this.shape[key];
-                        let newField = fieldSchema;
-                        while (newField instanceof ZodOptional) {
-                            newField = newField._def.innerType;
-                        }
-                        newShape[key] = newField;
-                    }
-                });
-            }
-            else {
-                for (const key in this.shape) {
+            exports.util.objectKeys(this.shape).forEach((key) => {
+                if (mask && !mask[key]) {
+                    newShape[key] = this.shape[key];
+                }
+                else {
                     const fieldSchema = this.shape[key];
                     let newField = fieldSchema;
                     while (newField instanceof ZodOptional) {
@@ -2056,7 +2076,7 @@
                     }
                     newShape[key] = newField;
                 }
-            }
+            });
             return new ZodObject({
                 ...this._def,
                 shape: () => newShape,
@@ -2437,7 +2457,7 @@
                 });
                 status.dirty();
             }
-            const items = ctx.data
+            const items = [...ctx.data]
                 .map((item, itemIndex) => {
                 const schema = this._def.items[itemIndex] || this._def.rest;
                 if (!schema)
@@ -2817,6 +2837,7 @@
             if (input.data !== this._def.value) {
                 const ctx = this._getOrReturnCtx(input);
                 addIssueToContext(ctx, {
+                    received: ctx.data,
                     code: ZodIssueCode.invalid_literal,
                     expected: this._def.value,
                 });
@@ -2890,6 +2911,12 @@
             }
             return enumValues;
         }
+        extract(values) {
+            return ZodEnum.create(values);
+        }
+        exclude(values) {
+            return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)));
+        }
     }
     ZodEnum.create = createZodEnum;
     class ZodNativeEnum extends ZodType {
@@ -2929,6 +2956,9 @@
         });
     };
     class ZodPromise extends ZodType {
+        unwrap() {
+            return this._def.type;
+        }
         _parse(input) {
             const { ctx } = this._processInputParams(input);
             if (ctx.parsedType !== ZodParsedType.promise &&
@@ -3168,24 +3198,30 @@
             const result = this._def.innerType._parse({
                 data: ctx.data,
                 path: ctx.path,
-                parent: ctx,
+                parent: {
+                    ...ctx,
+                    common: {
+                        ...ctx.common,
+                        issues: [], // don't collect issues from inner type
+                    },
+                },
             });
             if (isAsync(result)) {
                 return result.then((result) => {
                     return {
                         status: "valid",
-                        value: result.status === "valid" ? result.value : this._def.defaultValue(),
+                        value: result.status === "valid" ? result.value : this._def.catchValue(),
                     };
                 });
             }
             else {
                 return {
                     status: "valid",
-                    value: result.status === "valid" ? result.value : this._def.defaultValue(),
+                    value: result.status === "valid" ? result.value : this._def.catchValue(),
                 };
             }
         }
-        removeDefault() {
+        removeCatch() {
             return this._def.innerType;
         }
     }
@@ -3193,9 +3229,7 @@
         return new ZodCatch({
             innerType: type,
             typeName: exports.ZodFirstPartyTypeKind.ZodCatch,
-            defaultValue: typeof params.default === "function"
-                ? params.default
-                : () => params.default,
+            catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
             ...processCreateParams(params),
         });
     };
@@ -3390,7 +3424,10 @@
     const coerce = {
         string: ((arg) => ZodString.create({ ...arg, coerce: true })),
         number: ((arg) => ZodNumber.create({ ...arg, coerce: true })),
-        boolean: ((arg) => ZodBoolean.create({ ...arg, coerce: true })),
+        boolean: ((arg) => ZodBoolean.create({
+            ...arg,
+            coerce: true,
+        })),
         bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
         date: ((arg) => ZodDate.create({ ...arg, coerce: true })),
     };

package/lib/types.d.ts

@@ -72,7 +72,7 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     constructor(def: Def);
     optional(): ZodOptional<this>;
     nullable(): ZodNullable<this>;
-    nullish(): ZodNullable<ZodOptional<this>>;
+    nullish(): ZodOptional<ZodNullable<this>>;
     array(): ZodArray<this>;
     promise(): ZodPromise<this>;
     or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
@@ -81,8 +81,8 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     default(def: util.noUndefined<Input>): ZodDefault<this>;
     default(def: () => util.noUndefined<Input>): ZodDefault<this>;
     brand<B extends string | number | symbol>(brand?: B): ZodBranded<this, B>;
-    catch(def: Input): ZodCatch<this>;
-    catch(def: () => Input): ZodCatch<this>;
+    catch(def: Output): ZodCatch<this>;
+    catch(def: () => Output): ZodCatch<this>;
     describe(description: string): this;
     pipe<T extends ZodTypeAny>(target: T): ZodPipeline<this, T>;
     isOptional(): boolean;
@@ -112,6 +112,9 @@ export declare type ZodStringCheck = {
 } | {
     kind: "cuid";
     message?: string;
+} | {
+    kind: "cuid2";
+    message?: string;
 } | {
     kind: "startsWith";
     value: string;
@@ -146,6 +149,7 @@ export declare class ZodString extends ZodType<string, ZodStringDef> {
     url(message?: errorUtil.ErrMessage): ZodString;
     uuid(message?: errorUtil.ErrMessage): ZodString;
     cuid(message?: errorUtil.ErrMessage): ZodString;
+    cuid2(message?: errorUtil.ErrMessage): ZodString;
     datetime(options?: string | {
         message?: string | undefined;
         precision?: number | null;
@@ -168,6 +172,7 @@ export declare class ZodString extends ZodType<string, ZodStringDef> {
     get isURL(): boolean;
     get isUUID(): boolean;
     get isCUID(): boolean;
+    get isCUID2(): boolean;
     get minLength(): number | null;
     get maxLength(): number | null;
     static create: (params?: ({
@@ -234,6 +239,7 @@ export declare class ZodNumber extends ZodType<number, ZodNumberDef> {
     get minValue(): number | null;
     get maxValue(): number | null;
     get isInt(): boolean;
+    get isFinite(): boolean;
 }
 export interface ZodBigIntDef extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodBigInt;
@@ -420,8 +426,14 @@ export declare type objectInputType<Shape extends ZodRawShape, Catchall extends
     [k: string]: Catchall["_input"];
 }>;
 export declare type deoptional<T extends ZodTypeAny> = T extends ZodOptional<infer U> ? deoptional<U> : T extends ZodNullable<infer U> ? ZodNullable<deoptional<U>> : T;
-export declare type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny, any, any>;
-export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam = "strip", Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
+export declare type SomeZodObject = ZodObject<ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+export declare type objectKeyMask<Obj> = {
+    [k in keyof Obj]?: true;
+};
+export declare type noUnrecognized<Obj extends object, Shape extends object> = {
+    [k in keyof Obj]: k extends keyof Shape ? Obj[k] : never;
+};
+export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends UnknownKeysParam, Catchall extends ZodTypeAny = ZodTypeAny, Output = objectOutputType<T, Catchall>, Input = objectInputType<T, Catchall>> extends ZodType<Output, ZodObjectDef<T, UnknownKeys, Catchall>, Input> {
     private _cached;
     _getCached(): {
         shape: T;
@@ -449,27 +461,19 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
      */
     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;
-    }>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-    omit<Mask extends {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+    pick<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, T>): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+    omit<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
     deepPartial(): partialUtil.DeepPartial<this>;
     partial(): ZodObject<{
         [k in keyof T]: ZodOptional<T[k]>;
     }, UnknownKeys, Catchall>;
-    partial<Mask extends {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+    partial<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<objectUtil.noNever<{
         [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     required(): ZodObject<{
         [k in keyof T]: deoptional<T[k]>;
     }, UnknownKeys, Catchall>;
-    required<Mask extends {
-        [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+    required<Mask extends objectKeyMask<T>>(mask: noUnrecognized<Mask, objectKeyMask<T>>): ZodObject<objectUtil.noNever<{
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
@@ -494,8 +498,8 @@ export declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[numbe
 }
 export declare type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
     [key in Discriminator]: ZodTypeAny;
-} & ZodRawShape, any, any>;
-export interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<any>[] = ZodDiscriminatedUnionOption<any>[]> extends ZodTypeDef {
+} & ZodRawShape, UnknownKeysParam, ZodTypeAny>;
+export interface ZodDiscriminatedUnionDef<Discriminator extends string, Options extends ZodDiscriminatedUnionOption<string>[] = ZodDiscriminatedUnionOption<string>[]> extends ZodTypeDef {
     discriminator: Discriminator;
     options: Options;
     optionsMap: Map<Primitive, ZodDiscriminatedUnionOption<any>>;
@@ -651,6 +655,7 @@ export interface ZodEnumDef<T extends EnumValues = EnumValues> extends ZodTypeDe
 export declare type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
 };
+export declare type FilterEnum<Values, ToExclude> = Values extends [] ? [] : Values extends [infer Head, ...infer Rest] ? Head extends ToExclude ? FilterEnum<Rest, ToExclude> : [Head, ...FilterEnum<Rest, ToExclude>] : never;
 declare function createZodEnum<U extends string, T extends Readonly<[U, ...U[]]>>(values: T, params?: RawCreateParams): ZodEnum<Writeable<T>>;
 declare function createZodEnum<U extends string, T extends [U, ...U[]]>(values: T, params?: RawCreateParams): ZodEnum<T>;
 export declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>> {
@@ -659,6 +664,8 @@ export declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[
     get enum(): Values<T>;
     get Values(): Values<T>;
     get Enum(): Values<T>;
+    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract): ZodEnum<Writeable<ToExtract>>;
+    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude): ZodEnum<Writeable<FilterEnum<T, ToExclude[number]>>>;
     static create: typeof createZodEnum;
 }
 export interface ZodNativeEnumDef<T extends EnumLike = EnumLike> extends ZodTypeDef {
@@ -679,6 +686,7 @@ export interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTyp
     typeName: ZodFirstPartyTypeKind.ZodPromise;
 }
 export declare class ZodPromise<T extends ZodTypeAny> extends ZodType<Promise<T["_output"]>, ZodPromiseDef<T>, Promise<T["_input"]>> {
+    unwrap(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
 }
@@ -747,21 +755,21 @@ export declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUnd
         default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
     }) => ZodDefault<T_1>;
 }
-export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
+export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny, C extends T["_input"] = T["_input"]> extends ZodTypeDef {
     innerType: T;
-    defaultValue: () => T["_input"];
+    catchValue: () => C;
     typeName: ZodFirstPartyTypeKind.ZodCatch;
 }
-export declare class ZodCatch<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodCatchDef<T>, T["_input"] | undefined> {
+export declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, T["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    removeDefault(): T;
+    removeCatch(): T;
     static create: <T_1 extends ZodTypeAny>(type: T_1, params: {
         errorMap?: ZodErrorMap | undefined;
         invalid_type_error?: string | undefined;
         required_error?: string | undefined;
         description?: string | undefined;
     } & {
-        default: T_1["_input"] | (() => T_1["_input"]);
+        catch: T_1["_output"] | (() => T_1["_output"]);
     }) => ZodCatch<T_1>;
 }
 export interface ZodNaNDef extends ZodTypeDef {
@@ -836,7 +844,7 @@ export declare enum ZodFirstPartyTypeKind {
     ZodBranded = "ZodBranded",
     ZodPipeline = "ZodPipeline"
 }
-export declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any>;
+export declare type ZodFirstPartySchemaTypes = ZodString | ZodNumber | ZodNaN | ZodBigInt | ZodBoolean | ZodDate | ZodUndefined | ZodNull | ZodAny | ZodUnknown | ZodNever | ZodVoid | ZodArray<any, any> | ZodObject<any, any, any> | ZodUnion<any> | ZodDiscriminatedUnion<any, any> | ZodIntersection<any, any> | ZodTuple<any, any> | ZodRecord<any, any> | ZodMap<any> | ZodSet<any> | ZodFunction<any, any> | ZodLazy<any> | ZodLiteral<any> | ZodEnum<any> | ZodEffects<any, any, any> | ZodNativeEnum<any> | ZodOptional<any> | ZodNullable<any> | ZodDefault<any> | ZodCatch<any> | ZodPromise<any> | ZodBranded<any, any> | ZodPipeline<any, any>;
 declare abstract class Class {
     constructor(..._: any[]);
 }