zod 4.0.0-beta.20250505T195954 → 4.0.0

package/src/{schemas.ts → v4/classic/schemas.ts}

@@ -1,13 +1,10 @@
-import * as core from "@zod/core";
-import { util } from "@zod/core";
+import * as core from "../core/index.js";
+import { util } from "../core/index.js";
 
 import * as checks from "./checks.js";
 import * as iso from "./iso.js";
 import * as parse from "./parse.js";
 
-export * as iso from "./iso.js";
-export * as coerce from "./coerce.js";
-
 ///////////////////////////////////////////
 ///////////////////////////////////////////
 ////////////                   ////////////
@@ -20,29 +17,34 @@ export interface RefinementCtx<T = unknown> extends core.ParsePayload<T> {
   addIssue(arg: string | core.$ZodRawIssue | Partial<core.$ZodIssueCustom>): void;
 }
 
-export interface ZodType<out Output = unknown, out Input = unknown> extends core.$ZodType<Output, Input> {
-  def: this["_zod"]["def"];
+export interface ZodType<
+  out Output = unknown,
+  out Input = unknown,
+  out Internals extends core.$ZodTypeInternals<Output, Input> = core.$ZodTypeInternals<Output, Input>,
+> extends core.$ZodType<Output, Input, Internals> {
+  def: Internals["def"];
+  type: Internals["def"]["type"];
+
   /** @deprecated Use `.def` instead. */
-  _def: this["_zod"]["def"];
-  // /** @deprecated Use `z.output<typeof schema>` instead. */
-  _output: core.output<this>;
-  // /** @deprecated Use `z.input<typeof schema>` instead. */
-  _input: core.input<this>;
+  _def: Internals["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: Internals["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: Internals["input"];
+
   // base methods
   check(...checks: (core.CheckFn<core.output<this>> | core.$ZodCheck<core.output<this>>)[]): this;
-  clone(def?: this["_zod"]["def"]): this;
+  clone(def?: Internals["def"], params?: { parent: boolean }): this;
   register<R extends core.$ZodRegistry>(
     registry: R,
     ...meta: this extends R["_schema"]
       ? undefined extends R["_meta"]
-        ? [core.$ZodRegistry<R["_meta"], this>["_meta"]?]
-        : [core.$ZodRegistry<R["_meta"], this>["_meta"]]
+        ? [core.$replace<R["_meta"], this>?]
+        : [core.$replace<R["_meta"], this>]
       : ["Incompatible schema"]
   ): this;
 
-  brand<T extends PropertyKey = PropertyKey>(
-    value?: T
-  ): PropertyKey extends T ? this : this & Record<"_zod", Record<"~output", core.output<this> & core.$brand<T>>>;
+  brand<T extends PropertyKey = PropertyKey>(value?: T): PropertyKey extends T ? this : core.$ZodBranded<this, T>;
 
   // parsing
   parse(data: unknown, params?: core.ParseContext<core.$ZodIssue>): core.output<this>;
@@ -61,27 +63,29 @@ export interface ZodType<out Output = unknown, out Input = unknown> extends core
   refine(check: (arg: core.output<this>) => unknown | Promise<unknown>, params?: string | core.$ZodCustomParams): this;
   /** @deprecated Use `.check()` instead. */
   superRefine(
-    refinement: (arg: core.output<this>, ctx: RefinementCtx<this["_zod"]["output"]>) => void | Promise<void>
+    refinement: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => void | Promise<void>
   ): this;
   overwrite(fn: (x: core.output<this>) => core.output<this>): this;
 
   // wrappers
-  optional(params?: string | core.$ZodOptionalParams): ZodOptional<this>;
+  optional(): ZodOptional<this>;
   nonoptional(params?: string | core.$ZodNonOptionalParams): ZodNonOptional<this>;
-  nullable(params?: string | core.$ZodNullableParams): ZodNullable<this>;
+  nullable(): ZodNullable<this>;
   nullish(): ZodOptional<ZodNullable<this>>;
-  default(def: util.NoUndefined<core.output<this>>, params?: string | core.$ZodDefaultParams): ZodDefault<this>;
-  default(def: () => util.NoUndefined<core.output<this>>, params?: string | core.$ZodDefaultParams): ZodDefault<this>;
+  default(def: core.output<this>): ZodDefault<this>;
+  default(def: () => util.NoUndefined<core.output<this>>): ZodDefault<this>;
+  prefault(def: () => core.input<this>): ZodPrefault<this>;
+  prefault(def: core.input<this>): ZodPrefault<this>;
   array(): ZodArray<this>;
-  or<T extends core.$ZodType>(option: T): ZodUnion<[this, T]>;
-  and<T extends core.$ZodType>(incoming: T): ZodIntersection<this, T>;
+  or<T extends core.SomeType>(option: T): ZodUnion<[this, T]>;
+  and<T extends core.SomeType>(incoming: T): ZodIntersection<this, T>;
   transform<NewOut>(
     transform: (arg: core.output<this>, ctx: RefinementCtx<core.output<this>>) => NewOut | Promise<NewOut>
   ): ZodPipe<this, ZodTransform<Awaited<NewOut>, core.output<this>>>;
   catch(def: core.output<this>): ZodCatch<this>;
   catch(def: (ctx: core.$ZodCatchCtx) => core.output<this>): ZodCatch<this>;
-  pipe<T extends core.$ZodType<any, this["_zod"]["output"]>>(
-    target: T | core.$ZodType<any, this["_zod"]["output"]>
+  pipe<T extends core.$ZodType<any, core.output<this>>>(
+    target: T | core.$ZodType<any, core.output<this>>
   ): ZodPipe<this, T>;
   readonly(): ZodReadonly<this>;
 
@@ -94,28 +98,49 @@ export interface ZodType<out Output = unknown, out Input = unknown> extends core
   meta(data: core.$replace<core.GlobalMeta, this>): this;
 
   // helpers
+  /** @deprecated Try safe-parsing `undefined` (this is what `isOptional` does internally):
+   *
+   * ```ts
+   * const schema = z.string().optional();
+   * const isOptional = schema.safeParse(undefined).success; // true
+   * ```
+   */
   isOptional(): boolean;
+  /**
+   * @deprecated Try safe-parsing `null` (this is what `isNullable` does internally):
+   *
+   * ```ts
+   * const schema = z.string().nullable();
+   * const isNullable = schema.safeParse(null).success; // true
+   * ```
+   */
   isNullable(): boolean;
 }
 
+export interface _ZodType<out Internals extends core.$ZodTypeInternals = core.$ZodTypeInternals>
+  extends ZodType<any, any, Internals> {}
+
 export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$constructor("ZodType", (inst, def) => {
   core.$ZodType.init(inst, def);
   inst.def = def;
-  inst._def = def;
+  Object.defineProperty(inst, "_def", { value: def });
 
   // base methods
   inst.check = (...checks) => {
-    return inst.clone({
-      ...def,
-      checks: [
-        ...(def.checks ?? []),
-        ...checks.map((ch) =>
-          typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch
-        ),
-      ],
-    });
+    return inst.clone(
+      {
+        ...def,
+        checks: [
+          ...(def.checks ?? []),
+          ...checks.map((ch) =>
+            typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch
+          ),
+        ],
+      }
+      // { parent: true }
+    );
   };
-  inst.clone = (_def) => core.clone(inst, _def);
+  inst.clone = (def, params) => core.clone(inst, def, params);
   inst.brand = () => inst as any;
   inst.register = ((reg: any, meta: any) => {
     reg.add(inst, meta);
@@ -123,9 +148,9 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
   }) as any;
 
   // parsing
-  inst.parse = (data, params) => parse.parse(inst, data, params);
+  inst.parse = (data, params) => parse.parse(inst, data, params, { callee: inst.parse });
   inst.safeParse = (data, params) => parse.safeParse(inst, data, params);
-  inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params);
+  inst.parseAsync = async (data, params) => parse.parseAsync(inst, data, params, { callee: inst.parseAsync });
   inst.safeParseAsync = async (data, params) => parse.safeParseAsync(inst, data, params);
   inst.spa = inst.safeParseAsync;
 
@@ -135,15 +160,16 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
   inst.overwrite = (fn) => inst.check(checks.overwrite(fn));
 
   // wrappers
-  inst.optional = (params) => optional(inst, params);
-  inst.nullable = (params) => nullable(inst, params);
+  inst.optional = () => optional(inst);
+  inst.nullable = () => nullable(inst);
   inst.nullish = () => optional(nullable(inst));
   inst.nonoptional = (params) => nonoptional(inst, params);
   inst.array = () => array(inst);
   inst.or = (arg) => union([inst, arg]);
   inst.and = (arg) => intersection(inst, arg);
   inst.transform = (tx) => pipe(inst, transform(tx as any)) as never;
-  inst.default = (def, params) => _default(inst, def, params);
+  inst.default = (def) => _default(inst, def);
+  inst.prefault = (def) => prefault(inst, def);
   // inst.coalesce = (def, params) => coalesce(inst, def, params);
   inst.catch = (params) => _catch(inst, params);
   inst.pipe = (target) => pipe(inst, target);
@@ -152,9 +178,7 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
   // meta
   inst.describe = (description) => {
     const cl = inst.clone();
-    const meta = { ...(core.globalRegistry.get(inst) ?? {}), description };
-    delete meta.id; // do not inherit
-    core.globalRegistry.add(cl, meta);
+    core.globalRegistry.add(cl, { description });
     return cl;
   };
   Object.defineProperty(inst, "description", {
@@ -164,7 +188,9 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
     configurable: true,
   });
   inst.meta = (...args: any) => {
-    if (args.length === 0) return core.globalRegistry.get(inst);
+    if (args.length === 0) {
+      return core.globalRegistry.get(inst);
+    }
     const cl = inst.clone();
     core.globalRegistry.add(cl, args[0]);
     return cl as any;
@@ -177,19 +203,15 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
 });
 
 // ZodString
-export interface _ZodString<Input = unknown> extends ZodType {
-  _zod: core.$ZodStringInternals<Input>;
-
+export interface _ZodString<T extends core.$ZodStringInternals<unknown> = core.$ZodStringInternals<unknown>>
+  extends _ZodType<T> {
   format: string | null;
   minLength: number | null;
   maxLength: number | null;
 
-  // /** @deprecated Use `z.jsonString()` instead. */
-  // json(params?: string | core.$ZodCheckJSONStringParams): this;
-
   // miscellaneous checks
   regex(regex: RegExp, params?: string | core.$ZodCheckRegexParams): this;
-  includes(value: string, params?: { message?: string; position?: number }): this;
+  includes(value: string, params?: core.$ZodCheckIncludesParams): this;
   startsWith(value: string, params?: string | core.$ZodCheckStartsWithParams): this;
   endsWith(value: string, params?: string | core.$ZodCheckEndsWithParams): this;
   min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
@@ -206,19 +228,21 @@ export interface _ZodString<Input = unknown> extends ZodType {
   toUpperCase(): this;
 }
 
+/** @internal */
 export const _ZodString: core.$constructor<_ZodString> = /*@__PURE__*/ core.$constructor("_ZodString", (inst, def) => {
   core.$ZodString.init(inst, def);
   ZodType.init(inst, def);
 
-  inst.format = inst._zod.computed.format ?? null;
-  inst.minLength = inst._zod.computed.minimum ?? null;
-  inst.maxLength = inst._zod.computed.maximum ?? null;
+  const bag = inst._zod.bag;
+  inst.format = bag.format ?? null;
+  inst.minLength = bag.minimum ?? null;
+  inst.maxLength = bag.maximum ?? null;
 
   // validations
   inst.regex = (...args) => inst.check(checks.regex(...args));
   inst.includes = (...args) => inst.check(checks.includes(...args));
-  inst.startsWith = (params) => inst.check(checks.startsWith(params));
-  inst.endsWith = (params) => inst.check(checks.endsWith(params));
+  inst.startsWith = (...args) => inst.check(checks.startsWith(...args));
+  inst.endsWith = (...args) => inst.check(checks.endsWith(...args));
   inst.min = (...args) => inst.check(checks.minLength(...args));
   inst.max = (...args) => inst.check(checks.maxLength(...args));
   inst.length = (...args) => inst.check(checks.length(...args));
@@ -233,11 +257,9 @@ export const _ZodString: core.$constructor<_ZodString> = /*@__PURE__*/ core.$con
   inst.toUpperCase = () => inst.check(checks.toUpperCase());
 });
 
-export interface ZodString extends _ZodString<string> {
+export interface ZodString extends _ZodString<core.$ZodStringInternals<string>> {
   // string format checks
-  // email(): ZodString;
-  // email(params?: string): ZodString;
-  // email(params?: StringFormatParams): ZodString;
+
   /** @deprecated Use `z.email()` instead. */
   email(params?: string | core.$ZodCheckEmailParams): this;
   /** @deprecated Use `z.url()` instead. */
@@ -343,14 +365,15 @@ export const ZodString: core.$constructor<ZodString> = /*@__PURE__*/ core.$const
   inst.duration = (params) => inst.check(iso.duration(params as any));
 });
 
+export function string(params?: string | core.$ZodStringParams): ZodString;
+export function string<T extends string>(params?: string | core.$ZodStringParams): core.$ZodType<T, T>;
 export function string(params?: string | core.$ZodStringParams): ZodString {
   return core._string(ZodString, params) as any;
 }
 
 // ZodStringFormat
-export interface ZodStringFormat<Format extends core.$ZodStringFormats = core.$ZodStringFormats> extends _ZodString {
-  _zod: core.$ZodStringFormatInternals<Format>;
-}
+export interface ZodStringFormat<Format extends string = string>
+  extends _ZodString<core.$ZodStringFormatInternals<Format>> {}
 export const ZodStringFormat: core.$constructor<ZodStringFormat> = /*@__PURE__*/ core.$constructor(
   "ZodStringFormat",
   (inst, def) => {
@@ -653,10 +676,31 @@ export function jwt(params?: string | core.$ZodJWTParams): ZodJWT {
   return core._jwt(ZodJWT, params);
 }
 
-// ZodNumber
-export interface _ZodNumber<Input = unknown> extends ZodType {
-  _zod: core.$ZodNumberInternals<Input>;
+// ZodCustomStringFormat
+export interface ZodCustomStringFormat<Format extends string = string>
+  extends ZodStringFormat<Format>,
+    core.$ZodCustomStringFormat<Format> {
+  _zod: core.$ZodCustomStringFormatInternals<Format>;
+}
+export const ZodCustomStringFormat: core.$constructor<ZodCustomStringFormat> = /*@__PURE__*/ core.$constructor(
+  "ZodCustomStringFormat",
+  (inst, def) => {
+    // ZodStringFormat.init(inst, def);
+    core.$ZodCustomStringFormat.init(inst, def);
+    ZodStringFormat.init(inst, def);
+  }
+);
+export function stringFormat<Format extends string>(
+  format: Format,
+  fnOrRegex: ((arg: string) => util.MaybeAsync<unknown>) | RegExp,
+  _params: string | core.$ZodStringFormatParams = {}
+): ZodCustomStringFormat<Format> {
+  return core._stringFormat(ZodCustomStringFormat, format, fnOrRegex, _params) as any;
+}
 
+// ZodNumber
+export interface _ZodNumber<Internals extends core.$ZodNumberInternals = core.$ZodNumberInternals>
+  extends _ZodType<Internals> {
   gt(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
   /** Identical to .min() */
   gte(value: number, params?: string | core.$ZodCheckGreaterThanParams): this;
@@ -678,7 +722,7 @@ export interface _ZodNumber<Input = unknown> extends ZodType {
   step(value: number, params?: string | core.$ZodCheckMultipleOfParams): this;
 
   /** @deprecated In v4 and later, z.number() does not allow infinite values by default. This is a no-op. */
-  finite(params?: any): this;
+  finite(params?: unknown): this;
 
   minValue: number | null;
   maxValue: number | null;
@@ -689,7 +733,7 @@ export interface _ZodNumber<Input = unknown> extends ZodType {
   format: string | null;
 }
 
-export interface ZodNumber extends _ZodNumber<number> {}
+export interface ZodNumber extends _ZodNumber<core.$ZodNumberInternals<number>> {}
 
 export const ZodNumber: core.$constructor<ZodNumber> = /*@__PURE__*/ core.$constructor("ZodNumber", (inst, def) => {
   core.$ZodNumber.init(inst, def);
@@ -713,12 +757,14 @@ export const ZodNumber: core.$constructor<ZodNumber> = /*@__PURE__*/ core.$const
   // inst.finite = (params) => inst.check(core.finite(params));
   inst.finite = () => inst;
 
-  inst.minValue = inst._zod.computed.minimum ?? null;
-  inst.maxValue = inst._zod.computed.maximum ?? null;
-  inst.isInt =
-    (inst._zod.computed.format ?? "").includes("int") || Number.isSafeInteger(inst._zod.computed.multipleOf ?? 0.5);
+  const bag = inst._zod.bag;
+  inst.minValue =
+    Math.max(bag.minimum ?? Number.NEGATIVE_INFINITY, bag.exclusiveMinimum ?? Number.NEGATIVE_INFINITY) ?? null;
+  inst.maxValue =
+    Math.min(bag.maximum ?? Number.POSITIVE_INFINITY, bag.exclusiveMaximum ?? Number.POSITIVE_INFINITY) ?? null;
+  inst.isInt = (bag.format ?? "").includes("int") || Number.isSafeInteger(bag.multipleOf ?? 0.5);
   inst.isFinite = true;
-  inst.format = inst._zod.computed.format ?? null;
+  inst.format = bag.format ?? null;
 });
 
 export function number(params?: string | core.$ZodNumberParams): ZodNumber {
@@ -768,10 +814,8 @@ export function uint32(params?: string | core.$ZodCheckNumberFormatParams): ZodU
 }
 
 // boolean
-export interface _ZodBoolean<T = unknown> extends ZodType {
-  _zod: core.$ZodBooleanInternals<T>;
-}
-export interface ZodBoolean extends _ZodBoolean<boolean> {}
+export interface _ZodBoolean<T extends core.$ZodBooleanInternals = core.$ZodBooleanInternals> extends _ZodType<T> {}
+export interface ZodBoolean extends _ZodBoolean<core.$ZodBooleanInternals<boolean>> {}
 export const ZodBoolean: core.$constructor<ZodBoolean> = /*@__PURE__*/ core.$constructor("ZodBoolean", (inst, def) => {
   core.$ZodBoolean.init(inst, def);
   ZodType.init(inst, def);
@@ -782,9 +826,7 @@ export function boolean(params?: string | core.$ZodBooleanParams): ZodBoolean {
 }
 
 // bigint
-export interface _ZodBigInt<T = unknown> extends ZodType {
-  _zod: core.$ZodBigIntInternals<T>;
-
+export interface _ZodBigInt<T extends core.$ZodBigIntInternals = core.$ZodBigIntInternals> extends _ZodType<T> {
   gte(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
   /** Alias of `.gte()` */
   min(value: bigint, params?: string | core.$ZodCheckGreaterThanParams): this;
@@ -804,7 +846,7 @@ export interface _ZodBigInt<T = unknown> extends ZodType {
   format: string | null;
 }
 
-export interface ZodBigInt extends _ZodBigInt<bigint> {}
+export interface ZodBigInt extends _ZodBigInt<core.$ZodBigIntInternals<bigint>> {}
 export const ZodBigInt: core.$constructor<ZodBigInt> = /*@__PURE__*/ core.$constructor("ZodBigInt", (inst, def) => {
   core.$ZodBigInt.init(inst, def);
   ZodType.init(inst, def);
@@ -823,9 +865,10 @@ export const ZodBigInt: core.$constructor<ZodBigInt> = /*@__PURE__*/ core.$const
   inst.nonnegative = (params) => inst.check(checks.gte(BigInt(0), params));
   inst.multipleOf = (value, params) => inst.check(checks.multipleOf(value, params));
 
-  inst.minValue = inst._zod.computed.minimum ?? null;
-  inst.maxValue = inst._zod.computed.maximum ?? null;
-  inst.format = inst._zod.computed.format ?? null;
+  const bag = inst._zod.bag;
+  inst.minValue = bag.minimum ?? null;
+  inst.maxValue = bag.maximum ?? null;
+  inst.format = bag.format ?? null;
 });
 
 export function bigint(params?: string | core.$ZodBigIntParams): ZodBigInt {
@@ -856,9 +899,7 @@ export function uint64(params?: string | core.$ZodBigIntFormatParams): ZodBigInt
 }
 
 // symbol
-export interface ZodSymbol extends ZodType {
-  _zod: core.$ZodSymbolInternals;
-}
+export interface ZodSymbol extends _ZodType<core.$ZodSymbolInternals> {}
 export const ZodSymbol: core.$constructor<ZodSymbol> = /*@__PURE__*/ core.$constructor("ZodSymbol", (inst, def) => {
   core.$ZodSymbol.init(inst, def);
   ZodType.init(inst, def);
@@ -869,9 +910,7 @@ export function symbol(params?: string | core.$ZodSymbolParams): ZodSymbol {
 }
 
 // ZodUndefined
-export interface ZodUndefined extends ZodType {
-  _zod: core.$ZodUndefinedInternals;
-}
+export interface ZodUndefined extends _ZodType<core.$ZodUndefinedInternals> {}
 export const ZodUndefined: core.$constructor<ZodUndefined> = /*@__PURE__*/ core.$constructor(
   "ZodUndefined",
   (inst, def) => {
@@ -886,9 +925,7 @@ function _undefined(params?: string | core.$ZodUndefinedParams): ZodUndefined {
 export { _undefined as undefined };
 
 // ZodNull
-export interface ZodNull extends ZodType {
-  _zod: core.$ZodNullInternals;
-}
+export interface ZodNull extends _ZodType<core.$ZodNullInternals> {}
 export const ZodNull: core.$constructor<ZodNull> = /*@__PURE__*/ core.$constructor("ZodNull", (inst, def) => {
   core.$ZodNull.init(inst, def);
   ZodType.init(inst, def);
@@ -900,35 +937,29 @@ function _null(params?: string | core.$ZodNullParams): ZodNull {
 export { _null as null };
 
 // ZodAny
-export interface ZodAny extends ZodType {
-  _zod: core.$ZodAnyInternals;
-}
+export interface ZodAny extends _ZodType<core.$ZodAnyInternals> {}
 export const ZodAny: core.$constructor<ZodAny> = /*@__PURE__*/ core.$constructor("ZodAny", (inst, def) => {
   core.$ZodAny.init(inst, def);
   ZodType.init(inst, def);
 });
 
-export function any(params?: string | core.$ZodAnyParams): ZodAny {
-  return core._any(ZodAny, params);
+export function any(): ZodAny {
+  return core._any(ZodAny);
 }
 
 // ZodUnknown
-export interface ZodUnknown extends ZodType {
-  _zod: core.$ZodUnknownInternals;
-}
+export interface ZodUnknown extends _ZodType<core.$ZodUnknownInternals> {}
 export const ZodUnknown: core.$constructor<ZodUnknown> = /*@__PURE__*/ core.$constructor("ZodUnknown", (inst, def) => {
   core.$ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
 });
 
-export function unknown(params?: string | core.$ZodUnknownParams): ZodUnknown {
-  return core._unknown(ZodUnknown, params);
+export function unknown(): ZodUnknown {
+  return core._unknown(ZodUnknown);
 }
 
 // ZodNever
-export interface ZodNever extends ZodType {
-  _zod: core.$ZodNeverInternals;
-}
+export interface ZodNever extends _ZodType<core.$ZodNeverInternals> {}
 export const ZodNever: core.$constructor<ZodNever> = /*@__PURE__*/ core.$constructor("ZodNever", (inst, def) => {
   core.$ZodNever.init(inst, def);
   ZodType.init(inst, def);
@@ -939,9 +970,7 @@ export function never(params?: string | core.$ZodNeverParams): ZodNever {
 }
 
 // ZodVoid
-export interface ZodVoid extends ZodType {
-  _zod: core.$ZodVoidInternals;
-}
+export interface ZodVoid extends _ZodType<core.$ZodVoidInternals> {}
 export const ZodVoid: core.$constructor<ZodVoid> = /*@__PURE__*/ core.$constructor("ZodVoid", (inst, def) => {
   core.$ZodVoid.init(inst, def);
   ZodType.init(inst, def);
@@ -953,9 +982,7 @@ function _void(params?: string | core.$ZodVoidParams): ZodVoid {
 export { _void as void };
 
 // ZodDate
-export interface _ZodDate<T = unknown> extends ZodType {
-  _zod: core.$ZodDateInternals<T>;
-
+export interface _ZodDate<T extends core.$ZodDateInternals = core.$ZodDateInternals> extends _ZodType<T> {
   min(value: number | Date, params?: string | core.$ZodCheckGreaterThanParams): this;
   max(value: number | Date, params?: string | core.$ZodCheckLessThanParams): this;
 
@@ -965,7 +992,7 @@ export interface _ZodDate<T = unknown> extends ZodType {
   maxDate: Date | null;
 }
 
-export interface ZodDate extends _ZodDate<Date> {}
+export interface ZodDate extends _ZodDate<core.$ZodDateInternals<Date>> {}
 export const ZodDate: core.$constructor<ZodDate> = /*@__PURE__*/ core.$constructor("ZodDate", (inst, def) => {
   core.$ZodDate.init(inst, def);
   ZodType.init(inst, def);
@@ -973,7 +1000,7 @@ export const ZodDate: core.$constructor<ZodDate> = /*@__PURE__*/ core.$construct
   inst.min = (value, params) => inst.check(checks.gte(value, params));
   inst.max = (value, params) => inst.check(checks.lte(value, params));
 
-  const c = inst._zod.computed;
+  const c = inst._zod.bag;
   inst.minDate = c.minimum ? new Date(c.minimum) : null;
   inst.maxDate = c.maximum ? new Date(c.maximum) : null;
 });
@@ -983,14 +1010,16 @@ export function date(params?: string | core.$ZodDateParams): ZodDate {
 }
 
 // ZodArray
-export interface ZodArray<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodArrayInternals<T>;
-
+export interface ZodArray<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodArrayInternals<T>>,
+    core.$ZodArray<T> {
   element: T;
   min(minLength: number, params?: string | core.$ZodCheckMinLengthParams): this;
   nonempty(params?: string | core.$ZodCheckMinLengthParams): this;
   max(maxLength: number, params?: string | core.$ZodCheckMaxLengthParams): this;
   length(len: number, params?: string | core.$ZodCheckLengthEqualsParams): this;
+
+  unwrap(): T;
 }
 export const ZodArray: core.$constructor<ZodArray> = /*@__PURE__*/ core.$constructor("ZodArray", (inst, def) => {
   core.$ZodArray.init(inst, def);
@@ -1001,99 +1030,90 @@ export const ZodArray: core.$constructor<ZodArray> = /*@__PURE__*/ core.$constru
   inst.nonempty = (params) => inst.check(checks.minLength(1, params));
   inst.max = (maxLength, params) => inst.check(checks.maxLength(maxLength, params));
   inst.length = (len, params) => inst.check(checks.length(len, params));
+
+  inst.unwrap = () => inst.element;
 });
 
-export function array<T extends core.$ZodType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T>;
-export function array<T extends core.$ZodType>(element: core.$ZodType, params?: any): ZodArray<T> {
-  return core._array(ZodArray, element, params) as any;
+export function array<T extends core.SomeType>(element: T, params?: string | core.$ZodArrayParams): ZodArray<T> {
+  return core._array(ZodArray, element as any, params) as any;
 }
 
 // .keyof
-export function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["output"]> {
+export function keyof<T extends ZodObject>(schema: T): ZodLiteral<Exclude<keyof T["_zod"]["output"], symbol>> {
   const shape = schema._zod.def.shape;
   return literal(Object.keys(shape)) as any;
 }
 
 // ZodObject
+
 export interface ZodObject<
-  // @ts-ignore cast variance
+  /** @ts-ignore Cast variance */
   out Shape extends core.$ZodShape = core.$ZodLooseShape,
-  OutExtra extends Record<string, unknown> = Record<string, unknown>,
-  InExtra extends Record<string, unknown> = Record<string, unknown>,
-> extends ZodType {
-  _zod: core.$ZodObjectInternals<Shape, OutExtra, InExtra>;
+  out Config extends core.$ZodObjectConfig = core.$strip,
+> extends _ZodType<core.$ZodObjectInternals<Shape, Config>>,
+    core.$ZodObject<Shape, Config> {
   shape: Shape;
 
   keyof(): ZodEnum<util.ToEnum<keyof Shape & string>>;
   /** Define a schema to validate all unrecognized keys. This overrides the existing strict/loose behavior. */
-  catchall<T extends core.$ZodType>(schema: T): ZodObject<Shape, Record<string, T["_zod"]["output"]>>;
+  catchall<T extends core.SomeType>(schema: T): ZodObject<Shape, core.$catchall<T>>;
 
   /** @deprecated Use `z.looseObject()` or `.loose()` instead. */
-  passthrough(): ZodObject<Shape, Record<string, unknown>>;
+  passthrough(): ZodObject<Shape, core.$loose>;
   /** Consider `z.looseObject(A.shape)` instead */
-  loose(): ZodObject<Shape, Record<string, unknown>>;
+  loose(): ZodObject<Shape, core.$loose>;
 
   /** Consider `z.strictObject(A.shape)` instead */
-  strict(): ZodObject<Shape, {}>;
+  strict(): ZodObject<Shape, core.$strict>;
 
   /** This is the default behavior. This method call is likely unnecessary. */
-  strip(): ZodObject<Shape, {}>;
+  strip(): ZodObject<Shape, core.$strip>;
 
-  extend<U extends core.$ZodLooseShape>(
+  extend<U extends core.$ZodLooseShape & Partial<Record<keyof Shape, core.SomeType>>>(
     shape: U
-  ): ZodObject<
-    util.Extend<Shape, U>,
-    OutExtra,
-    InExtra // & B['_zod']["extra"]
-  >;
+  ): ZodObject<util.Extend<Shape, U>, Config>;
 
   /**
-   * @deprecated Use destructuring to merge the shapes:
+   * @deprecated Use spread syntax and the `.shape` property to combine two object schemas:
    *
    * ```ts
-   * z.object({
-   *    ...A.shape,
-   *    ...B.shape
-   * });
-   * ```
-   */
-  merge<U extends ZodObject>(
-    other: U
-  ): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["outextra"], U["_zod"]["inextra"]>;
-  /**
-   * @deprecated Use destructuring to merge the shapes:
+   * const A = z.object({ a: z.string() });
+   * const B = z.object({ b: z.number() });
    *
-   * ```ts
-   * z.object({
+   * const C = z.object({
    *    ...A.shape,
    *    ...B.shape
    * });
    * ```
    */
+  merge<U extends ZodObject>(other: U): ZodObject<util.Extend<Shape, U["shape"]>, U["_zod"]["config"]>;
 
-  pick<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(
+  pick<M extends util.Mask<keyof Shape>>(
     mask: M
-  ): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, OutExtra, InExtra>;
+  ): ZodObject<util.Flatten<Pick<Shape, Extract<keyof Shape, keyof M>>>, Config>;
 
-  omit<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(
+  omit<M extends util.Mask<keyof Shape>>(
     mask: M
-  ): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, OutExtra, InExtra>;
+  ): ZodObject<util.Flatten<Omit<Shape, Extract<keyof Shape, keyof M>>>, Config>;
 
   partial(): ZodObject<
     {
       [k in keyof Shape]: ZodOptional<Shape[k]>;
     },
-    OutExtra,
-    InExtra
+    Config
   >;
-  partial<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(
+  partial<M extends util.Mask<keyof Shape>>(
     mask: M
   ): ZodObject<
     {
-      [k in keyof Shape]: k extends keyof M ? ZodOptional<Shape[k]> : Shape[k];
+      [k in keyof Shape]: k extends keyof M
+        ? // Shape[k] extends OptionalInSchema
+          //   ? Shape[k]
+          //   :
+          ZodOptional<Shape[k]>
+        : Shape[k];
     },
-    OutExtra,
-    InExtra
+    Config
   >;
 
   // required
@@ -1101,17 +1121,15 @@ export interface ZodObject<
     {
       [k in keyof Shape]: ZodNonOptional<Shape[k]>;
     },
-    OutExtra,
-    InExtra
+    Config
   >;
-  required<M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(
+  required<M extends util.Mask<keyof Shape>>(
     mask: M
   ): ZodObject<
     {
       [k in keyof Shape]: k extends keyof M ? ZodNonOptional<Shape[k]> : Shape[k];
     },
-    OutExtra,
-    InExtra
+    Config
   >;
 }
 
@@ -1119,11 +1137,9 @@ export const ZodObject: core.$constructor<ZodObject> = /*@__PURE__*/ core.$const
   core.$ZodObject.init(inst, def);
   ZodType.init(inst, def);
 
-  util.defineLazy(inst, "shape", () => {
-    return Object.fromEntries(Object.entries(inst._zod.def.shape));
-  });
+  util.defineLazy(inst, "shape", () => def.shape);
   inst.keyof = () => _enum(Object.keys(inst._zod.def.shape)) as any;
-  inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
+  inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall: catchall as any as core.$ZodType }) as any;
   inst.passthrough = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
   // inst.nonstrict = () => inst.clone({ ...inst._zod.def, catchall: api.unknown() });
   inst.loose = () => inst.clone({ ...inst._zod.def, catchall: unknown() });
@@ -1140,18 +1156,16 @@ export const ZodObject: core.$constructor<ZodObject> = /*@__PURE__*/ core.$const
   inst.required = (...args: any[]) => util.required(ZodNonOptional, inst, args[0] as object);
 });
 
-export function object<T extends core.$ZodLooseShape = Record<never, core.$ZodType>>(
+export function object<T extends core.$ZodLooseShape = Partial<Record<never, core.SomeType>>>(
   shape?: T,
   params?: string | core.$ZodObjectParams
-): ZodObject<util.Writeable<T> & {}, {}, {}> {
+): ZodObject<util.Writeable<T>, core.$strip> {
   const def: core.$ZodObjectDef = {
     type: "object",
-
     get shape() {
       util.assignProp(this, "shape", { ...shape });
       return this.shape;
     },
-
     ...util.normalizeParams(params),
   };
   return new ZodObject(def) as any;
@@ -1162,41 +1176,39 @@ export function object<T extends core.$ZodLooseShape = Record<never, core.$ZodTy
 export function strictObject<T extends core.$ZodLooseShape>(
   shape: T,
   params?: string | core.$ZodObjectParams
-): ZodObject<T, {}, {}> {
+): ZodObject<T, core.$strict> {
   return new ZodObject({
     type: "object",
-
     get shape() {
       util.assignProp(this, "shape", { ...shape });
       return this.shape;
     },
-
     catchall: never(),
     ...util.normalizeParams(params),
   }) as any;
 }
 
 // looseObject
+
 export function looseObject<T extends core.$ZodLooseShape>(
   shape: T,
   params?: string | core.$ZodObjectParams
-): ZodObject<T, { [k: string]: unknown }, { [k: string]: unknown }> {
+): ZodObject<T, core.$loose> {
   return new ZodObject({
     type: "object",
-
     get shape() {
       util.assignProp(this, "shape", { ...shape });
       return this.shape;
     },
-
     catchall: unknown(),
     ...util.normalizeParams(params),
   }) as any;
 }
 
 // ZodUnion
-export interface ZodUnion<T extends readonly core.$ZodType[] = readonly core.$ZodType[]> extends ZodType {
-  _zod: core.$ZodUnionInternals<T>;
+export interface ZodUnion<T extends readonly core.SomeType[] = readonly core.$ZodType[]>
+  extends _ZodType<core.$ZodUnionInternals<T>>,
+    core.$ZodUnion<T> {
   options: T;
 }
 export const ZodUnion: core.$constructor<ZodUnion> = /*@__PURE__*/ core.$constructor("ZodUnion", (inst, def) => {
@@ -1205,62 +1217,51 @@ export const ZodUnion: core.$constructor<ZodUnion> = /*@__PURE__*/ core.$constru
   inst.options = def.options;
 });
 
-export function union<const T extends readonly core.$ZodType[]>(
+export function union<const T extends readonly core.SomeType[]>(
   options: T,
   params?: string | core.$ZodUnionParams
 ): ZodUnion<T> {
   return new ZodUnion({
     type: "union",
-    options,
+    options: options as any as core.$ZodType[],
     ...util.normalizeParams(params),
-  }) as ZodUnion<T>;
+  }) as any;
 }
 
 // ZodDiscriminatedUnion
-export interface ZodDiscriminatedUnion<Options extends readonly core.$ZodType[] = readonly core.$ZodType[]>
-  extends ZodUnion<Options> {
+export interface ZodDiscriminatedUnion<Options extends readonly core.SomeType[] = readonly core.$ZodType[]>
+  extends ZodUnion<Options>,
+    core.$ZodDiscriminatedUnion<Options> {
   _zod: core.$ZodDiscriminatedUnionInternals<Options>;
 }
 export const ZodDiscriminatedUnion: core.$constructor<ZodDiscriminatedUnion> = /*@__PURE__*/ core.$constructor(
   "ZodDiscriminatedUnion",
   (inst, def) => {
+    ZodUnion.init(inst, def);
     core.$ZodDiscriminatedUnion.init(inst, def);
-    ZodType.init(inst, def);
   }
 );
 
-export interface $ZodTypeDiscriminableInternals extends core.$ZodTypeInternals {
-  disc: util.DiscriminatorMap;
-}
-
-export interface $ZodTypeDiscriminable extends ZodType {
-  _zod: $ZodTypeDiscriminableInternals;
-}
-
-export function discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]]>(
-  disc: string,
-  options: Types,
-  params?: string | core.$ZodDiscriminatedUnionParams
-): ZodDiscriminatedUnion<Types>;
-export function discriminatedUnion<Types extends [$ZodTypeDiscriminable, ...$ZodTypeDiscriminable[]]>(
+export function discriminatedUnion<
+  Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]],
+>(
+  discriminator: string,
   options: Types,
   params?: string | core.$ZodDiscriminatedUnionParams
-): ZodDiscriminatedUnion<Types>;
-export function discriminatedUnion(...args: any[]): any {
-  if (typeof args[0] === "string") args = args.slice(1);
-  const [options, params] = args;
+): ZodDiscriminatedUnion<Types> {
+  // const [options, params] = args;
   return new ZodDiscriminatedUnion({
     type: "union",
     options,
+    discriminator,
     ...util.normalizeParams(params),
-  });
+  }) as any;
 }
 
 // ZodIntersection
-export interface ZodIntersection<A extends core.$ZodType = core.$ZodType, B extends core.$ZodType = core.$ZodType>
-  extends ZodType {
-  _zod: core.$ZodIntersectionInternals<A, B>;
-}
+export interface ZodIntersection<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodIntersectionInternals<A, B>>,
+    core.$ZodIntersection<A, B> {}
 export const ZodIntersection: core.$constructor<ZodIntersection> = /*@__PURE__*/ core.$constructor(
   "ZodIntersection",
   (inst, def) => {
@@ -1269,26 +1270,24 @@ export const ZodIntersection: core.$constructor<ZodIntersection> = /*@__PURE__*/
   }
 );
 
-export function intersection<T extends core.$ZodType, U extends core.$ZodType>(
+export function intersection<T extends core.SomeType, U extends core.SomeType>(
   left: T,
-  right: U,
-  params?: string | core.$ZodIntersectionParams
+  right: U
 ): ZodIntersection<T, U> {
   return new ZodIntersection({
     type: "intersection",
-    left,
-    right,
-    ...util.normalizeParams(params),
-  }) as ZodIntersection<T, U>;
+    left: left as any as core.$ZodType,
+    right: right as any as core.$ZodType,
+  }) as any;
 }
 
 // ZodTuple
 export interface ZodTuple<
-  T extends util.TupleItems = util.TupleItems,
-  Rest extends core.$ZodType | null = core.$ZodType | null,
-> extends ZodType {
-  _zod: core.$ZodTupleInternals<T, Rest>;
-  rest<Rest extends core.$ZodType>(rest: Rest): ZodTuple<T, Rest>;
+  T extends util.TupleItems = readonly core.$ZodType[],
+  Rest extends core.SomeType | null = core.$ZodType | null,
+> extends _ZodType<core.$ZodTupleInternals<T, Rest>>,
+    core.$ZodTuple<T, Rest> {
+  rest<Rest extends core.SomeType = core.$ZodType>(rest: Rest): ZodTuple<T, Rest>;
 }
 export const ZodTuple: core.$constructor<ZodTuple> = /*@__PURE__*/ core.$constructor("ZodTuple", (inst, def) => {
   core.$ZodTuple.init(inst, def);
@@ -1296,23 +1295,23 @@ export const ZodTuple: core.$constructor<ZodTuple> = /*@__PURE__*/ core.$constru
   inst.rest = (rest) =>
     inst.clone({
       ...inst._zod.def,
-      rest,
+      rest: rest as any as core.$ZodType,
     }) as any;
 });
 
-export function tuple<T extends readonly [core.$ZodType, ...core.$ZodType[]]>(
+export function tuple<T extends readonly [core.SomeType, ...core.SomeType[]]>(
   items: T,
   params?: string | core.$ZodTupleParams
 ): ZodTuple<T, null>;
-export function tuple<T extends readonly [core.$ZodType, ...core.$ZodType[]], Rest extends core.$ZodType>(
+export function tuple<T extends readonly [core.SomeType, ...core.SomeType[]], Rest extends core.SomeType>(
   items: T,
   rest: Rest,
   params?: string | core.$ZodTupleParams
 ): ZodTuple<T, Rest>;
 export function tuple(items: [], params?: string | core.$ZodTupleParams): ZodTuple<[], null>;
 export function tuple(
-  items: core.$ZodType[],
-  _paramsOrRest?: string | core.$ZodTupleParams | core.$ZodType,
+  items: core.SomeType[],
+  _paramsOrRest?: string | core.$ZodTupleParams | core.SomeType,
   _params?: string | core.$ZodTupleParams
 ) {
   const hasRest = _paramsOrRest instanceof core.$ZodType;
@@ -1320,7 +1319,7 @@ export function tuple(
   const rest = hasRest ? _paramsOrRest : null;
   return new ZodTuple({
     type: "tuple",
-    items,
+    items: items as any as core.$ZodType[],
     rest,
     ...util.normalizeParams(params),
   });
@@ -1329,9 +1328,9 @@ export function tuple(
 // ZodRecord
 export interface ZodRecord<
   Key extends core.$ZodRecordKey = core.$ZodRecordKey,
-  Value extends core.$ZodType = core.$ZodType,
-> extends ZodType {
-  _zod: core.$ZodRecordInternals<Key, Value>;
+  Value extends core.SomeType = core.$ZodType,
+> extends _ZodType<core.$ZodRecordInternals<Key, Value>>,
+    core.$ZodRecord<Key, Value> {
   keyType: Key;
   valueType: Value;
 }
@@ -1343,7 +1342,7 @@ export const ZodRecord: core.$constructor<ZodRecord> = /*@__PURE__*/ core.$const
   inst.valueType = def.valueType;
 });
 
-export function record<Key extends core.$ZodRecordKey, Value extends core.$ZodType>(
+export function record<Key extends core.$ZodRecordKey, Value extends core.SomeType>(
   keyType: Key,
   valueType: Value,
   params?: string | core.$ZodRecordParams
@@ -1351,29 +1350,28 @@ export function record<Key extends core.$ZodRecordKey, Value extends core.$ZodTy
   return new ZodRecord({
     type: "record",
     keyType,
-    valueType,
+    valueType: valueType as any as core.$ZodType,
     ...util.normalizeParams(params),
-  }) as ZodRecord<Key, Value>;
+  }) as any;
 }
-
-export function partialRecord<Key extends core.$ZodRecordKey, Value extends core.$ZodType>(
+// type alksjf = core.output<core.$ZodRecordKey>;
+export function partialRecord<Key extends core.$ZodRecordKey, Value extends core.SomeType>(
   keyType: Key,
   valueType: Value,
   params?: string | core.$ZodRecordParams
-): ZodRecord<ZodUnion<[Key, ZodNever]>, Value> {
+): ZodRecord<Key & core.$partial, Value> {
   return new ZodRecord({
     type: "record",
     keyType: union([keyType, never()]),
-    valueType,
+    valueType: valueType as any,
     ...util.normalizeParams(params),
-  }) as ZodRecord<ZodUnion<[Key, ZodNever]>, Value>;
+  }) as any;
 }
 
 // ZodMap
-export interface ZodMap<Key extends core.$ZodType = core.$ZodType, Value extends core.$ZodType = core.$ZodType>
-  extends ZodType {
-  _zod: core.$ZodMapInternals<Key, Value>;
-
+export interface ZodMap<Key extends core.SomeType = core.$ZodType, Value extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodMapInternals<Key, Value>>,
+    core.$ZodMap<Key, Value> {
   keyType: Key;
   valueType: Value;
 }
@@ -1384,22 +1382,23 @@ export const ZodMap: core.$constructor<ZodMap> = /*@__PURE__*/ core.$constructor
   inst.valueType = def.valueType;
 });
 
-export function map<Key extends core.$ZodType, Value extends core.$ZodType>(
+export function map<Key extends core.SomeType, Value extends core.SomeType>(
   keyType: Key,
   valueType: Value,
   params?: string | core.$ZodMapParams
 ): ZodMap<Key, Value> {
   return new ZodMap({
     type: "map",
-    keyType,
-    valueType,
+    keyType: keyType as any as core.$ZodType,
+    valueType: valueType as any as core.$ZodType,
     ...util.normalizeParams(params),
-  }) as ZodMap<Key, Value>;
+  }) as any;
 }
 
 // ZodSet
-export interface ZodSet<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodSetInternals<T>;
+export interface ZodSet<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodSetInternals<T>>,
+    core.$ZodSet<T> {
   min(minSize: number, params?: string | core.$ZodCheckMinSizeParams): this;
   /** */
   nonempty(params?: string | core.$ZodCheckMinSizeParams): this;
@@ -1416,22 +1415,23 @@ export const ZodSet: core.$constructor<ZodSet> = /*@__PURE__*/ core.$constructor
   inst.size = (...args) => inst.check(core._size(...args));
 });
 
-export function set<Value extends core.$ZodType>(
+export function set<Value extends core.SomeType>(
   valueType: Value,
   params?: string | core.$ZodSetParams
 ): ZodSet<Value> {
   return new ZodSet({
     type: "set",
-    valueType,
+    valueType: valueType as any as core.$ZodType,
     ...util.normalizeParams(params),
-  }) as ZodSet<Value>;
+  }) as any;
 }
 
 // ZodEnum
-// @ts
-export interface ZodEnum<T extends util.EnumLike = util.EnumLike> extends ZodType {
-  _zod: core.$ZodEnumInternals<T>;
-
+export interface ZodEnum<
+  /** @ts-ignore Cast variance */
+  out T extends util.EnumLike = util.EnumLike,
+> extends _ZodType<core.$ZodEnumInternals<T>>,
+    core.$ZodEnum<T> {
   enum: T;
   options: Array<T[keyof T]>;
 
@@ -1516,17 +1516,28 @@ export function nativeEnum<T extends util.EnumLike>(entries: T, params?: string
 }
 
 // ZodLiteral
-export interface ZodLiteral<T extends util.Primitive = util.Primitive> extends ZodType {
-  _zod: core.$ZodLiteralInternals<T>;
+export interface ZodLiteral<T extends util.Literal = util.Literal>
+  extends _ZodType<core.$ZodLiteralInternals<T>>,
+    core.$ZodLiteral<T> {
   values: Set<T>;
+  /** @legacy Use `.values` instead. Accessing this property will throw an error if the literal accepts multiple values. */
+  value: T;
 }
 export const ZodLiteral: core.$constructor<ZodLiteral> = /*@__PURE__*/ core.$constructor("ZodLiteral", (inst, def) => {
   core.$ZodLiteral.init(inst, def);
   ZodType.init(inst, def);
   inst.values = new Set(def.values);
+  Object.defineProperty(inst, "value", {
+    get() {
+      if (def.values.length > 1) {
+        throw new Error("This schema contains multiple valid literal values. Use `.values` instead.");
+      }
+      return def.values[0];
+    },
+  });
 });
 
-export function literal<const T extends Array<util.Literal>>(
+export function literal<const T extends ReadonlyArray<util.Literal>>(
   value: T,
   params?: string | core.$ZodLiteralParams
 ): ZodLiteral<T[number]>;
@@ -1543,12 +1554,10 @@ export function literal(value: any, params: any) {
 }
 
 // ZodFile
-export interface ZodFile extends ZodType {
-  _zod: core.$ZodFileInternals;
-
+export interface ZodFile extends _ZodType<core.$ZodFileInternals>, core.$ZodFile {
   min(size: number, params?: string | core.$ZodCheckMinSizeParams): this;
   max(size: number, params?: string | core.$ZodCheckMaxSizeParams): this;
-  mime(types: Array<util.MimeTypes>, params?: string | core.$ZodCheckMimeTypeParams): this;
+  mime(types: util.MimeTypes | Array<util.MimeTypes>, params?: string | core.$ZodCheckMimeTypeParams): this;
 }
 export const ZodFile: core.$constructor<ZodFile> = /*@__PURE__*/ core.$constructor("ZodFile", (inst, def) => {
   core.$ZodFile.init(inst, def);
@@ -1556,7 +1565,7 @@ export const ZodFile: core.$constructor<ZodFile> = /*@__PURE__*/ core.$construct
 
   inst.min = (size, params) => inst.check(core._minSize(size, params));
   inst.max = (size, params) => inst.check(core._maxSize(size, params));
-  inst.mime = (types, params) => inst.check(core._mime(types, params));
+  inst.mime = (types, params) => inst.check(core._mime(Array.isArray(types) ? types : [types], params));
 });
 
 export function file(params?: string | core.$ZodFileParams): ZodFile {
@@ -1564,9 +1573,9 @@ export function file(params?: string | core.$ZodFileParams): ZodFile {
 }
 
 // ZodTransform
-export interface ZodTransform<O = unknown, I = unknown> extends ZodType {
-  _zod: core.$ZodTransformInternals<O, I>;
-}
+export interface ZodTransform<O = unknown, I = unknown>
+  extends _ZodType<core.$ZodTransformInternals<O, I>>,
+    core.$ZodTransform<O, I> {}
 export const ZodTransform: core.$constructor<ZodTransform> = /*@__PURE__*/ core.$constructor(
   "ZodTransform",
   (inst, def) => {
@@ -1585,7 +1594,7 @@ export const ZodTransform: core.$constructor<ZodTransform> = /*@__PURE__*/ core.
           _issue.code ??= "custom";
           _issue.input ??= payload.value;
           _issue.inst ??= inst;
-          _issue.continue ??= !def.abort;
+          _issue.continue ??= true;
           payload.issues.push(util.issue(_issue));
         }
       };
@@ -1604,20 +1613,18 @@ export const ZodTransform: core.$constructor<ZodTransform> = /*@__PURE__*/ core.
 );
 
 export function transform<I = unknown, O = I>(
-  fn: (input: I, ctx: core.ParsePayload) => O,
-  params?: string | core.$ZodTransformParams
+  fn: (input: I, ctx: core.ParsePayload) => O
 ): ZodTransform<Awaited<O>, I> {
   return new ZodTransform({
     type: "transform",
     transform: fn as any,
-    ...util.normalizeParams(params),
   }) as any;
 }
 
 // ZodOptional
-export interface ZodOptional<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodOptionalInternals<T>;
-
+export interface ZodOptional<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodOptionalInternals<T>>,
+    core.$ZodOptional<T> {
   unwrap(): T;
 }
 export const ZodOptional: core.$constructor<ZodOptional> = /*@__PURE__*/ core.$constructor(
@@ -1630,21 +1637,17 @@ export const ZodOptional: core.$constructor<ZodOptional> = /*@__PURE__*/ core.$c
   }
 );
 
-export function optional<T extends core.$ZodType>(
-  innerType: T,
-  params?: string | core.$ZodOptionalParams
-): ZodOptional<T> {
+export function optional<T extends core.SomeType>(innerType: T): ZodOptional<T> {
   return new ZodOptional({
     type: "optional",
-    innerType,
-    ...util.normalizeParams(params),
-  }) as ZodOptional<T>;
+    innerType: innerType as any as core.$ZodType,
+  }) as any;
 }
 
 // ZodNullable
-export interface ZodNullable<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodNullableInternals<T>;
-
+export interface ZodNullable<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodNullableInternals<T>>,
+    core.$ZodNullable<T> {
   unwrap(): T;
 }
 export const ZodNullable: core.$constructor<ZodNullable> = /*@__PURE__*/ core.$constructor(
@@ -1657,26 +1660,22 @@ export const ZodNullable: core.$constructor<ZodNullable> = /*@__PURE__*/ core.$c
   }
 );
 
-export function nullable<T extends core.$ZodType>(
-  innerType: T,
-  params?: string | core.$ZodNullableParams
-): ZodNullable<T> {
+export function nullable<T extends core.SomeType>(innerType: T): ZodNullable<T> {
   return new ZodNullable({
     type: "nullable",
-    innerType,
-    ...util.normalizeParams(params),
-  }) as ZodNullable<T>;
+    innerType: innerType as any as core.$ZodType,
+  }) as any;
 }
 
 // nullish
-export function nullish<T extends core.$ZodType>(innerType: T): ZodOptional<ZodNullable<T>> {
+export function nullish<T extends core.SomeType>(innerType: T): ZodOptional<ZodNullable<T>> {
   return optional(nullable(innerType));
 }
 
 // ZodDefault
-export interface ZodDefault<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodDefaultInternals<T>;
-
+export interface ZodDefault<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodDefaultInternals<T>>,
+    core.$ZodDefault<T> {
   unwrap(): T;
   /** @deprecated Use `.unwrap()` instead. */
   removeDefault(): T;
@@ -1689,23 +1688,51 @@ export const ZodDefault: core.$constructor<ZodDefault> = /*@__PURE__*/ core.$con
   inst.removeDefault = inst.unwrap;
 });
 
-export function _default<T extends core.$ZodType>(
+export function _default<T extends core.SomeType>(
   innerType: T,
-  defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>),
-  params?: string | core.$ZodDefaultParams
+  defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>)
 ): ZodDefault<T> {
   return new ZodDefault({
     type: "default",
-    defaultValue: (typeof defaultValue === "function" ? defaultValue : () => defaultValue) as () => core.output<T>,
-    innerType,
-    ...util.normalizeParams(params),
-  }) as any as ZodDefault<T>;
+    innerType: innerType as any as core.$ZodType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : defaultValue;
+    },
+  }) as any;
 }
 
-// ZodNonOptional
-export interface ZodNonOptional<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodNonOptionalInternals<T>;
+// ZodPrefault
+export interface ZodPrefault<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodPrefaultInternals<T>>,
+    core.$ZodPrefault<T> {
+  unwrap(): T;
+}
+export const ZodPrefault: core.$constructor<ZodPrefault> = /*@__PURE__*/ core.$constructor(
+  "ZodPrefault",
+  (inst, def) => {
+    core.$ZodPrefault.init(inst, def);
+    ZodType.init(inst, def);
+    inst.unwrap = () => inst._zod.def.innerType;
+  }
+);
+
+export function prefault<T extends core.SomeType>(
+  innerType: T,
+  defaultValue: core.input<T> | (() => core.input<T>)
+): ZodPrefault<T> {
+  return new ZodPrefault({
+    type: "prefault",
+    innerType: innerType as any as core.$ZodType,
+    get defaultValue() {
+      return typeof defaultValue === "function" ? (defaultValue as Function)() : defaultValue;
+    },
+  }) as any;
+}
 
+// ZodNonOptional
+export interface ZodNonOptional<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodNonOptionalInternals<T>>,
+    core.$ZodNonOptional<T> {
   unwrap(): T;
 }
 export const ZodNonOptional: core.$constructor<ZodNonOptional> = /*@__PURE__*/ core.$constructor(
@@ -1718,21 +1745,21 @@ export const ZodNonOptional: core.$constructor<ZodNonOptional> = /*@__PURE__*/ c
   }
 );
 
-export function nonoptional<T extends core.$ZodType>(
+export function nonoptional<T extends core.SomeType>(
   innerType: T,
   params?: string | core.$ZodNonOptionalParams
 ): ZodNonOptional<T> {
   return new ZodNonOptional({
     type: "nonoptional",
-    innerType,
+    innerType: innerType as any as core.$ZodType,
     ...util.normalizeParams(params),
-  }) as ZodNonOptional<T>;
+  }) as any;
 }
 
 // ZodSuccess
-export interface ZodSuccess<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodSuccessInternals<T>;
-
+export interface ZodSuccess<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodSuccessInternals<T>>,
+    core.$ZodSuccess<T> {
   unwrap(): T;
 }
 export const ZodSuccess: core.$constructor<ZodSuccess> = /*@__PURE__*/ core.$constructor("ZodSuccess", (inst, def) => {
@@ -1742,21 +1769,17 @@ export const ZodSuccess: core.$constructor<ZodSuccess> = /*@__PURE__*/ core.$con
   inst.unwrap = () => inst._zod.def.innerType;
 });
 
-export function success<T extends core.$ZodType>(
-  innerType: T,
-  params?: string | core.$ZodSuccessParams
-): ZodSuccess<T> {
+export function success<T extends core.SomeType>(innerType: T): ZodSuccess<T> {
   return new ZodSuccess({
     type: "success",
-    innerType,
-    ...util.normalizeParams(params),
-  }) as ZodSuccess<T>;
+    innerType: innerType as any as core.$ZodType,
+  }) as any;
 }
 
 // ZodCatch
-export interface ZodCatch<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodCatchInternals<T>;
-
+export interface ZodCatch<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodCatchInternals<T>>,
+    core.$ZodCatch<T> {
   unwrap(): T;
   /** @deprecated Use `.unwrap()` instead. */
   removeCatch(): T;
@@ -1769,26 +1792,22 @@ export const ZodCatch: core.$constructor<ZodCatch> = /*@__PURE__*/ core.$constru
   inst.removeCatch = inst.unwrap;
 });
 
-function _catch<T extends core.$ZodType>(
+function _catch<T extends core.SomeType>(
   innerType: T,
-  catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>),
-  params?: string | core.$ZodCatchParams
+  catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>)
 ): ZodCatch<T> {
   return new ZodCatch({
     type: "catch",
-    innerType,
+    innerType: innerType as any as core.$ZodType,
     catchValue: (typeof catchValue === "function" ? catchValue : () => catchValue) as (
       ctx: core.$ZodCatchCtx
     ) => core.output<T>,
-    ...util.normalizeParams(params),
-  }) as ZodCatch<T>;
+  }) as any;
 }
 export { _catch as catch };
 
 // ZodNaN
-export interface ZodNaN extends ZodType {
-  _zod: core.$ZodNaNInternals;
-}
+export interface ZodNaN extends _ZodType<core.$ZodNaNInternals>, core.$ZodNaN {}
 export const ZodNaN: core.$constructor<ZodNaN> = /*@__PURE__*/ core.$constructor("ZodNaN", (inst, def) => {
   core.$ZodNaN.init(inst, def);
   ZodType.init(inst, def);
@@ -1799,10 +1818,9 @@ export function nan(params?: string | core.$ZodNaNParams): ZodNaN {
 }
 
 // ZodPipe
-export interface ZodPipe<A extends core.$ZodType = core.$ZodType, B extends core.$ZodType = core.$ZodType>
-  extends ZodType {
-  _zod: core.$ZodPipeInternals<A, B>;
-
+export interface ZodPipe<A extends core.SomeType = core.$ZodType, B extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodPipeInternals<A, B>>,
+    core.$ZodPipe<A, B> {
   in: A;
   out: B;
 }
@@ -1815,22 +1833,22 @@ export const ZodPipe: core.$constructor<ZodPipe> = /*@__PURE__*/ core.$construct
 });
 
 export function pipe<
-  const A extends core.$ZodType,
+  const A extends core.SomeType,
   B extends core.$ZodType<unknown, core.output<A>> = core.$ZodType<unknown, core.output<A>>,
->(in_: A, out: B | core.$ZodType<unknown, core.output<A>>, params?: string | core.$ZodPipeParams): ZodPipe<A, B>;
-export function pipe(in_: core.$ZodType, out: core.$ZodType, params?: string | core.$ZodPipeParams) {
+>(in_: A, out: B | core.$ZodType<unknown, core.output<A>>): ZodPipe<A, B>;
+export function pipe(in_: core.SomeType, out: core.SomeType) {
   return new ZodPipe({
     type: "pipe",
-    in: in_,
-    out,
-    ...util.normalizeParams(params),
+    in: in_ as unknown as core.$ZodType,
+    out: out as unknown as core.$ZodType,
+    // ...util.normalizeParams(params),
   });
 }
 
 // ZodReadonly
-export interface ZodReadonly<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodReadonlyInternals<T>;
-}
+export interface ZodReadonly<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodReadonlyInternals<T>>,
+    core.$ZodReadonly<T> {}
 export const ZodReadonly: core.$constructor<ZodReadonly> = /*@__PURE__*/ core.$constructor(
   "ZodReadonly",
   (inst, def) => {
@@ -1839,21 +1857,17 @@ export const ZodReadonly: core.$constructor<ZodReadonly> = /*@__PURE__*/ core.$c
   }
 );
 
-export function readonly<T extends core.$ZodType>(
-  innerType: T,
-  params?: string | core.$ZodReadonlyParams
-): ZodReadonly<T> {
+export function readonly<T extends core.SomeType>(innerType: T): ZodReadonly<T> {
   return new ZodReadonly({
     type: "readonly",
-    innerType,
-    ...util.normalizeParams(params),
-  }) as ZodReadonly<T>;
+    innerType: innerType as any as core.$ZodType,
+  }) as any;
 }
 
 // ZodTemplateLiteral
-export interface ZodTemplateLiteral<Template extends string = string> extends ZodType {
-  _zod: core.$ZodTemplateLiteralInternals<Template>;
-}
+export interface ZodTemplateLiteral<Template extends string = string>
+  extends _ZodType<core.$ZodTemplateLiteralInternals<Template>>,
+    core.$ZodTemplateLiteral<Template> {}
 export const ZodTemplateLiteral: core.$constructor<ZodTemplateLiteral> = /*@__PURE__*/ core.$constructor(
   "ZodTemplateLiteral",
   (inst, def) => {
@@ -1862,7 +1876,7 @@ export const ZodTemplateLiteral: core.$constructor<ZodTemplateLiteral> = /*@__PU
   }
 );
 
-export function templateLiteral<const Parts extends core.$TemplateLiteralPart[]>(
+export function templateLiteral<const Parts extends core.$ZodTemplateLiteralPart[]>(
   parts: Parts,
   params?: string | core.$ZodTemplateLiteralParams
 ): ZodTemplateLiteral<core.$PartsToTemplateLiteral<Parts>> {
@@ -1874,9 +1888,9 @@ export function templateLiteral<const Parts extends core.$TemplateLiteralPart[]>
 }
 
 // ZodLazy
-export interface ZodLazy<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodLazyInternals<T>;
-
+export interface ZodLazy<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodLazyInternals<T>>,
+    core.$ZodLazy<T> {
   unwrap(): T;
 }
 export const ZodLazy: core.$constructor<ZodLazy> = /*@__PURE__*/ core.$constructor("ZodLazy", (inst, def) => {
@@ -1886,17 +1900,17 @@ export const ZodLazy: core.$constructor<ZodLazy> = /*@__PURE__*/ core.$construct
   inst.unwrap = () => inst._zod.def.getter();
 });
 
-export function lazy<T extends core.$ZodType>(getter: () => T): ZodLazy<T> {
+export function lazy<T extends core.SomeType>(getter: () => T): ZodLazy<T> {
   return new ZodLazy({
     type: "lazy",
-    getter,
-  }) as ZodLazy<T>;
+    getter: getter as any,
+  }) as any;
 }
 
 // ZodPromise
-export interface ZodPromise<T extends core.$ZodType = core.$ZodType> extends ZodType {
-  _zod: core.$ZodPromiseInternals<T>;
-
+export interface ZodPromise<T extends core.SomeType = core.$ZodType>
+  extends _ZodType<core.$ZodPromiseInternals<T>>,
+    core.$ZodPromise<T> {
   unwrap(): T;
 }
 export const ZodPromise: core.$constructor<ZodPromise> = /*@__PURE__*/ core.$constructor("ZodPromise", (inst, def) => {
@@ -1906,41 +1920,37 @@ export const ZodPromise: core.$constructor<ZodPromise> = /*@__PURE__*/ core.$con
   inst.unwrap = () => inst._zod.def.innerType;
 });
 
-export function promise<T extends core.$ZodType>(
-  innerType: T,
-  params?: string | core.$ZodPromiseParams
-): ZodPromise<T> {
+export function promise<T extends core.SomeType>(innerType: T): ZodPromise<T> {
   return new ZodPromise({
     type: "promise",
-    innerType,
-    ...util.normalizeParams(params),
-  }) as ZodPromise<T>;
+    innerType: innerType as any as core.$ZodType,
+  }) as any;
 }
 
 // ZodCustom
-export interface ZodCustom<O = unknown, I = unknown> extends ZodType {
-  _zod: core.$ZodCustomInternals<O, I>;
-}
+export interface ZodCustom<O = unknown, I = unknown>
+  extends _ZodType<core.$ZodCustomInternals<O, I>>,
+    core.$ZodCustom<O, I> {}
 export const ZodCustom: core.$constructor<ZodCustom> = /*@__PURE__*/ core.$constructor("ZodCustom", (inst, def) => {
   core.$ZodCustom.init(inst, def);
   ZodType.init(inst, def);
 });
 
 // custom checks
-export function check<O = unknown>(fn: core.CheckFn<O>, params?: string | core.$ZodCustomParams): core.$ZodCheck<O> {
+export function check<O = unknown>(fn: core.CheckFn<O>): core.$ZodCheck<O> {
   const ch = new core.$ZodCheck({
     check: "custom",
-    ...util.normalizeParams(params),
+    // ...util.normalizeParams(params),
   });
 
   ch._zod.check = fn;
   return ch;
 }
 
-export function custom<O = unknown, I = O>(
-  fn?: (data: O) => unknown,
+export function custom<O>(
+  fn?: (data: unknown) => unknown,
   _params?: string | core.$ZodCustomParams | undefined
-): ZodCustom<O, I> {
+): ZodCustom<O, O> {
   return core._custom(ZodCustom, fn ?? (() => true), _params) as any;
 }
 
@@ -1948,14 +1958,11 @@ export function refine<T>(
   fn: (arg: NoInfer<T>) => util.MaybeAsync<unknown>,
   _params: string | core.$ZodCustomParams = {}
 ): core.$ZodCheck<T> {
-  return core._custom(ZodCustom, fn, _params);
+  return core._refine(ZodCustom, fn, _params);
 }
 
 // superRefine
-export function superRefine<T>(
-  fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>,
-  params?: string | core.$ZodCustomParams
-): core.$ZodCheck<T> {
+export function superRefine<T>(fn: (arg: T, payload: RefinementCtx<T>) => void | Promise<void>): core.$ZodCheck<T> {
   const ch = check<T>((payload) => {
     (payload as RefinementCtx).addIssue = (issue) => {
       if (typeof issue === "string") {
@@ -1973,52 +1980,60 @@ export function superRefine<T>(
     };
 
     return fn(payload.value, payload as RefinementCtx<T>);
-  }, params);
+  });
   return ch;
 }
 
-// instanceof
-abstract class Class {
-  constructor(..._args: any[]) {}
-}
-type ZodInstanceOfParams = util.Params<
+type ZodInstanceOfParams = core.Params<
   ZodCustom,
   core.$ZodIssueCustom,
   "type" | "check" | "checks" | "fn" | "abort" | "error" | "params" | "path"
 >;
-function _instanceof<T extends typeof Class>(
+function _instanceof<T extends typeof util.Class>(
   cls: T,
   params: ZodInstanceOfParams = {
     error: `Input not instance of ${cls.name}`,
   }
-): ZodCustom<InstanceType<T>> {
-  return new ZodCustom({
+): ZodCustom<InstanceType<T>, InstanceType<T>> {
+  const inst = new ZodCustom({
     type: "custom",
     check: "custom",
     fn: (data) => data instanceof cls,
     abort: true,
     ...(util.normalizeParams(params) as any),
-  }) as any;
+  });
+  inst._zod.bag.Class = cls;
+  return inst as any;
 }
 export { _instanceof as instanceof };
 
 // stringbool
-export const stringbool: (_params?: string | core.$ZodStringBoolParams) => ZodPipe<ZodUnknown, ZodBoolean> =
-  /*@__PURE__*/ core._stringbool.bind(null, {
-    Pipe: ZodPipe,
-    Boolean: ZodBoolean,
-    Unknown: ZodUnknown,
-  }) as any;
+export const stringbool: (
+  _params?: string | core.$ZodStringBoolParams
+) => ZodPipe<ZodPipe<ZodString, ZodTransform<boolean, string>>, ZodBoolean> = (...args) =>
+  core._stringbool(
+    {
+      Pipe: ZodPipe,
+      Boolean: ZodBoolean,
+      String: ZodString,
+      Transform: ZodTransform,
+    },
+    ...args
+  ) as any;
 
 // json
-export type ZodJSONSchema = ZodUnion<
+type _ZodJSONSchema = ZodUnion<
   [ZodString, ZodNumber, ZodBoolean, ZodNull, ZodArray<ZodJSONSchema>, ZodRecord<ZodString, ZodJSONSchema>]
-> & {
-  _zod: {
-    input: util.JSONType;
-    output: util.JSONType;
-  };
-};
+>;
+type _ZodJSONSchemaInternals = _ZodJSONSchema["_zod"];
+
+export interface ZodJSONSchemaInternals extends _ZodJSONSchemaInternals {
+  output: util.JSONType;
+  input: util.JSONType;
+}
+export interface ZodJSONSchema extends _ZodJSONSchema {
+  _zod: ZodJSONSchemaInternals;
+}
 
 export function json(params?: string | core.$ZodCustomParams): ZodJSONSchema {
   const jsonSchema: any = lazy(() => {
@@ -2029,13 +2044,11 @@ export function json(params?: string | core.$ZodCustomParams): ZodJSONSchema {
 }
 
 // preprocess
-export interface ZodPreprocessParams extends core.$ZodTransformParams, core.$ZodPipeParams {}
 
 // /** @deprecated Use `z.pipe()` and `z.transform()` instead. */
-export function preprocess<A, U extends core.$ZodType>(
-  fn: (arg: unknown, ctx: RefinementCtx) => A,
-  schema: U,
-  params?: ZodPreprocessParams
-): ZodPipe<ZodTransform<A, unknown>, U> {
-  return pipe(transform(fn as any, params), schema as any, params);
+export function preprocess<A, U extends core.SomeType, B = unknown>(
+  fn: (arg: B, ctx: RefinementCtx) => A,
+  schema: U
+): ZodPipe<ZodTransform<A, B>, U> {
+  return pipe(transform(fn as any), schema as any) as any;
 }