zod 3.25.3 → 3.25.5

package/dist/commonjs/v3/types.d.ts

@@ -491,7 +491,7 @@ export declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCar
     max(maxLength: number, message?: errorUtil.ErrMessage): this;
     length(len: number, message?: errorUtil.ErrMessage): this;
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <T extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1>;
+    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
 }
 export type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
 export type UnknownKeysParam = "passthrough" | "strict" | "strip";
@@ -584,9 +584,9 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectOutputType<T_1, ZodTypeAny, "strip">, objectInputType<T_1, ZodTypeAny, "strip">>;
-    static strictCreate: <T extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict">;
-    static lazycreate: <T extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip">;
+    static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+    static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+    static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
 }
 export type AnyZodObject = ZodObject<any, any, any>;
 export type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
@@ -597,7 +597,7 @@ export interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, Z
 export declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
-    static create: <T extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 }
 export type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
     [key in Discriminator]: ZodTypeAny;
@@ -633,7 +633,7 @@ export interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends
 }
 export declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
+    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
 }
 export type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 export type AssertArray<T> = T extends any[] ? T : never;
@@ -655,7 +655,7 @@ export declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
     rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
+    static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
 export interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     valueType: Value;
@@ -681,7 +681,7 @@ export declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends Z
     get keySchema(): Key;
     get valueSchema(): Value;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(keyType: Key_1, valueType: Value_1, params?: RawCreateParams) => ZodMap<Key_1, Value_1>;
+    static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
 }
 export interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     valueType: Value;
@@ -701,7 +701,7 @@ export declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodTy
     max(maxSize: number, message?: errorUtil.ErrMessage): this;
     size(size: number, message?: errorUtil.ErrMessage): this;
     nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
-    static create: <Value extends ZodTypeAny = ZodTypeAny>(valueType: Value_1, params?: RawCreateParams) => ZodSet<Value_1>;
+    static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
 }
 export interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     args: Args;
@@ -731,7 +731,7 @@ export interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDe
 export declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
     get schema(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T extends ZodTypeAny>(getter: () => T_1, params?: RawCreateParams) => ZodLazy<T_1>;
+    static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
 }
 export interface ZodLiteralDef<T = any> extends ZodTypeDef {
     value: T;
@@ -740,7 +740,7 @@ export interface ZodLiteralDef<T = any> extends ZodTypeDef {
 export declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get value(): T;
-    static create: <T extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
+    static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
 }
 export type ArrayKeys = keyof any[];
 export type Indices<T> = Exclude<keyof T, ArrayKeys>;
@@ -782,7 +782,7 @@ export declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T
     #private;
     _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
     get enum(): T;
-    static create: <T extends EnumLike>(values: T_1, params?: RawCreateParams) => ZodNativeEnum<T_1>;
+    static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
 }
 export interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     type: T;
@@ -791,7 +791,7 @@ export interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTyp
 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 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 }
 export type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
 export type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
@@ -829,7 +829,7 @@ export type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
 export declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
 }
 export interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -839,7 +839,7 @@ export type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
 export declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
 }
 export interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -849,9 +849,9 @@ export interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTyp
 export declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeDefault(): T;
-    static create: <T extends ZodTypeAny>(type: T_1, params: RawCreateParams & {
-        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
-    }) => ZodDefault<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+    }) => ZodDefault<Inner>;
 }
 export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -864,9 +864,9 @@ export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeD
 export declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeCatch(): T;
-    static create: <T extends ZodTypeAny>(type: T_1, params: RawCreateParams & {
-        catch: T_1["_output"] | (() => T_1["_output"]);
-    }) => ZodCatch<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        catch: Inner["_output"] | (() => Inner["_output"]);
+    }) => ZodCatch<Inner>;
 }
 export interface ZodNaNDef extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodNaN;
@@ -896,7 +896,7 @@ export interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> exte
 }
 export declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
     _parse(input: ParseInput): ParseReturnType<any>;
-    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
 }
 type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
     readonly [Symbol.toStringTag]: string;
