zod - npm Package Compare versions

Comparing version 3.22.4 to 3.23.0-beta.0

lib/benchmarks/index.js

@@ -6,3 +6,5 @@ "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const datetime_1 = __importDefault(require("./datetime"));
 const discriminatedUnion_1 = __importDefault(require("./discriminatedUnion"));
+const ipv4_1 = __importDefault(require("./ipv4"));
 const object_1 = __importDefault(require("./object"));
@@ -42,7 +44,18 @@ const primitives_1 = __importDefault(require("./primitives"));
     if (argv.includes("--discriminatedUnion")) {
-        suites.push(...discriminatedUnion_1.default.suites);
+        suites.push(...datetime_1.default.suites);
     }
+    if (argv.includes("--datetime")) {
+        suites.push(...datetime_1.default.suites);
+    }
+    if (argv.includes("--ipv4")) {
+        suites.push(...ipv4_1.default.suites);
+    }
 }
 for (const suite of suites) {
-    suite.run();
+    suite.run({});
 }
+// exit on Ctrl-C
+process.on("SIGINT", function () {
+    console.log("Exiting...");
+    process.exit();
+});

lib/benchmarks/primitives.js

@@ -25,2 +25,35 @@ "use strict";
 });
+const longEnumSuite = new benchmark_1.default.Suite("long z.enum");
+const longEnumSchema = index_1.z.enum([
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "eleven",
+    "twelve",
+    "thirteen",
+    "fourteen",
+    "fifteen",
+    "sixteen",
+    "seventeen",
+]);
+longEnumSuite
+    .add("valid", () => {
+    longEnumSchema.parse("five");
+})
+    .add("invalid", () => {
+    try {
+        longEnumSchema.parse("invalid");
+    }
+    catch (e) { }
+})
+    .on("cycle", (e) => {
+    console.log(`long z.enum: ${e.target}`);
+});
 const undefinedSuite = new benchmark_1.default.Suite("z.undefined");
@@ -131,2 +164,3 @@ const undefinedSchema = index_1.z.undefined();
         enumSuite,
+        longEnumSuite,
         undefinedSuite,
@@ -133,0 +167,0 @@ literalSuite,

lib/helpers/parseUtil.d.ts

@@ -77,3 +77,3 @@ import type { IssueData, ZodErrorMap, ZodIssue } from "../ZodError";
 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 isValid: <T>(x: ParseReturnType<T>) => x is OK<T>;
 export declare const isAsync: <T>(x: ParseReturnType<T>) => x is AsyncParseReturnType<T>;

lib/helpers/parseUtil.js

@@ -16,2 +16,9 @@ "use strict";
     };
+    if (issueData.message !== undefined) {
+        return {
+            ...issueData,
+            path: fullPath,
+            message: issueData.message,
+        };
+    }
     let errorMessage = "";
@@ -28,3 +35,3 @@ const maps = errorMaps
         path: fullPath,
-        message: issueData.message || errorMessage,
+        message: errorMessage,
     };
@@ -35,2 +42,3 @@ };
 function addIssueToContext(ctx, issueData) {
+    const overrideMap = (0, errors_1.getErrorMap)();
     const issue = (0, exports.makeIssue)({
@@ -43,4 +51,4 @@ issueData: issueData,
             ctx.schemaErrorMap,
-            (0, errors_1.getErrorMap)(),
-            en_1.default, // then global default map
+            overrideMap,
+            overrideMap === en_1.default ? undefined : en_1.default, // then global default map
         ].filter((x) => !!x),
@@ -77,5 +85,7 @@ });
         for (const pair of pairs) {
+            const key = await pair.key;
+            const value = await pair.value;
             syncPairs.push({
-                key: await pair.key,
-                value: await pair.value,
+                key,
+                value,
             });
@@ -82,0 +92,0 @@ }

lib/helpers/util.d.ts

