zod 4.0.0-beta.20250411T005215 → 4.0.0-beta.20250411T232125

package/src/schemas.ts

@@ -7,8 +7,6 @@ import * as parse from "./parse.js";
 export * as iso from "./iso.js";
 export * as coerce from "./coerce.js";
 
-type SomeType = core.$ZodType;
-
 ///////////////////////////////////////////
 ///////////////////////////////////////////
 ////////////                   ////////////
@@ -25,6 +23,10 @@ export interface ZodType<out Output = unknown, out Input = unknown> extends core
   def: this["_zod"]["def"];
   /** @deprecated Use `.def` instead. */
   _def: this["_zod"]["def"];
+  /** @deprecated Use `z.output<typeof schema>` instead. */
+  _output: this["_zod"]["output"];
+  /** @deprecated Use `z.input<typeof schema>` instead. */
+  _input: this["_zod"]["input"];
   // base methods
   check(...checks: (core.CheckFn<this["_zod"]["output"]> | core.$ZodCheck<this["_zod"]["output"]>)[]): this;
   clone(def?: this["_zod"]["def"]): this;
@@ -70,7 +72,7 @@ export interface ZodType<out Output = unknown, out Input = unknown> extends core
   default(def: () => util.NoUndefined<core.output<this>>, params?: core.$ZodDefaultParams): ZodDefault<this>;
   array(): ZodArray<this>;
   or<T extends core.$ZodType>(option: T): ZodUnion<[this, T]>;
-  // and<T extends core.$ZodType>(incoming: T): ZodIntersection<this, T>;
+  and<T extends core.$ZodType>(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>>>;
@@ -135,7 +137,7 @@ export const ZodType: core.$constructor<ZodType> = /*@__PURE__*/ core.$construct
   inst.nonoptional = (params) => nonoptional(inst, params);
   inst.array = () => array(inst);
   inst.or = (arg) => union([inst, arg]);
-  // inst.and = (arg) => intersection(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.coalesce = (def, params) => coalesce(inst, def, params);
@@ -979,7 +981,7 @@ export function date(params?: string | core.$ZodDateParams): ZodDate {
 }
 
 // ZodArray
-export interface ZodArray<T extends SomeType = SomeType> extends ZodType {
+export interface ZodArray<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodArrayInternals<T>;
 
   element: T;
@@ -999,8 +1001,8 @@ export const ZodArray: core.$constructor<ZodArray> = /*@__PURE__*/ core.$constru
   inst.length = (len, params) => inst.check(checks.length(len, params));
 });
 
-export function array<T extends SomeType>(element: T, params?: core.$ZodArrayParams): ZodArray<T>;
-export function array<T extends SomeType>(element: SomeType, params?: any): ZodArray<T> {
+export function array<T extends core.$ZodType>(element: T, params?: 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;
 }
 
@@ -1017,7 +1019,7 @@ export const ZodObjectLike: core.$constructor<ZodObjectLike> = /*@__PURE__*/ cor
 );
 
 // .keyof