@@ -908,7 +908,7 @@ export interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTy
 }
 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 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
     unwrap(): T;
 }
 type CustomParams = CustomErrorParams & {
@@ -928,7 +928,7 @@ export declare function custom<T>(check?: (data: any) => any, _params?: string |
 fatal?: boolean): ZodType<T, ZodTypeDef, T>;
 export { ZodType as Schema, ZodType as ZodSchema };
 export declare const late: {
-    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip">;
+    object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
 };
 export declare enum ZodFirstPartyTypeKind {
     ZodString = "ZodString",
@@ -996,25 +996,25 @@ declare const anyType: (params?: RawCreateParams) => ZodAny;
 declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
 declare const neverType: (params?: RawCreateParams) => ZodNever;
 declare const voidType: (params?: RawCreateParams) => ZodVoid;
-declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T>;
-declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, objectOutputType<T, ZodTypeAny, "strip">, objectInputType<T, ZodTypeAny, "strip">>;
-declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict">;
-declare const unionType: <T extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: T, params?: RawCreateParams) => ZodUnion<T>;
+declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+declare const unionType: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 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 intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+declare const tupleType: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, 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>;
+declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
 declare const functionType: typeof ZodFunction.create;
-declare const lazyType: <T extends ZodTypeAny>(getter: () => T, params?: RawCreateParams) => ZodLazy<T>;
-declare const literalType: <T extends Primitive>(value: T, params?: RawCreateParams) => ZodLiteral<T>;
+declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
 declare const enumType: typeof createZodEnum;
-declare const nativeEnumType: <T extends EnumLike>(values: T, params?: RawCreateParams) => ZodNativeEnum<T>;
-declare const promiseType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodPromise<T>;
+declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-declare const optionalType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodOptional<T>;
-declare const nullableType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodNullable<T>;
+declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
 declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
 declare const pipelineType: typeof ZodPipeline.create;
 declare const ostring: () => ZodOptional<ZodString>;

package/dist/commonjs/v4/classic/errors.d.ts

@@ -2,7 +2,7 @@ import * as core from "zod/v4/core";
 import { $ZodError } from "zod/v4/core";
 /** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
 export type ZodIssue = core.$ZodIssue;
-/** An Error-like class that doesn't extend `Error`. Used inside safeParse.  */
+/** An Error-like class used to store Zod validation issues.  */
 export interface ZodError<T = unknown> extends $ZodError<T> {
     /** @deprecated Use the `z.treeifyError(err)` function instead. */
     format(): core.$ZodFormattedError<T>;

package/dist/commonjs/v4/classic/errors.js

@@ -38,6 +38,7 @@ const core = __importStar(require("zod/v4/core"));
 const core_1 = require("zod/v4/core");
 const initializer = (inst, issues) => {
     core_1.$ZodError.init(inst, issues);
+    inst.name = "ZodError";
     Object.defineProperties(inst, {
         format: {
             value: (mapper) => core.formatError(inst, mapper),

package/dist/commonjs/v4/classic/parse.d.ts

@@ -1,5 +1,5 @@
 import * as core from "zod/v4/core";
-import { ZodError } from "./errors.js";
+import { type ZodError } from "./errors.js";
 export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
 export type ZodSafeParseSuccess<T> = {
     success: true;

package/dist/commonjs/v4/classic/parse.js

@@ -38,5 +38,5 @@ const core = __importStar(require("zod/v4/core"));
 const errors_js_1 = require("./errors.js");
 exports.parse = core._parse(errors_js_1.ZodRealError);
 exports.parseAsync = core._parseAsync(errors_js_1.ZodRealError);
-exports.safeParse = core._safeParse(errors_js_1.ZodError);
-exports.safeParseAsync = core._safeParseAsync(errors_js_1.ZodError);
+exports.safeParse = core._safeParse(errors_js_1.ZodRealError);
+exports.safeParseAsync = core._safeParseAsync(errors_js_1.ZodRealError);

package/dist/commonjs/v4/core/errors.d.ts

@@ -1,7 +1,7 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 import type { $ZodType } from "./schemas.js";
-import type * as util from "./util.js";
+import * as util from "./util.js";
 export interface $ZodIssueBase {
     readonly code?: string;
     readonly input?: unknown;

package/dist/commonjs/v4/core/errors.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.$ZodRealError = exports.$ZodError = void 0;
 exports.flattenError = flattenError;
@@ -7,15 +40,26 @@ exports.treeifyError = treeifyError;
 exports.toDotPath = toDotPath;
 exports.prettifyError = prettifyError;
 const core_js_1 = require("./core.js");
+const util = __importStar(require("./util.js"));
 const initializer = (inst, def) => {
+    inst.name = "$ZodError";
     Object.defineProperty(inst, "_zod", {
         value: inst._zod,
         enumerable: false,
     });
     Object.defineProperty(inst, "issues", {
         value: def,
+        enumerable: false,
+    });
+    // inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);
+    Object.defineProperty(inst, "message", {
+        get() {
+            return JSON.stringify(def, util.jsonStringifyReplacer, 2);
+        },
         enumerable: true,
+        // configurable: false,
     });
+    // inst.toString = () => inst.message;
     // inst.message = `Invalid input`;
     // Object.defineProperty(inst, "message", {
     //   get() {

package/dist/commonjs/v4/core/parse.js

@@ -80,7 +80,7 @@ const _safeParse = (_Err) => (schema, value, _ctx) => {
         : { success: true, data: result.value };
 };
 exports._safeParse = _safeParse;
-exports.safeParse = (0, exports._safeParse)(errors.$ZodError);
+exports.safeParse = (0, exports._safeParse)(errors.$ZodRealError);
 const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
     const ctx = _ctx ? Object.assign(_ctx, { async: true }) : { async: true };
     let result = schema._zod.run({ value, issues: [] }, ctx);
@@ -94,4 +94,4 @@ const _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
         : { success: true, data: result.value };
 };
 exports._safeParseAsync = _safeParseAsync;
-exports.safeParseAsync = (0, exports._safeParseAsync)(errors.$ZodError);
+exports.safeParseAsync = (0, exports._safeParseAsync)(errors.$ZodRealError);

package/dist/esm/v3/types.d.ts

@@ -491,7 +491,7 @@ export declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCar
     max(maxLength: number, message?: errorUtil.ErrMessage): this;
     length(len: number, message?: errorUtil.ErrMessage): this;
     nonempty(message?: errorUtil.ErrMessage): ZodArray<T, "atleastone">;
-    static create: <T extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodArray<T_1>;
+    static create: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
 }
 export type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
 export type UnknownKeysParam = "passthrough" | "strict" | "strip";
@@ -584,9 +584,9 @@ export declare class ZodObject<T extends ZodRawShape, UnknownKeys extends Unknow
         [k in keyof T]: k extends keyof Mask ? deoptional<T[k]> : T[k];
     }>, UnknownKeys, Catchall>;
     keyof(): ZodEnum<enumUtil.UnionToTupleString<keyof T>>;
-    static create: <T extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strip", ZodTypeAny, objectOutputType<T_1, ZodTypeAny, "strip">, objectInputType<T_1, ZodTypeAny, "strip">>;
-    static strictCreate: <T extends ZodRawShape>(shape: T_1, params?: RawCreateParams) => ZodObject<T_1, "strict">;
-    static lazycreate: <T extends ZodRawShape>(shape: () => T_1, params?: RawCreateParams) => ZodObject<T_1, "strip">;
+    static create: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+    static strictCreate: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+    static lazycreate: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
 }
 export type AnyZodObject = ZodObject<any, any, any>;
 export type ZodUnionOptions = Readonly<[ZodTypeAny, ...ZodTypeAny[]]>;
@@ -597,7 +597,7 @@ export interface ZodUnionDef<T extends ZodUnionOptions = Readonly<[ZodTypeAny, Z
 export declare class ZodUnion<T extends ZodUnionOptions> extends ZodType<T[number]["_output"], ZodUnionDef<T>, T[number]["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get options(): T;
-    static create: <T extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: T_1, params?: RawCreateParams) => ZodUnion<T_1>;
+    static create: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 }
 export type ZodDiscriminatedUnionOption<Discriminator extends string> = ZodObject<{
     [key in Discriminator]: ZodTypeAny;
@@ -633,7 +633,7 @@ export interface ZodIntersectionDef<T extends ZodTypeAny = ZodTypeAny, U extends
 }
 export declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends ZodType<T["_output"] & U["_output"], ZodIntersectionDef<T, U>, T["_input"] & U["_input"]> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T extends ZodTypeAny, U extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
+    static create: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
 }
 export type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
 export type AssertArray<T> = T extends any[] ? T : never;
@@ -655,7 +655,7 @@ export declare class ZodTuple<T extends ZodTupleItems | [] = ZodTupleItems, Rest
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get items(): T;
     rest<Rest extends ZodTypeAny>(rest: Rest): ZodTuple<T, Rest>;
-    static create: <T extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: T_1, params?: RawCreateParams) => ZodTuple<T_1, null>;
+    static create: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, null>;
 }
 export interface ZodRecordDef<Key extends KeySchema = ZodString, Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     valueType: Value;
@@ -681,7 +681,7 @@ export declare class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends Z
     get keySchema(): Key;
     get valueSchema(): Value;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(keyType: Key_1, valueType: Value_1, params?: RawCreateParams) => ZodMap<Key_1, Value_1>;
+    static create: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
 }
 export interface ZodSetDef<Value extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     valueType: Value;
@@ -701,7 +701,7 @@ export declare class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodTy
     max(maxSize: number, message?: errorUtil.ErrMessage): this;
     size(size: number, message?: errorUtil.ErrMessage): this;
     nonempty(message?: errorUtil.ErrMessage): ZodSet<Value>;
-    static create: <Value extends ZodTypeAny = ZodTypeAny>(valueType: Value_1, params?: RawCreateParams) => ZodSet<Value_1>;
+    static create: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
 }
 export interface ZodFunctionDef<Args extends ZodTuple<any, any> = ZodTuple<any, any>, Returns extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     args: Args;