@@ -10,2 +10,3 @@ export declare namespace util {
     export type MakePartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+    export type Exactly<T, X> = T & Record<Exclude<keyof X, keyof T>, never>;
     export const arrayToEnum: <T extends string, U extends [T, ...T[]]>(items: U) => { [k in U[number]]: k; };
@@ -28,6 +29,17 @@ export const getValidEnumValues: (obj: any) => any[];
     } & V;
+    type optionalKeys<T extends object> = {
+        [k in keyof T]: undefined extends T[k] ? k : never;
+    }[keyof T];
     type requiredKeys<T extends object> = {
         [k in keyof T]: undefined extends T[k] ? never : k;
     }[keyof T];
-    export type addQuestionMarks<T extends object, R extends keyof T = requiredKeys<T>> = Pick<Required<T>, R> & Partial<T>;
+    type pickRequired<T extends object, R extends keyof T = requiredKeys<T>> = {
+        [k in R]: T[k];
+    };
+    type pickOptional<T extends object, O extends keyof T = optionalKeys<T>> = {
+        [k in O]?: T[k];
+    };
+    export type addQuestionMarks<T extends object> = pickRequired<T> & pickOptional<T> & {
+        [k in keyof T]?: unknown;
+    };
     export type identity<T> = T;
@@ -34,0 +46,0 @@ export type flatten<T> = identity<{

lib/types.d.ts

@@ -29,2 +29,3 @@ import { enumUtil } from "./helpers/enumUtil";
     required_error?: string;
+    message?: string;
     description?: string;
@@ -39,2 +40,3 @@ } | undefined;
     data: Output;
+    error?: never;
 };
@@ -44,5 +46,6 @@ export declare type SafeParseError<Input> = {
     error: ZodError<Input>;
+    data?: never;
 };
 export declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+export declare abstract class ZodType<Output = unknown, Def extends ZodTypeDef = ZodTypeDef, Input = unknown> {
     readonly _type: Output;
@@ -125,2 +128,5 @@ readonly _output: Output;
 } | {
+    kind: "nanoid";
+    message?: string;
+} | {
     kind: "cuid";
@@ -163,8 +169,22 @@ message?: string;
     offset: boolean;
+    local: boolean;
     precision: number | null;
     message?: string;
 } | {
+    kind: "date";
+    message?: string;
+} | {
+    kind: "time";
+    precision: number | null;
+    message?: string;
+} | {
+    kind: "duration";
+    message?: string;
+} | {
     kind: "ip";
     version?: IpVersion;
     message?: string;
+} | {
+    kind: "base64";
+    message?: string;
 };
@@ -176,3 +196,8 @@ export interface ZodStringDef extends ZodTypeDef {
 }
