zod 3.17.6 → 3.17.9

package/README.md

@@ -63,6 +63,7 @@
 - [Nullables](#nullables)
 - [Objects](#objects)
   - [.shape](#shape)
+  - [.enum](#enum)
   - [.extend](#extend)
   - [.merge](#merge)
   - [.pick/.omit](#pickomit)
@@ -550,14 +551,32 @@ const isActive = z.boolean({
 
 ## Dates
 
-z.date() accepts a date, not a date string
+Use z.date() to validate `Date` instances.
 
 ```ts
 z.date().safeParse(new Date()); // success: true
 z.date().safeParse("2022-01-12T00:00:00.000Z"); // success: false
 ```
 
-To allow for dates or date strings, you can use preprocess
+You can customize certain error messages when creating a boolean schema.
+
+```ts
+const myDateSchema = z.date({
+  required_error: "Please select a date and time",
+  invalid_type_error: "That's not a date!",
+});
+```
+
+Zod provides a handful of date-specific validations.
+
+```ts
+z.date().min(new Date("1900-01-01"), { message: "Too old" });
+z.date().max(new Date(), { message: "Too young!" });
+```
+
+**Supporting date strings**
+
+To write a schema that accepts either a `Date` or a date string, use (`z.preprocess`)[#preprocess].
 
 ```ts
 const dateSchema = z.preprocess((arg) => {
@@ -764,6 +783,15 @@ Dog.shape.name; // => string schema
 Dog.shape.age; // => number schema
 ```
 
+### `.keyof`
+
+Use `.key` to create a `ZodEnum` schema from the keys of an object schema.
+
+```ts
+const keySchema = Dog.keyof();
+keySchema; // ZodEnum<["name", "age"]>
+```
+
 ### `.extend`
 
 You can add additional fields to an object schema with the `.extend` method.
@@ -1772,7 +1800,7 @@ z.optional(z.string());
 
 ### `.nullable`
 
-A convenience method that returns an nullable version of a schema.
+A convenience method that returns a nullable version of a schema.
 
 ```ts
 const nullableString = z.string().nullable(); // string | null

package/lib/ZodError.d.ts

@@ -81,13 +81,13 @@ export interface ZodTooSmallIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_small;
     minimum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number" | "set";
+    type: "array" | "string" | "number" | "set" | "date";
 }
 export interface ZodTooBigIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.too_big;
     maximum: number;
     inclusive: boolean;
-    type: "array" | "string" | "number" | "set";
+    type: "array" | "string" | "number" | "set" | "date";
 }
 export interface ZodInvalidIntersectionTypesIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.invalid_intersection_types;

package/lib/ZodError.js

@@ -191,6 +191,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 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;
@@ -201,6 +203,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 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;

package/lib/helpers/enumUtil.d.ts

@@ -0,0 +1,8 @@
+export declare namespace enumUtil {
+    type UnionToIntersectionFn<T> = (T extends unknown ? (k: () => T) => void : never) extends (k: infer Intersection) => void ? Intersection : never;
+    type GetUnionLast<T> = UnionToIntersectionFn<T> extends () => infer Last ? Last : never;
+    type UnionToTuple<T, Tuple extends unknown[] = []> = [T] extends [never] ? Tuple : UnionToTuple<Exclude<T, GetUnionLast<T>>, [GetUnionLast<T>, ...Tuple]>;
+    type CastToStringTuple<T> = T extends [string, ...string[]] ? T : never;
+    export type UnionToTupleString<T> = CastToStringTuple<UnionToTuple<T>>;
+    export {};
+}

package/lib/helpers/enumUtil.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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();
     }
@@ -303,6 +305,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 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;
@@ -313,6 +317,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 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;
@@ -484,11 +490,10 @@ function processCreateParams(params) {
     const customMap = (iss, ctx) => {
         if (iss.code !== "invalid_type")
             return { message: ctx.defaultError };
-        if (typeof ctx.data === "undefined" && required_error)
-            return { message: required_error };
-        if (params.invalid_type_error)
-            return { message: params.invalid_type_error };
-        return { message: ctx.defaultError };
+        if (typeof ctx.data === "undefined") {
+            return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError };
+        }
+        return { message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError };
     };
     return { errorMap: customMap, description };
 }
@@ -1229,14 +1234,88 @@ class ZodDate extends ZodType {
             });
             return INVALID;
         }
+        const status = new ParseStatus();
+        let ctx = undefined;
+        for (const check of this._def.checks) {
+            if (check.kind === "min") {
+                if (input.data.getTime() < check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_small,
+                        message: check.message,
+                        inclusive: true,
+                        minimum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else if (check.kind === "max") {
+                if (input.data.getTime() > check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_big,
+                        message: check.message,
+                        inclusive: true,
+                        maximum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else {
+                util.assertNever(check);
+            }
+        }
         return {
-            status: "valid",
+            status: status.value,
             value: new Date(input.data.getTime()),
         };
     }
+    _addCheck(check) {
+        return new ZodDate({
+            ...this._def,
+            checks: [...this._def.checks, check],
+        });
+    }
+    min(minDate, message) {
+        return this._addCheck({
+            kind: "min",
+            value: minDate.getTime(),
+            message: errorUtil.toString(message),
+        });
+    }
+    max(maxDate, message) {
+        return this._addCheck({
+            kind: "max",
+            value: maxDate.getTime(),
+            message: errorUtil.toString(message),
+        });
+    }
+    get minDate() {
+        let min = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "min") {
+                if (min === null || ch.value > min)
+                    min = ch.value;
+            }
+        }
+        return min != null ? new Date(min) : null;
+    }
+    get maxDate() {
+        let max = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "max") {
+                if (max === null || ch.value < max)
+                    max = ch.value;
+            }
+        }
+        return max != null ? new Date(max) : null;
+    }
 }
 ZodDate.create = (params) => {
     return new ZodDate({
+        checks: [],
         typeName: ZodFirstPartyTypeKind.ZodDate,
         ...processCreateParams(params),
     });
@@ -1725,6 +1804,9 @@ class ZodObject extends ZodType {
             shape: () => newShape,
         });
     }
+    keyof() {
+        return createZodEnum(util.objectKeys(this.shape));
+    }
 }
 ZodObject.create = (shape, params) => {
     return new ZodObject({

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();
         }
@@ -309,6 +311,8 @@
                     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;
@@ -319,6 +323,8 @@
                     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;
@@ -490,11 +496,10 @@
         const customMap = (iss, ctx) => {
             if (iss.code !== "invalid_type")
                 return { message: ctx.defaultError };
-            if (typeof ctx.data === "undefined" && required_error)
-                return { message: required_error };
-            if (params.invalid_type_error)
-                return { message: params.invalid_type_error };
-            return { message: ctx.defaultError };
+            if (typeof ctx.data === "undefined") {
+                return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError };
+            }
+            return { message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError };
         };
         return { errorMap: customMap, description };
     }
@@ -1235,14 +1240,88 @@
                 });
                 return INVALID;
             }
+            const status = new ParseStatus();
+            let ctx = undefined;
+            for (const check of this._def.checks) {
+                if (check.kind === "min") {
+                    if (input.data.getTime() < check.value) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.too_small,
+                            message: check.message,
+                            inclusive: true,
+                            minimum: check.value,
+                            type: "date",
+                        });
+                        status.dirty();
+                    }
+                }
+                else if (check.kind === "max") {
+                    if (input.data.getTime() > check.value) {
+                        ctx = this._getOrReturnCtx(input, ctx);
+                        addIssueToContext(ctx, {
+                            code: ZodIssueCode.too_big,
+                            message: check.message,
+                            inclusive: true,
+                            maximum: check.value,
+                            type: "date",
+                        });
+                        status.dirty();
+                    }
+                }
+                else {
+                    util.assertNever(check);
+                }
+            }
             return {
-                status: "valid",
+                status: status.value,
                 value: new Date(input.data.getTime()),
             };
         }
+        _addCheck(check) {
+            return new ZodDate({
+                ...this._def,
+                checks: [...this._def.checks, check],
+            });
+        }
+        min(minDate, message) {
+            return this._addCheck({
+                kind: "min",
+                value: minDate.getTime(),
+                message: errorUtil.toString(message),
+            });
+        }
+        max(maxDate, message) {
+            return this._addCheck({
+                kind: "max",
+                value: maxDate.getTime(),
+                message: errorUtil.toString(message),
+            });
+        }
+        get minDate() {
+            let min = null;
+            for (const ch of this._def.checks) {
+                if (ch.kind === "min") {
+                    if (min === null || ch.value > min)
+                        min = ch.value;
+                }
+            }
+            return min != null ? new Date(min) : null;
+        }
+        get maxDate() {
+            let max = null;
+            for (const ch of this._def.checks) {
+                if (ch.kind === "max") {
+                    if (max === null || ch.value < max)
+                        max = ch.value;
+                }
+            }
+            return max != null ? new Date(max) : null;
+        }
     }
     ZodDate.create = (params) => {
         return new ZodDate({
+            checks: [],
             typeName: exports.ZodFirstPartyTypeKind.ZodDate,
             ...processCreateParams(params),
         });
@@ -1731,6 +1810,9 @@
                 shape: () => newShape,
             });
         }
+        keyof() {
+            return createZodEnum(util.objectKeys(this.shape));
+        }
     }
     ZodObject.create = (shape, params) => {
         return new ZodObject({

package/lib/types.d.ts

@@ -1,3 +1,4 @@
+import { enumUtil } from "./helpers/enumUtil";
 import { errorUtil } from "./helpers/errorUtil";
 import { AsyncParseReturnType, ParseContext, ParseInput, ParseParams, ParseReturnType, ParseStatus, SyncParseReturnType } from "./helpers/parseUtil";
 import { partialUtil } from "./helpers/partialUtil";
@@ -214,11 +215,26 @@ export declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef> {
     _parse(input: ParseInput): ParseReturnType<boolean>;
     static create: (params?: RawCreateParams) => ZodBoolean;
 }
+declare type ZodDateCheck = {
+    kind: "min";
+    value: number;
+    message?: string;
+} | {
+    kind: "max";
+    value: number;
+    message?: string;
+};
 export interface ZodDateDef extends ZodTypeDef {
+    checks: ZodDateCheck[];
     typeName: ZodFirstPartyTypeKind.ZodDate;
 }
 export declare class ZodDate extends ZodType<Date, ZodDateDef> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
+    _addCheck(check: ZodDateCheck): ZodDate;
+    min(minDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+    max(maxDate: Date, message?: errorUtil.ErrMessage): ZodDate;
+    get minDate(): Date | null;
+    get maxDate(): Date | null;
     static create: (params?: RawCreateParams) => ZodDate;
 }
 export interface ZodUndefinedDef extends ZodTypeDef {
@@ -385,6 +401,7 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
     required(): ZodObject<{
         [k in keyof T]: deoptional<T[k]>;
     }, UnknownKeys, Catchall>;
+    keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
     static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
     static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
     static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>]: objectUtil.addQuestionMarks<{ [k in keyof T_1]: T_1[k]["_output"]; }>[k_1]; }, { [k_3 in keyof objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>]: objectUtil.addQuestionMarks<{ [k_2 in keyof T_1]: T_1[k_2]["_input"]; }>[k_3]; }>;
@@ -459,7 +476,7 @@ export declare class ZodTuple<T extends [ZodTypeAny, ...ZodTypeAny[]] | [] = [Zo
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
     rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T_1 extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
+    static create: <T_1 extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
 }
 export interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     valueType: Value;
@@ -518,9 +535,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 {
@@ -707,7 +724,7 @@ declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCr
 declare const unionType: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
 declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
 declare const intersectionType: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T, right: U, params?: RawCreateParams) => ZodIntersection<T, U>;
-declare const tupleType: <T extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: T, params?: RawCreateParams) => ZodTuple<T, null>;
+declare const tupleType: <T extends [] | [ZodTypeAny, ...ZodTypeAny[]]>(schemas: T, params?: RawCreateParams) => ZodTuple<T, null>;
 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>;

package/lib/types.js

@@ -41,11 +41,10 @@ function processCreateParams(params) {
     const customMap = (iss, ctx) => {
         if (iss.code !== "invalid_type")
             return { message: ctx.defaultError };
-        if (typeof ctx.data === "undefined" && required_error)
-            return { message: required_error };
-        if (params.invalid_type_error)
-            return { message: params.invalid_type_error };
-        return { message: ctx.defaultError };
+        if (typeof ctx.data === "undefined") {
+            return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError };
+        }
+        return { message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError };
     };
     return { errorMap: customMap, description };
 }
@@ -793,15 +792,89 @@ class ZodDate extends ZodType {
             });
             return parseUtil_1.INVALID;
         }
+        const status = new parseUtil_1.ParseStatus();
+        let ctx = undefined;
+        for (const check of this._def.checks) {
+            if (check.kind === "min") {
+                if (input.data.getTime() < check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    parseUtil_1.addIssueToContext(ctx, {
+                        code: ZodError_1.ZodIssueCode.too_small,
+                        message: check.message,
+                        inclusive: true,
+                        minimum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else if (check.kind === "max") {
+                if (input.data.getTime() > check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    parseUtil_1.addIssueToContext(ctx, {
+                        code: ZodError_1.ZodIssueCode.too_big,
+                        message: check.message,
+                        inclusive: true,
+                        maximum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else {
+                util_1.util.assertNever(check);
+            }
+        }
         return {
-            status: "valid",
+            status: status.value,
             value: new Date(input.data.getTime()),
         };
     }
+    _addCheck(check) {
+        return new ZodDate({
+            ...this._def,
+            checks: [...this._def.checks, check],
+        });
+    }
+    min(minDate, message) {
+        return this._addCheck({
+            kind: "min",
+            value: minDate.getTime(),
+            message: errorUtil_1.errorUtil.toString(message),
+        });
+    }
+    max(maxDate, message) {
+        return this._addCheck({
+            kind: "max",
+            value: maxDate.getTime(),
+            message: errorUtil_1.errorUtil.toString(message),
+        });
+    }
+    get minDate() {
+        let min = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "min") {
+                if (min === null || ch.value > min)
+                    min = ch.value;
+            }
+        }
+        return min != null ? new Date(min) : null;
+    }
+    get maxDate() {
+        let max = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "max") {
+                if (max === null || ch.value < max)
+                    max = ch.value;
+            }
+        }
+        return max != null ? new Date(max) : null;
+    }
 }
 exports.ZodDate = ZodDate;
 ZodDate.create = (params) => {
     return new ZodDate({
+        checks: [],
         typeName: ZodFirstPartyTypeKind.ZodDate,
         ...processCreateParams(params),
     });
@@ -1298,6 +1371,9 @@ class ZodObject extends ZodType {
             shape: () => newShape,
         });
     }
+    keyof() {
+        return createZodEnum(util_1.util.objectKeys(this.shape));
+    }
 }
 exports.ZodObject = ZodObject;
 ZodObject.create = (shape, params) => {

package/package.json

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