@@ -731,7 +731,7 @@ export interface ZodLazyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDe
 export declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef<T>, input<T>> {
     get schema(): T;
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
-    static create: <T extends ZodTypeAny>(getter: () => T_1, params?: RawCreateParams) => ZodLazy<T_1>;
+    static create: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
 }
 export interface ZodLiteralDef<T = any> extends ZodTypeDef {
     value: T;
@@ -740,7 +740,7 @@ export interface ZodLiteralDef<T = any> extends ZodTypeDef {
 export declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get value(): T;
-    static create: <T extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;
+    static create: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
 }
 export type ArrayKeys = keyof any[];
 export type Indices<T> = Exclude<keyof T, ArrayKeys>;
@@ -782,7 +782,7 @@ export declare class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T
     #private;
     _parse(input: ParseInput): ParseReturnType<T[keyof T]>;
     get enum(): T;
-    static create: <T extends EnumLike>(values: T_1, params?: RawCreateParams) => ZodNativeEnum<T_1>;
+    static create: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
 }
 export interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     type: T;
@@ -791,7 +791,7 @@ export interface ZodPromiseDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTyp
 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 extends ZodTypeAny>(schema: T_1, params?: RawCreateParams) => ZodPromise<T_1>;
+    static create: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 }
 export type Refinement<T> = (arg: T, ctx: RefinementCtx) => any;
 export type SuperRefinement<T> = (arg: T, ctx: RefinementCtx) => void | Promise<void>;