-export declare class ZodString extends ZodType<string, ZodStringDef> {
+export declare function datetimeRegex(args: {
+    precision?: number | null;
+    offset?: boolean;
+    local?: boolean;
+}): RegExp;
+export declare class ZodString extends ZodType<string, ZodStringDef, string> {
     _parse(input: ParseInput): ParseReturnType<string>;
@@ -185,5 +210,7 @@ protected _regex(regex: RegExp, validation: StringValidation, message?: errorUtil.ErrMessage): ZodEffects<this, string, string>;
     uuid(message?: errorUtil.ErrMessage): ZodString;
+    nanoid(message?: errorUtil.ErrMessage): ZodString;
     cuid(message?: errorUtil.ErrMessage): ZodString;
     cuid2(message?: errorUtil.ErrMessage): ZodString;
     ulid(message?: errorUtil.ErrMessage): ZodString;
+    base64(message?: errorUtil.ErrMessage): ZodString;
     ip(options?: string | {
@@ -197,3 +224,10 @@ version?: "v4" | "v6";
         offset?: boolean;
+        local?: boolean;
     }): ZodString;
+    date(message?: string): ZodString;
+    time(options?: string | {
+        message?: string | undefined;
+        precision?: number | null;
+    }): ZodString;
+    duration(message?: errorUtil.ErrMessage): ZodString;
     regex(regex: RegExp, message?: errorUtil.ErrMessage): ZodString;
@@ -218,2 +252,5 @@ includes(value: string, options?: {
     get isDatetime(): boolean;
+    get isDate(): boolean;
+    get isTime(): boolean;
+    get isDuration(): boolean;
     get isEmail(): boolean;
@@ -223,2 +260,3 @@ get isURL(): boolean;
     get isUUID(): boolean;
+    get isNANOID(): boolean;
     get isCUID(): boolean;
@@ -228,2 +266,3 @@ get isCUID2(): boolean;
     get isIP(): boolean;
+    get isBase64(): boolean;
     get minLength(): number | null;
@@ -235,2 +274,3 @@ get maxLength(): number | null;
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -267,3 +307,3 @@ } & {
 }
-export declare class ZodNumber extends ZodType<number, ZodNumberDef> {
+export declare class ZodNumber extends ZodType<number, ZodNumberDef, number> {
     _parse(input: ParseInput): ParseReturnType<number>;
@@ -274,2 +314,3 @@ static create: (params?: ({
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -321,3 +362,3 @@ } & {
 }
-export declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef> {
+export declare class ZodBigInt extends ZodType<bigint, ZodBigIntDef, bigint> {
     _parse(input: ParseInput): ParseReturnType<bigint>;
@@ -328,2 +369,3 @@ static create: (params?: ({
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -353,3 +395,3 @@ } & {
 }
-export declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef> {
+export declare class ZodBoolean extends ZodType<boolean, ZodBooleanDef, boolean> {
     _parse(input: ParseInput): ParseReturnType<boolean>;
@@ -360,2 +402,3 @@ static create: (params?: ({
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -380,3 +423,3 @@ } & {
 }
-export declare class ZodDate extends ZodType<Date, ZodDateDef> {
+export declare class ZodDate extends ZodType<Date, ZodDateDef, Date> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -392,2 +435,3 @@ _addCheck(check: ZodDateCheck): ZodDate;
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -408,3 +452,3 @@ } & {
 }
-export declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef> {
+export declare class ZodUndefined extends ZodType<undefined, ZodUndefinedDef, undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -417,3 +461,3 @@ params?: RawCreateParams;
 }
-export declare class ZodNull extends ZodType<null, ZodNullDef> {
+export declare class ZodNull extends ZodType<null, ZodNullDef, null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -425,3 +469,3 @@ static create: (params?: RawCreateParams) => ZodNull;
 }
-export declare class ZodAny extends ZodType<any, ZodAnyDef> {
+export declare class ZodAny extends ZodType<any, ZodAnyDef, any> {
     _any: true;
@@ -434,3 +478,3 @@ _parse(input: ParseInput): ParseReturnType<this["_output"]>;
 }
-export declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef> {
+export declare class ZodUnknown extends ZodType<unknown, ZodUnknownDef, unknown> {
     _unknown: true;
@@ -443,3 +487,3 @@ _parse(input: ParseInput): ParseReturnType<this["_output"]>;
 }
-export declare class ZodNever extends ZodType<never, ZodNeverDef> {
+export declare class ZodNever extends ZodType<never, ZodNeverDef, never> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -451,3 +495,3 @@ static create: (params?: RawCreateParams) => ZodNever;
 }
-export declare class ZodVoid extends ZodType<void, ZodVoidDef> {
+export declare class ZodVoid extends ZodType<void, ZodVoidDef, void> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -502,6 +546,6 @@ static create: (params?: RawCreateParams) => ZodVoid;
 }>;
-export declare type CatchallOutput<T extends ZodTypeAny> = ZodTypeAny extends T ? unknown : {
+export declare type CatchallOutput<T extends ZodType> = ZodType extends T ? unknown : {
     [k: string]: T["_output"];
 };
-export declare type CatchallInput<T extends ZodTypeAny> = ZodTypeAny extends T ? unknown : {
+export declare type CatchallInput<T extends ZodType> = ZodType extends T ? unknown : {
     [k: string]: T["_input"];
@@ -548,8 +592,8 @@ };
     catchall<Index extends ZodTypeAny>(index: Index): ZodObject<T, UnknownKeys, Index>;
-    pick<Mask extends {
+    pick<Mask extends util.Exactly<{
         [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
-    omit<Mask extends {
+    }, Mask>>(mask: Mask): ZodObject<Pick<T, Extract<keyof T, keyof Mask>>, UnknownKeys, Catchall>;
+    omit<Mask extends util.Exactly<{
         [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
+    }, Mask>>(mask: Mask): ZodObject<Omit<T, keyof Mask>, UnknownKeys, Catchall>;
     /**
@@ -562,5 +606,5 @@ * @deprecated
     }, UnknownKeys, Catchall>;
-    partial<Mask extends {
+    partial<Mask extends util.Exactly<{
         [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+    }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
         [k in keyof T]: k extends keyof Mask ? ZodOptional<T[k]> : T[k];
@@ -571,11 +615,11 @@ }>, UnknownKeys, Catchall>;
     }, UnknownKeys, Catchall>;
-    required<Mask extends {
+    required<Mask extends util.Exactly<{
         [k in keyof T]?: true;
-    }>(mask: Mask): ZodObject<objectUtil.noNever<{
+    }, Mask>>(mask: Mask): ZodObject<objectUtil.noNever<{
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : 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<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
-    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
-    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>, { [k in keyof baseObjectOutputType<T_1>]: undefined extends baseObjectOutputType<T_1>[k] ? never : k; }[keyof T_1]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_2]; }>;
+    static create: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>>[k]; }, { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1]; }>;
+    static strictCreate: <T_1 extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>>[k]; }, { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1]; }>;
+    static lazycreate: <T_1 extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T_1>>]: objectUtil.addQuestionMarks<baseObjectOutputType<T_1>>[k]; }, { [k_1 in keyof baseObjectInputType<T_1>]: baseObjectInputType<T_1>[k_1]; }>;
 }
@@ -636,7 +680,7 @@ export declare type AnyZodObject = ZodObject<any, any, any>;
 export declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
-    [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_output"] : never;
+    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_output"] : never;
 }>;
 export declare type OutputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...OutputTypeOfTuple<T>, ...Rest["_output"][]] : OutputTypeOfTuple<T>;
 export declare type InputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
-    [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_input"] : never;
+    [k in keyof T]: T[k] extends ZodType<any, any, any> ? T[k]["_input"] : never;
 }>;
@@ -719,3 +763,3 @@ export declare type InputTypeOfTupleWithRest<T extends ZodTupleItems | [], Rest extends ZodTypeAny | null = null> = Rest extends ZodTypeAny ? [...InputTypeOfTuple<T>, ...Rest["_input"][]] : InputTypeOfTuple<T>;
     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>;
+    returns<NewReturnType extends ZodType<any, any, any>>(returnType: NewReturnType): ZodFunction<Args, NewReturnType>;
     implement<F extends InnerTypeOfFunction<Args, Returns>>(func: F): ReturnType<F> extends Returns["_output"] ? (...args: Args["_input"]) => ReturnType<F> : OuterTypeOfFunction<Args, Returns>;
@@ -742,3 +786,3 @@ strictImplement(func: InnerTypeOfFunction<Args, Returns>): InnerTypeOfFunction<Args, Returns>;
 }
-export declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>> {
+export declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -750,3 +794,3 @@ get value(): T;
 export declare type Indices<T> = Exclude<keyof T, ArrayKeys>;
-export declare type EnumValues = [string, ...string[]];
+export declare type EnumValues<T extends string = string> = [T, ...T[]];
 export declare type Values<T extends EnumValues> = {
@@ -766,3 +810,4 @@ [k in T[number]]: k;
 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>> {
+export declare class ZodEnum<T extends [string, ...string[]]> extends ZodType<T[number], ZodEnumDef<T>, T[number]> {
+    #private;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
@@ -773,4 +818,4 @@ get options(): 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<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
+    extract<ToExtract extends readonly [T[number], ...T[number][]]>(values: ToExtract, newDef?: RawCreateParams): ZodEnum<Writeable<ToExtract>>;
+    exclude<ToExclude extends readonly [T[number], ...T[number][]]>(values: ToExclude, newDef?: RawCreateParams): ZodEnum<typecast<Writeable<FilterEnum<T, ToExclude[number]>>, [string, ...string[]]>>;
     static create: typeof createZodEnum;
@@ -786,3 +831,4 @@ }
 };
-export declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>> {
+export declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNativeEnumDef<T>, T[keyof T]> {
+    #private;
     _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
@@ -861,2 +907,3 @@ get enum(): T;
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -882,2 +929,3 @@ } & {
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -891,3 +939,3 @@ } & {
 }
-export declare class ZodNaN extends ZodType<number, ZodNaNDef> {
+export declare class ZodNaN extends ZodType<number, ZodNaNDef, number> {
     _parse(input: ParseInput): ParseReturnType<any>;
@@ -927,5 +975,6 @@ static create: (params?: RawCreateParams) => ZodNaN;
 }
-export declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, T["_input"]> {
+export declare class ZodReadonly<T extends ZodTypeAny> extends ZodType<MakeReadonly<T["_output"]>, ZodReadonlyDef<T>, MakeReadonly<T["_input"]>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+    unwrap(): T;
 }
@@ -935,6 +984,17 @@ declare type CustomParams = CustomErrorParams & {
 };
-export declare const custom: <T>(check?: ((data: unknown) => any) | undefined, params?: string | CustomParams | ((input: any) => CustomParams), fatal?: boolean | undefined) => ZodType<T, ZodTypeDef, T>;
+export declare function custom<T>(check?: (data: any) => any, params?: string | CustomParams | ((input: any) => CustomParams), 
+/**
+ * @deprecated
+ *
+ * Pass `fatal` into the params object instead:
+ *
+ * ```ts
+ * z.string().custom((val) => val.length > 5, { fatal: false })
+ * ```
+ *
+ */
+fatal?: boolean): ZodType<T, ZodTypeDef, unknown>;
 export { ZodType as Schema, ZodType as ZodSchema };
 export declare const late: {
-    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, { [k in keyof baseObjectOutputType<T>]: undefined extends baseObjectOutputType<T>[k] ? never : k; }[keyof T]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, { [k in keyof baseObjectOutputType<T>]: undefined extends baseObjectOutputType<T>[k] ? never : k; }[keyof T]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_2]; }>;
+    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>>[k]; }, { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1]; }>;
 };
@@ -979,7 +1039,7 @@ export declare enum ZodFirstPartyTypeKind {
 }
-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>;
+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> | ZodReadonly<any> | ZodSymbol;
 declare abstract class Class {
     constructor(..._: any[]);
 }
-declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, InstanceType<T>>;
+declare const instanceOfType: <T extends typeof Class>(cls: T, params?: CustomParams) => ZodType<InstanceType<T>, ZodTypeDef, unknown>;
 declare const stringType: (params?: ({
@@ -989,2 +1049,3 @@ errorMap?: ZodErrorMap | undefined;
     required_error?: string | undefined;
+    message?: string | undefined;
     description?: string | undefined;
@@ -998,2 +1059,3 @@ } & {
     required_error?: string | undefined;
+    message?: string | undefined;
     description?: string | undefined;
@@ -1008,2 +1070,3 @@ } & {
     required_error?: string | undefined;
+    message?: string | undefined;
     description?: string | undefined;
@@ -1017,2 +1080,3 @@ } & {
     required_error?: string | undefined;
+    message?: string | undefined;
     description?: string | undefined;
@@ -1026,2 +1090,3 @@ } & {
     required_error?: string | undefined;
+    message?: string | undefined;
     description?: string | undefined;
@@ -1039,4 +1104,4 @@ } & {
 declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T, "many">;
-declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, { [k in keyof baseObjectOutputType<T>]: undefined extends baseObjectOutputType<T>[k] ? never : k; }[keyof T]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, { [k in keyof baseObjectOutputType<T>]: undefined extends baseObjectOutputType<T>[k] ? never : k; }[keyof T]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_2]; }>;
-declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k_1 in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>, { [k in keyof baseObjectOutputType<T>]: undefined extends baseObjectOutputType<T>[k] ? never : k; }[keyof T]>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>, { [k in keyof baseObjectOutputType<T>]: undefined extends baseObjectOutputType<T>[k] ? never : k; }[keyof T]>[k_1]; }, { [k_2 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_2]; }>;
+declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>>[k]; }, { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1]; }>;
+declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict", ZodTypeAny, { [k in keyof objectUtil.addQuestionMarks<baseObjectOutputType<T>>]: objectUtil.addQuestionMarks<baseObjectOutputType<T>>[k]; }, { [k_1 in keyof baseObjectInputType<T>]: baseObjectInputType<T>[k_1]; }>;
 declare const unionType: <T extends readonly [ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>(types: T, params?: RawCreateParams) => ZodUnion<T>;
@@ -1068,2 +1133,3 @@ declare const discriminatedUnionType: typeof ZodDiscriminatedUnion.create;
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -1077,2 +1143,3 @@ } & {
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -1086,2 +1153,3 @@ } & {
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -1095,2 +1163,3 @@ } & {
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -1104,2 +1173,3 @@ } & {
         required_error?: string | undefined;
+        message?: string | undefined;
         description?: string | undefined;
@@ -1106,0 +1176,0 @@ } & {

lib/ZodError.d.ts

@@ -73,3 +73,3 @@ import type { TypeOf, ZodType } from ".";
 }
-export declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "ip" | {
+export declare type StringValidation = "email" | "url" | "emoji" | "uuid" | "nanoid" | "regex" | "cuid" | "cuid2" | "ulid" | "datetime" | "date" | "time" | "duration" | "ip" | "base64" | {
     includes: string;
@@ -143,2 +143,3 @@ position?: number;
     static create: (issues: ZodIssue[]) => ZodError<any>;
+    static assert(value: unknown): asserts value is ZodError;
     toString(): string;
@@ -145,0 +146,0 @@ get message(): string;

lib/ZodError.js

@@ -101,2 +101,7 @@ "use strict";
     }
+    static assert(value) {
+        if (!(value instanceof ZodError)) {
+            throw new Error(`Not a ZodError: ${value}`);
+        }
+    }
     toString() {
@@ -103,0 +108,0 @@ return this.message;

package.json

 {
   "name": "zod",
-  "version": "3.22.4",
+  "version": "3.23.0-beta.0",
   "author": "Colin McDonnell <[e-mail]>",
@@ -15,2 +15,3 @@ "repository": {
     "@babel/preset-typescript": "^7.22.5",
+    "@jest/globals": "^29.4.3",
     "@rollup/plugin-typescript": "^8.2.0",
@@ -45,3 +46,3 @@ "@swc/core": "^1.3.66",
     "tsx": "^3.8.0",
-    "typescript": "~4.5.0",
+    "typescript": "~4.5.5",
     "vitest": "^0.32.2"
@@ -102,3 +103,3 @@ },
     "test:babel": "jest --coverage --config ./configs/babel-jest.config.json",
-    "test:bun": "bun test",
+    "test:bun": "bun test src/",
     "test:vitest": "npx vitest --config ./configs/vitest.config.ts",
@@ -120,4 +121,3 @@ "test:ts-jest": "npx jest --config ./configs/ts-jest.config.json",
   },
-  "types": "./index.d.ts",
-  "dependencies": {}
+  "types": "./index.d.ts"
 }

New alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

673907

increased by7.34%

Number of package files

50

increased by8.7%

Lines of code

15166

increased by6%

Number of lines in readme file

3082

increased by8.71%

Worsened metrics

Dev dependency count

35

increased by2.94%

Number of low quality alerts

1

increased byInfinity%

No dependency changes