-export function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["shape"]>;
+export function keyof<T extends ZodObject>(schema: T): ZodLiteral<keyof T["_zod"]["def"]["shape"]>;
 export function keyof<T extends ZodInterface>(schema: T): ZodLiteral<keyof T["_zod"]["output"]>;
 export function keyof(schema: ZodObjectLike) {
   const shape =
@@ -1031,12 +1033,12 @@ export function keyof(schema: ZodObjectLike) {
 // ZodInterface
 type ZodInterfacePartial<
   T extends ZodInterface,
-  Keys extends keyof T["_zod"]["shape"] = keyof T["_zod"]["shape"],
+  Keys extends keyof T["_zod"]["def"]["shape"] = keyof T["_zod"]["def"]["shape"],
 > = ZodInterface<
   util.ExtendShape<
-    T["_zod"]["shape"],
+    T["_zod"]["def"]["shape"],
     {
-      [k in Keys]: ZodOptional<T["_zod"]["shape"][k]>;
+      [k in Keys]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
     }
   >,
   {
@@ -1048,12 +1050,12 @@ type ZodInterfacePartial<
 
 type ZodInterfaceRequired<
   T extends ZodInterface,
-  Keys extends keyof T["_zod"]["shape"] = keyof T["_zod"]["shape"],
+  Keys extends keyof T["_zod"]["def"]["shape"] = keyof T["_zod"]["def"]["shape"],
 > = ZodInterface<
   util.ExtendShape<
-    T["_zod"]["shape"],
+    T["_zod"]["def"]["shape"],
     {
-      [k in Keys]: ZodNonOptional<T["_zod"]["shape"][k]>;
+      [k in Keys]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
     }
   >,
   {
@@ -1063,8 +1065,8 @@ type ZodInterfaceRequired<
   }
 >;
 
-type MergeInterfaces<A extends ZodInterface, B extends ZodInterface> = ZodInterface<
-  util.ExtendShape<A["_zod"]["shape"], B["_zod"]["shape"]>,
+export type MergeInterfaces<A extends ZodInterface, B extends ZodInterface> = ZodInterface<
+  util.ExtendShape<A["_zod"]["def"]["shape"], B["_zod"]["def"]["shape"]>,
   util.MergeInterfaceParams<A, B>
 >;
 
@@ -1117,7 +1119,7 @@ export interface ZodInterface<
     shape: U
   ): MergeInterfaces<this, ZodInterface<U, util.InitInterfaceParams<U, {}>>>;
 
-  /** @deprecated Use `.extend()` */
+  /** @deprecated Use `A.extend(B)` */
   merge<U extends ZodInterface>(incoming: U): MergeInterfaces<this, U>;
 
   pick<const M extends util.Exactly<util.Mask<string & keyof Shape>, M>>(
@@ -1153,7 +1155,7 @@ export const ZodInterface: core.$constructor<ZodInterface> = /*@__PURE__*/ core.
   (inst, def) => {
     core.$ZodInterface.init(inst, def);
     ZodType.init(inst, def);
-    util.defineLazy(inst._zod, "shape", () => def.shape);
+    // util.defineLazy(inst._zod, "shape", () => def.shape);
 
     inst.keyof = () => _enum(Object.keys(inst._zod.def.shape));
     inst.catchall = (catchall) => inst.clone({ ...inst._zod.def, catchall });
@@ -1270,12 +1272,7 @@ export interface ZodObject<
   /** @deprecated This is the default behavior. This method call is likely unnecessary. */
   strip(): ZodObject<Shape, {}>;
 
-  extend<U extends ZodObject>(
-    shape: U
-  ): ZodObject<
-    util.ExtendShape<Shape, U["_zod"]["shape"]>,
-    Extra // & B['_zod']["extra"]
-  >;
+  extend<const U extends ZodObject>(schema: U): ZodObject<util.ExtendShape<Shape, U["_zod"]["def"]["shape"]>, Extra>;
   extend<U extends core.$ZodShape>(
     shape: U
   ): ZodObject<
@@ -1351,7 +1348,7 @@ export const ZodObject: core.$constructor<ZodObject> = /*@__PURE__*/ core.$const
   inst.partial = (...args: any[]) => util.partialObjectLike(ZodOptional, inst, args[0] as object);
   inst.required = (...args: any[]) => util.requiredObjectLike(ZodNonOptional, inst, args[0] as object);
 });
-export function object<T extends core.$ZodShape = Record<never, SomeType>>(
+export function object<T extends core.$ZodShape = Record<never, core.$ZodType>>(
   shape?: T,
   params?: core.$ZodObjectLikeParams
 ): ZodObject<T, {}> {
@@ -1401,17 +1398,23 @@ export function looseObject<T extends core.$ZodShape>(
 export function extend<T extends ZodInterface, U extends ZodInterface>(
   a: T,
   b: U
-): ZodInterface<util.ExtendShape<T["_zod"]["shape"], U["_zod"]["shape"]>, util.MergeInterfaceParams<T, U>>;
+): ZodInterface<
+  util.ExtendShape<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>,
+  util.MergeInterfaceParams<T, U>
+>;
 export function extend<T extends ZodObject, U extends ZodObject>(
   a: T,
   b: U
-): ZodObject<util.ExtendObject<T["_zod"]["shape"], U["_zod"]["shape"]>, U["_zod"]["extra"] & T["_zod"]["extra"]>;
+): ZodObject<
+  util.ExtendObject<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>,
+  U["_zod"]["extra"] & T["_zod"]["extra"]
+>;
 export function extend<T extends ZodObjectLike, U extends core.$ZodLooseShape>(
   schema: T,
   shape: U
 ): T extends ZodInterface<infer TShape, infer TParams>
   ? ZodInterface<util.ExtendInterfaceShape<TShape, U>, util.ExtendInterfaceParams<ZodInterface<TShape, TParams>, U>>
-  : ZodObject<util.ExtendObject<T["_zod"]["shape"], U>, T["_zod"]["extra"]>;
+  : ZodObject<util.ExtendObject<T["_zod"]["def"]["shape"], U>, T["_zod"]["extra"]>;
 export function extend(schema: ZodObjectLike, shape: core.$ZodShape): ZodObjectLike {
   if (shape instanceof core.$ZodType) return util.mergeObjectLike(schema, shape as any);
   if (schema instanceof ZodInterface) {
@@ -1427,51 +1430,57 @@ export function merge<T extends ZodObjectLike, U extends core.$ZodLooseShape>(
 ): T["_zod"]["def"]["type"] extends "interface"
   ? // T extends ZodInterface
     ZodInterface<
-      util.ExtendShape<T["_zod"]["shape"], U["_zod"]["shape"]>,
+      util.ExtendShape<T["_zod"]["def"]["shape"], U["_zod"]["def"]["shape"]>,
       {
         extra: T["_zod"]["extra"] & U["_zod"]["extra"];
-        optional: Exclude<T["_zod"]["optional"], keyof U["_zod"]["shape"]> | U["_zod"]["optional"];
-        defaulted: Exclude<T["_zod"]["defaulted"], keyof U["_zod"]["shape"]> | U["_zod"]["defaulted"];
+        optional: Exclude<T["_zod"]["optional"], keyof U["_zod"]["def"]["shape"]> | U["_zod"]["optional"];
+        defaulted: Exclude<T["_zod"]["defaulted"], keyof U["_zod"]["def"]["shape"]> | U["_zod"]["defaulted"];
       }
     >
-  : ZodObject<util.ExtendObject<T["_zod"]["shape"], U>, T["_zod"]["extra"]>;
+  : ZodObject<util.ExtendObject<T["_zod"]["def"]["shape"], U>, T["_zod"]["extra"]>;
 export function merge(a: ZodObjectLike, b: ZodObjectLike): ZodObjectLike {
   return util.mergeObjectLike(a, b);
 }
 
 // .pick
-export function pick<T extends ZodObjectLike, M extends util.Exactly<util.Mask<keyof T["_zod"]["shape"]>, M>>(
+export function pick<T extends ZodObjectLike, M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(
   schema: T,
   mask: M
 ): T["_zod"]["def"]["type"] extends "interface"
   ? ZodInterface<
-      util.Flatten<Pick<T["_zod"]["shape"], keyof T["_zod"]["shape"] & keyof M>>,
+      util.Flatten<Pick<T["_zod"]["def"]["shape"], keyof T["_zod"]["def"]["shape"] & keyof M>>,
       {
         optional: Extract<T["_zod"]["optional"], keyof M>;
         defaulted: Extract<T["_zod"]["defaulted"], keyof M>;
         extra: T["_zod"]["extra"];
       }
     >
-  : ZodObject<util.Flatten<Pick<T["_zod"]["shape"], keyof T["_zod"]["shape"] & keyof M>>, T["_zod"]["extra"]>;
+  : ZodObject<
+      util.Flatten<Pick<T["_zod"]["def"]["shape"], keyof T["_zod"]["def"]["shape"] & keyof M>>,
+      T["_zod"]["extra"]
+    >;
 export function pick(schema: ZodObjectLike, mask: object) {
   // const picked = util.pick(schema, mask);
   return util.pick(schema, mask);
 }
 
 // .omit
-export function omit<T extends ZodObjectLike, const M extends util.Exactly<util.Mask<keyof T["_zod"]["shape"]>, M>>(
+export function omit<
+  T extends ZodObjectLike,
+  const M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>,
+>(
   schema: T,
   mask: M
 ): T["_zod"]["def"]["type"] extends "interface"
   ? ZodInterface<
-      util.Flatten<Omit<T["_zod"]["shape"], keyof M>>,
+      util.Flatten<Omit<T["_zod"]["def"]["shape"], keyof M>>,
       {
         optional: Exclude<T["_zod"]["optional"], keyof M>;
         defaulted: Exclude<T["_zod"]["defaulted"], keyof M>;
         extra: T["_zod"]["extra"];
       }
     >
-  : ZodObject<util.Flatten<Omit<T["_zod"]["shape"], keyof M>>, T["_zod"]["extra"]>;
+  : ZodObject<util.Flatten<Omit<T["_zod"]["def"]["shape"], keyof M>>, T["_zod"]["extra"]>;
 
 export function omit(schema: ZodObjectLike, mask: object) {
   return util.omit(schema, mask);
@@ -1483,29 +1492,29 @@ export function partial<T extends ZodObjectLike>(
   ? ZodInterface<
       // T['_zod']["shape"],
       {
-        [k in keyof T["_zod"]["shape"]]: ZodOptional<T["_zod"]["shape"][k]>;
+        [k in keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
       },
       {
-        optional: string & keyof T["_zod"]["shape"];
+        optional: string & keyof T["_zod"]["def"]["shape"];
         defaulted: never;
         extra: T["_zod"]["extra"];
       }
     >
   : ZodObject<
       {
-        [k in keyof T["_zod"]["shape"]]: ZodOptional<T["_zod"]["shape"][k]>;
+        [k in keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
       },
       T["_zod"]["extra"]
     >;
-export function partial<T extends ZodObjectLike, M extends util.Exactly<util.Mask<keyof T["_zod"]["shape"]>, M>>(
+export function partial<T extends ZodObjectLike, M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>>(
   schema: T,
   mask: M
 ): T["_zod"]["def"]["type"] extends "interface"
   ? ZodInterface<
       util.ExtendShape<
-        T["_zod"]["shape"],
+        T["_zod"]["def"]["shape"],
         {
-          [k in keyof M & keyof T["_zod"]["shape"]]: ZodOptional<T["_zod"]["shape"][k]>;
+          [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodOptional<T["_zod"]["def"]["shape"][k]>;
         }
       >,
       {
@@ -1516,7 +1525,9 @@ export function partial<T extends ZodObjectLike, M extends util.Exactly<util.Mas
     >
   : ZodObject<
       {
-        [k in keyof T["_zod"]["shape"]]: k extends keyof M ? ZodOptional<T["_zod"]["shape"][k]> : T["_zod"]["shape"][k];
+        [k in keyof T["_zod"]["def"]["shape"]]: k extends keyof M
+          ? ZodOptional<T["_zod"]["def"]["shape"][k]>
+          : T["_zod"]["def"]["shape"][k];
       },
       T["_zod"]["extra"]
     >;
@@ -1529,19 +1540,19 @@ export function partial(schema: ZodObjectLike, mask?: object): ZodObjectLike {
 export function required<T extends { _subtype: "object" } & ZodObject>(
   schema: T
 ): ZodObject<{
-  [k in keyof T["_zod"]["shape"]]: ZodNonOptional<T["_zod"]["shape"][k]>;
+  [k in keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
 }>;
 export function required<
   T extends { _subtype: "object" } & ZodObject,
-  M extends util.Exactly<util.Mask<keyof T["_zod"]["shape"]>, M>,
+  M extends util.Exactly<util.Mask<keyof T["_zod"]["def"]["shape"]>, M>,
 >(
   schema: T,
   mask: M
 ): ZodObject<
   util.ExtendShape<
-    T["_zod"]["shape"],
+    T["_zod"]["def"]["shape"],
     {
-      [k in keyof M & keyof T["_zod"]["shape"]]: ZodNonOptional<T["_zod"]["shape"][k]>;
+      [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
     }
   >
 >;
@@ -1549,7 +1560,7 @@ export function required<T extends { _subtype: "interface" } & ZodInterface>(
   schema: T
 ): ZodInterface<
   {
-    [k in keyof T["_zod"]["shape"]]: ZodNonOptional<T["_zod"]["shape"][k]>;
+    [k in keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
   },
   {
     optional: never;
@@ -1565,9 +1576,9 @@ export function required<
   mask: M
 ): ZodInterface<
   util.ExtendShape<
-    T["_zod"]["shape"],
+    T["_zod"]["def"]["shape"],
     {
-      [k in keyof M & keyof T["_zod"]["shape"]]: ZodNonOptional<T["_zod"]["shape"][k]>;
+      [k in keyof M & keyof T["_zod"]["def"]["shape"]]: ZodNonOptional<T["_zod"]["def"]["shape"][k]>;
     }
   >,
   {
@@ -1581,7 +1592,7 @@ export function required(schema: ZodObjectLike, mask?: object): ZodObjectLike {
 }
 
 // ZodUnion
-export interface ZodUnion<T extends readonly SomeType[] = readonly SomeType[]> extends ZodType {
+export interface ZodUnion<T extends readonly core.$ZodType[] = readonly core.$ZodType[]> extends ZodType {
   _zod: core.$ZodUnionInternals<T>;
   options: T;
 }
@@ -1591,7 +1602,10 @@ export const ZodUnion: core.$constructor<ZodUnion> = /*@__PURE__*/ core.$constru
   inst.options = def.options;
 });
 
-export function union<const T extends readonly SomeType[]>(options: T, params?: core.$ZodUnionParams): ZodUnion<T> {
+export function union<const T extends readonly core.$ZodType[]>(
+  options: T,
+  params?: core.$ZodUnionParams
+): ZodUnion<T> {
   return new ZodUnion({
     type: "union",
     options,
@@ -1600,7 +1614,7 @@ export function union<const T extends readonly SomeType[]>(options: T, params?:
 }
 
 // ZodDiscriminatedUnion
-export interface ZodDiscriminatedUnion<Options extends readonly SomeType[] = readonly SomeType[]>
+export interface ZodDiscriminatedUnion<Options extends readonly core.$ZodType[] = readonly core.$ZodType[]>
   extends ZodUnion<Options> {
   _zod: core.$ZodDiscriminatedUnionInternals<Options>;
 }
@@ -1640,7 +1654,8 @@ export function discriminatedUnion(...args: any[]): any {
 }
 
 // ZodIntersection
-export interface ZodIntersection<A extends SomeType = SomeType, B extends SomeType = SomeType> extends ZodType {
+export interface ZodIntersection<A extends core.$ZodType = core.$ZodType, B extends core.$ZodType = core.$ZodType>
+  extends ZodType {
   _zod: core.$ZodIntersectionInternals<A, B>;
 }
 export const ZodIntersection: core.$constructor<ZodIntersection> = /*@__PURE__*/ core.$constructor(
@@ -1651,7 +1666,7 @@ export const ZodIntersection: core.$constructor<ZodIntersection> = /*@__PURE__*/
   }
 );
 
-export function intersection<T extends SomeType, U extends SomeType>(
+export function intersection<T extends core.$ZodType, U extends core.$ZodType>(
   left: T,
   right: U,
   params?: core.$ZodIntersectionParams
@@ -1665,8 +1680,10 @@ export function intersection<T extends SomeType, U extends SomeType>(
 }
 
 // ZodTuple
-export interface ZodTuple<T extends util.TupleItems = util.TupleItems, Rest extends SomeType | null = SomeType | null>
-  extends ZodType {
+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>;
 }
@@ -1680,19 +1697,19 @@ export const ZodTuple: core.$constructor<ZodTuple> = /*@__PURE__*/ core.$constru
     }) as any;
 });
 
-export function tuple<T extends readonly [SomeType, ...SomeType[]]>(
+export function tuple<T extends readonly [core.$ZodType, ...core.$ZodType[]]>(
   items: T,
   params?: core.$ZodTupleParams
 ): ZodTuple<T, null>;
-export function tuple<T extends readonly [SomeType, ...SomeType[]], Rest extends SomeType>(
+export function tuple<T extends readonly [core.$ZodType, ...core.$ZodType[]], Rest extends core.$ZodType>(
   items: T,
   rest: Rest,
   params?: core.$ZodTupleParams
 ): ZodTuple<T, Rest>;
 export function tuple(items: [], params?: core.$ZodTupleParams): ZodTuple<[], null>;
 export function tuple(
-  items: SomeType[],
-  _paramsOrRest?: core.$ZodTupleParams | SomeType,
+  items: core.$ZodType[],
+  _paramsOrRest?: core.$ZodTupleParams | core.$ZodType,
   _params?: core.$ZodTupleParams
 ) {
   const hasRest = _paramsOrRest instanceof core.$ZodType;
@@ -1707,8 +1724,10 @@ export function tuple(
 }
 
 // ZodRecord
-export interface ZodRecord<Key extends core.$ZodRecordKey = core.$ZodRecordKey, Value extends SomeType = SomeType>
-  extends ZodType {
+export interface ZodRecord<
+  Key extends core.$ZodRecordKey = core.$ZodRecordKey,
+  Value extends core.$ZodType = core.$ZodType,
+> extends ZodType {
   _zod: core.$ZodRecordInternals<Key, Value>;
   keyType: Key;
   valueType: Value;
@@ -1721,7 +1740,7 @@ export const ZodRecord: core.$constructor<ZodRecord> = /*@__PURE__*/ core.$const
   inst.valueType = def.valueType;
 });
 
-export function record<Key extends core.$ZodRecordKey, Value extends SomeType>(
+export function record<Key extends core.$ZodRecordKey, Value extends core.$ZodType>(
   keyType: Key,
   valueType: Value,
   params?: core.$ZodRecordParams
@@ -1735,7 +1754,8 @@ export function record<Key extends core.$ZodRecordKey, Value extends SomeType>(
 }
 
 // ZodMap
-export interface ZodMap<Key extends SomeType = SomeType, Value extends SomeType = SomeType> extends ZodType {
+export interface ZodMap<Key extends core.$ZodType = core.$ZodType, Value extends core.$ZodType = core.$ZodType>
+  extends ZodType {
   _zod: core.$ZodMapInternals<Key, Value>;
 
   keyType: Key;
@@ -1748,7 +1768,7 @@ export const ZodMap: core.$constructor<ZodMap> = /*@__PURE__*/ core.$constructor
   inst.valueType = def.valueType;
 });
 
-export function map<Key extends SomeType, Value extends SomeType>(
+export function map<Key extends core.$ZodType, Value extends core.$ZodType>(
   keyType: Key,
   valueType: Value,
   params?: core.$ZodMapParams
@@ -1762,7 +1782,7 @@ export function map<Key extends SomeType, Value extends SomeType>(
 }
 
 // ZodSet
-export interface ZodSet<T extends SomeType = SomeType> extends ZodType {
+export interface ZodSet<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodSetInternals<T>;
   min(minSize: number, params?: core.$ZodCheckMinSizeParams): this;
   /** */
@@ -1780,7 +1800,7 @@ export const ZodSet: core.$constructor<ZodSet> = /*@__PURE__*/ core.$constructor
   inst.size = (...args) => inst.check(core._size(...args));
 });
 
-export function set<Value extends SomeType>(valueType: Value, params?: core.$ZodSetParams): ZodSet<Value> {
+export function set<Value extends core.$ZodType>(valueType: Value, params?: core.$ZodSetParams): ZodSet<Value> {
   return new ZodSet({
     type: "set",
     valueType,
@@ -1845,8 +1865,11 @@ export const ZodEnum: core.$constructor<ZodEnum> = /*@__PURE__*/ core.$construct
   };
 });
 
-function _enum<const T extends string[]>(values: T, params?: core.$ZodEnumParams): ZodEnum<util.ToEnum<T[number]>>;
-function _enum<T extends util.EnumLike>(entries: T, params?: core.$ZodEnumParams): ZodEnum<T>;
+function _enum<const T extends readonly string[]>(
+  values: T,
+  params?: core.$ZodEnumParams
+): ZodEnum<util.ToEnum<T[number]>>;
+function _enum<const T extends util.EnumLike>(entries: T, params?: core.$ZodEnumParams): ZodEnum<T>;
 function _enum(values: any, params?: core.$ZodEnumParams) {
   const entries: any = Array.isArray(values) ? Object.fromEntries(values.map((v) => [v, v])) : values;
 
@@ -1970,7 +1993,7 @@ export function transform<I = unknown, O = I>(
 }
 
 // ZodOptional
-export interface ZodOptional<T extends SomeType = SomeType> extends ZodType {
+export interface ZodOptional<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodOptionalInternals<T>;
 
   unwrap(): T;
@@ -1985,7 +2008,7 @@ export const ZodOptional: core.$constructor<ZodOptional> = /*@__PURE__*/ core.$c
   }
 );
 
-export function optional<T extends SomeType>(innerType: T, params?: core.$ZodOptionalParams): ZodOptional<T> {
+export function optional<T extends core.$ZodType>(innerType: T, params?: core.$ZodOptionalParams): ZodOptional<T> {
   return new ZodOptional({
     type: "optional",
     innerType,
@@ -1994,7 +2017,7 @@ export function optional<T extends SomeType>(innerType: T, params?: core.$ZodOpt
 }
 
 // ZodNullable
-export interface ZodNullable<T extends SomeType = SomeType> extends ZodType {
+export interface ZodNullable<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodNullableInternals<T>;
 
   unwrap(): T;
@@ -2009,7 +2032,7 @@ export const ZodNullable: core.$constructor<ZodNullable> = /*@__PURE__*/ core.$c
   }
 );
 
-export function nullable<T extends SomeType>(innerType: T, params?: core.$ZodNullableParams): ZodNullable<T> {
+export function nullable<T extends core.$ZodType>(innerType: T, params?: core.$ZodNullableParams): ZodNullable<T> {
   return new ZodNullable({
     type: "nullable",
     innerType,
@@ -2018,12 +2041,12 @@ export function nullable<T extends SomeType>(innerType: T, params?: core.$ZodNul
 }
 
 // nullish
-export function nullish<T extends SomeType>(innerType: T): ZodOptional<ZodNullable<T>> {
+export function nullish<T extends core.$ZodType>(innerType: T): ZodOptional<ZodNullable<T>> {
   return optional(nullable(innerType));
 }
 
 // ZodDefault
-export interface ZodDefault<T extends SomeType = SomeType> extends ZodType {
+export interface ZodDefault<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodDefaultInternals<T>;
 
   unwrap(): T;
@@ -2038,7 +2061,7 @@ export const ZodDefault: core.$constructor<ZodDefault> = /*@__PURE__*/ core.$con
   inst.removeDefault = inst.unwrap;
 });
 
-export function _default<T extends SomeType>(
+export function _default<T extends core.$ZodType>(
   innerType: T,
   defaultValue: util.NoUndefined<core.output<T>> | (() => util.NoUndefined<core.output<T>>),
   params?: core.$ZodDefaultParams
@@ -2052,7 +2075,7 @@ export function _default<T extends SomeType>(
 }
 
 // ZodNonOptional
-export interface ZodNonOptional<T extends SomeType = SomeType> extends ZodType {
+export interface ZodNonOptional<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodNonOptionalInternals<T>;
 
   unwrap(): T;
@@ -2067,7 +2090,10 @@ export const ZodNonOptional: core.$constructor<ZodNonOptional> = /*@__PURE__*/ c
   }
 );
 
-export function nonoptional<T extends SomeType>(innerType: T, params?: core.$ZodNonOptionalParams): ZodNonOptional<T> {
+export function nonoptional<T extends core.$ZodType>(
+  innerType: T,
+  params?: core.$ZodNonOptionalParams
+): ZodNonOptional<T> {
   return new ZodNonOptional({
     type: "nonoptional",
     innerType,
@@ -2076,7 +2102,7 @@ export function nonoptional<T extends SomeType>(innerType: T, params?: core.$Zod
 }
 
 // ZodSuccess
-export interface ZodSuccess<T extends SomeType = SomeType> extends ZodType {
+export interface ZodSuccess<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodSuccessInternals<T>;
 
   unwrap(): T;
@@ -2088,7 +2114,7 @@ export const ZodSuccess: core.$constructor<ZodSuccess> = /*@__PURE__*/ core.$con
   inst.unwrap = () => inst._zod.def.innerType;
 });
 
-export function success<T extends SomeType>(innerType: T, params?: core.$ZodSuccessParams): ZodSuccess<T> {
+export function success<T extends core.$ZodType>(innerType: T, params?: core.$ZodSuccessParams): ZodSuccess<T> {
   return new ZodSuccess({
     type: "success",
     innerType,
@@ -2097,7 +2123,7 @@ export function success<T extends SomeType>(innerType: T, params?: core.$ZodSucc
 }
 
 // ZodCatch
-export interface ZodCatch<T extends SomeType = SomeType> extends ZodType {
+export interface ZodCatch<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodCatchInternals<T>;
 
   unwrap(): T;
@@ -2112,7 +2138,7 @@ export const ZodCatch: core.$constructor<ZodCatch> = /*@__PURE__*/ core.$constru
   inst.removeCatch = inst.unwrap;
 });
 
-function _catch<T extends SomeType>(
+function _catch<T extends core.$ZodType>(
   innerType: T,
   catchValue: core.output<T> | ((ctx: core.$ZodCatchCtx) => core.output<T>),
   params?: core.$ZodCatchParams
@@ -2142,7 +2168,8 @@ export function nan(params?: string | core.$ZodNaNParams): ZodNaN {
 }
 
 // ZodPipe
-export interface ZodPipe<A extends SomeType = SomeType, B extends SomeType = SomeType> extends ZodType {
+export interface ZodPipe<A extends core.$ZodType = core.$ZodType, B extends core.$ZodType = core.$ZodType>
+  extends ZodType {
   _zod: core.$ZodPipeInternals<A, B>;
 
   in: A;
@@ -2170,7 +2197,7 @@ export function pipe(in_: core.$ZodType, out: core.$ZodType, params?: core.$ZodP
 }
 
 // ZodReadonly
-export interface ZodReadonly<T extends SomeType = SomeType> extends ZodType {
+export interface ZodReadonly<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodReadonlyInternals<T>;
 }
 export const ZodReadonly: core.$constructor<ZodReadonly> = /*@__PURE__*/ core.$constructor(
@@ -2181,7 +2208,7 @@ export const ZodReadonly: core.$constructor<ZodReadonly> = /*@__PURE__*/ core.$c
   }
 );
 
-export function readonly<T extends SomeType>(innerType: T, params?: core.$ZodReadonlyParams): ZodReadonly<T> {
+export function readonly<T extends core.$ZodType>(innerType: T, params?: core.$ZodReadonlyParams): ZodReadonly<T> {
   return new ZodReadonly({
     type: "readonly",
     innerType,
@@ -2213,7 +2240,7 @@ export function templateLiteral<const Parts extends core.$TemplateLiteralPart[]>
 }
 
 // ZodLazy
-export interface ZodLazy<T extends SomeType = SomeType> extends ZodType {
+export interface ZodLazy<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodLazyInternals<T>;
 
   unwrap(): T;
@@ -2225,7 +2252,7 @@ export const ZodLazy: core.$constructor<ZodLazy> = /*@__PURE__*/ core.$construct
   inst.unwrap = () => inst._zod.def.getter();
 });
 
-export function lazy<T extends SomeType>(getter: () => T): ZodLazy<T> {
+export function lazy<T extends core.$ZodType>(getter: () => T): ZodLazy<T> {
   return new ZodLazy({
     type: "lazy",
     getter,
@@ -2233,7 +2260,7 @@ export function lazy<T extends SomeType>(getter: () => T): ZodLazy<T> {
 }
 
 // ZodPromise
-export interface ZodPromise<T extends SomeType = SomeType> extends ZodType {
+export interface ZodPromise<T extends core.$ZodType = core.$ZodType> extends ZodType {
   _zod: core.$ZodPromiseInternals<T>;
 
   unwrap(): T;
@@ -2245,7 +2272,7 @@ export const ZodPromise: core.$constructor<ZodPromise> = /*@__PURE__*/ core.$con
   inst.unwrap = () => inst._zod.def.innerType;
 });
 
-export function promise<T extends SomeType>(innerType: T, params?: core.$ZodPromiseParams): ZodPromise<T> {
+export function promise<T extends core.$ZodType>(innerType: T, params?: core.$ZodPromiseParams): ZodPromise<T> {
   return new ZodPromise({
     type: "promise",
     innerType,