@@ -829,7 +829,7 @@ export type ZodOptionalType<T extends ZodTypeAny> = ZodOptional<T>;
 export declare class ZodOptional<T extends ZodTypeAny> extends ZodType<T["_output"] | undefined, ZodOptionalDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodOptional<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
 }
 export interface ZodNullableDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -839,7 +839,7 @@ export type ZodNullableType<T extends ZodTypeAny> = ZodNullable<T>;
 export declare class ZodNullable<T extends ZodTypeAny> extends ZodType<T["_output"] | null, ZodNullableDef<T>, T["_input"] | null> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     unwrap(): T;
-    static create: <T extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodNullable<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
 }
 export interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -849,9 +849,9 @@ export interface ZodDefaultDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTyp
 export declare class ZodDefault<T extends ZodTypeAny> extends ZodType<util.noUndefined<T["_output"]>, ZodDefaultDef<T>, T["_input"] | undefined> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeDefault(): T;
-    static create: <T extends ZodTypeAny>(type: T_1, params: RawCreateParams & {
-        default: T_1["_input"] | (() => util.noUndefined<T_1["_input"]>);
-    }) => ZodDefault<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
+    }) => ZodDefault<Inner>;
 }
 export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeDef {
     innerType: T;
@@ -864,9 +864,9 @@ export interface ZodCatchDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTypeD
 export declare class ZodCatch<T extends ZodTypeAny> extends ZodType<T["_output"], ZodCatchDef<T>, unknown> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     removeCatch(): T;
-    static create: <T extends ZodTypeAny>(type: T_1, params: RawCreateParams & {
-        catch: T_1["_output"] | (() => T_1["_output"]);
-    }) => ZodCatch<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params: RawCreateParams & {
+        catch: Inner["_output"] | (() => Inner["_output"]);
+    }) => ZodCatch<Inner>;
 }
 export interface ZodNaNDef extends ZodTypeDef {
     typeName: ZodFirstPartyTypeKind.ZodNaN;
@@ -896,7 +896,7 @@ export interface ZodPipelineDef<A extends ZodTypeAny, B extends ZodTypeAny> exte
 }
 export declare class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends ZodType<B["_output"], ZodPipelineDef<A, B>, A["_input"]> {
     _parse(input: ParseInput): ParseReturnType<any>;
-    static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B>;
+    static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(a: ASchema, b: BSchema): ZodPipeline<ASchema, BSchema>;
 }
 type BuiltIn = (((...args: any[]) => any) | (new (...args: any[]) => any)) | {
     readonly [Symbol.toStringTag]: string;
@@ -908,7 +908,7 @@ export interface ZodReadonlyDef<T extends ZodTypeAny = ZodTypeAny> extends ZodTy
 }
 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 extends ZodTypeAny>(type: T_1, params?: RawCreateParams) => ZodReadonly<T_1>;
+    static create: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodReadonly<Inner>;
     unwrap(): T;
 }
 type CustomParams = CustomErrorParams & {
@@ -928,7 +928,7 @@ export declare function custom<T>(check?: (data: any) => any, _params?: string |
 fatal?: boolean): ZodType<T, ZodTypeDef, T>;
 export { ZodType as Schema, ZodType as ZodSchema };
 export declare const late: {
-    object: <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams) => ZodObject<T, "strip">;
+    object: <Shape extends ZodRawShape>(shape: () => Shape, params?: RawCreateParams) => ZodObject<Shape, "strip">;
 };
 export declare enum ZodFirstPartyTypeKind {
     ZodString = "ZodString",
@@ -996,25 +996,25 @@ declare const anyType: (params?: RawCreateParams) => ZodAny;
 declare const unknownType: (params?: RawCreateParams) => ZodUnknown;
 declare const neverType: (params?: RawCreateParams) => ZodNever;
 declare const voidType: (params?: RawCreateParams) => ZodVoid;
-declare const arrayType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodArray<T>;
-declare const objectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strip", ZodTypeAny, objectOutputType<T, ZodTypeAny, "strip">, objectInputType<T, ZodTypeAny, "strip">>;
-declare const strictObjectType: <T extends ZodRawShape>(shape: T, params?: RawCreateParams) => ZodObject<T, "strict">;
-declare const unionType: <T extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: T, params?: RawCreateParams) => ZodUnion<T>;
+declare const arrayType: <El extends ZodTypeAny>(schema: El, params?: RawCreateParams) => ZodArray<El>;
+declare const objectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strip", ZodTypeAny, objectOutputType<Shape, ZodTypeAny, "strip">, objectInputType<Shape, ZodTypeAny, "strip">>;
+declare const strictObjectType: <Shape extends ZodRawShape>(shape: Shape, params?: RawCreateParams) => ZodObject<Shape, "strict">;
+declare const unionType: <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(types: Options, params?: RawCreateParams) => ZodUnion<Options>;
 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 intersectionType: <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(left: TSchema, right: USchema, params?: RawCreateParams) => ZodIntersection<TSchema, USchema>;
+declare const tupleType: <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(schemas: Items, params?: RawCreateParams) => ZodTuple<Items, 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>;
+declare const mapType: <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(keyType: KeySchema, valueType: ValueSchema, params?: RawCreateParams) => ZodMap<KeySchema, ValueSchema>;
+declare const setType: <ValueSchema extends ZodTypeAny = ZodTypeAny>(valueType: ValueSchema, params?: RawCreateParams) => ZodSet<ValueSchema>;
 declare const functionType: typeof ZodFunction.create;
-declare const lazyType: <T extends ZodTypeAny>(getter: () => T, params?: RawCreateParams) => ZodLazy<T>;
-declare const literalType: <T extends Primitive>(value: T, params?: RawCreateParams) => ZodLiteral<T>;
+declare const lazyType: <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams) => ZodLazy<Inner>;
+declare const literalType: <Value extends Primitive>(value: Value, params?: RawCreateParams) => ZodLiteral<Value>;
 declare const enumType: typeof createZodEnum;
-declare const nativeEnumType: <T extends EnumLike>(values: T, params?: RawCreateParams) => ZodNativeEnum<T>;
-declare const promiseType: <T extends ZodTypeAny>(schema: T, params?: RawCreateParams) => ZodPromise<T>;
+declare const nativeEnumType: <Elements extends EnumLike>(values: Elements, params?: RawCreateParams) => ZodNativeEnum<Elements>;
+declare const promiseType: <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams) => ZodPromise<Inner>;
 declare const effectsType: <I extends ZodTypeAny>(schema: I, effect: Effect<I["_output"]>, params?: RawCreateParams) => ZodEffects<I, I["_output"]>;
-declare const optionalType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodOptional<T>;
-declare const nullableType: <T extends ZodTypeAny>(type: T, params?: RawCreateParams) => ZodNullable<T>;
+declare const optionalType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodOptional<Inner>;
+declare const nullableType: <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams) => ZodNullable<Inner>;
 declare const preprocessType: <I extends ZodTypeAny>(preprocess: (arg: unknown, ctx: RefinementCtx) => unknown, schema: I, params?: RawCreateParams) => ZodEffects<I, I["_output"], unknown>;
 declare const pipelineType: typeof ZodPipeline.create;
 declare const ostring: () => ZodOptional<ZodString>;

package/dist/esm/v4/classic/errors.d.ts

@@ -2,7 +2,7 @@ import * as core from "zod/v4/core";
 import { $ZodError } from "zod/v4/core";
 /** @deprecated Use `z.core.$ZodIssue` from `@zod/core` instead, especially if you are building a library on top of Zod. */
 export type ZodIssue = core.$ZodIssue;
-/** An Error-like class that doesn't extend `Error`. Used inside safeParse.  */
+/** An Error-like class used to store Zod validation issues.  */
 export interface ZodError<T = unknown> extends $ZodError<T> {
     /** @deprecated Use the `z.treeifyError(err)` function instead. */
     format(): core.$ZodFormattedError<T>;

package/dist/esm/v4/classic/errors.js

@@ -2,6 +2,7 @@ import * as core from "zod/v4/core";
 import { $ZodError } from "zod/v4/core";
 const initializer = (inst, issues) => {
     $ZodError.init(inst, issues);
+    inst.name = "ZodError";
     Object.defineProperties(inst, {
         format: {
             value: (mapper) => core.formatError(inst, mapper),

package/dist/esm/v4/classic/parse.d.ts

@@ -1,5 +1,5 @@
 import * as core from "zod/v4/core";
-import { ZodError } from "./errors.js";
+import { type ZodError } from "./errors.js";
 export type ZodSafeParseResult<T> = ZodSafeParseSuccess<T> | ZodSafeParseError<T>;
 export type ZodSafeParseSuccess<T> = {
     success: true;

package/dist/esm/v4/classic/parse.js

@@ -1,6 +1,6 @@
 import * as core from "zod/v4/core";
-import { ZodError, ZodRealError } from "./errors.js";
+import { ZodRealError } from "./errors.js";
 export const parse = /* @__PURE__ */ core._parse(ZodRealError);
 export const parseAsync = /* @__PURE__ */ core._parseAsync(ZodRealError);
-export const safeParse = /* @__PURE__ */ core._safeParse(ZodError);
-export const safeParseAsync = /* @__PURE__ */ core._safeParseAsync(ZodError);
+export const safeParse = /* @__PURE__ */ core._safeParse(ZodRealError);
+export const safeParseAsync = /* @__PURE__ */ core._safeParseAsync(ZodRealError);

package/dist/esm/v4/core/errors.d.ts

@@ -1,7 +1,7 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 import type { $ZodType } from "./schemas.js";
-import type * as util from "./util.js";
+import * as util from "./util.js";
 export interface $ZodIssueBase {
     readonly code?: string;
     readonly input?: unknown;