npm - zod - Versions diffs - 3.25.3 → 3.25.4 - Mend

zod 3.25.3 → 3.25.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/commonjs/v3/types.d.ts +38 -38
package/dist/esm/v3/types.d.ts +38 -38
package/package.json +1 -1
package/src/v3/types.ts +50 -41

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

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

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

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

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.25.3",
+  "version": "3.25.4",
   "type": "module",
   "author": "Colin McDonnell <zod@colinhacks.com>",
   "description": "TypeScript-first schema declaration and validation library with static type inference",

package/src/v3/types.ts CHANGED Viewed

@@ -2340,7 +2340,7 @@ export class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCardinality
     return this.min(1, message) as any;
   }
-  static create = <T extends ZodTypeAny>(schema: T, params?: RawCreateParams): ZodArray<T> => {
+  static create = <El extends ZodTypeAny>(schema: El, params?: RawCreateParams): ZodArray<El> => {
     return new ZodArray({
       type: schema,
       minLength: null,
@@ -2874,15 +2874,15 @@ export class ZodObject<
     return createZodEnum(util.objectKeys(this.shape) as [string, ...string[]]) as any;
   }
-  static create = <T extends ZodRawShape>(
-    shape: T,
+  static create = <Shape extends ZodRawShape>(
+    shape: Shape,
     params?: RawCreateParams
   ): ZodObject<
-    T,
+    Shape,
     "strip",
     ZodTypeAny,
-    objectOutputType<T, ZodTypeAny, "strip">,
-    objectInputType<T, ZodTypeAny, "strip">
+    objectOutputType<Shape, ZodTypeAny, "strip">,
+    objectInputType<Shape, ZodTypeAny, "strip">
   > => {
     return new ZodObject({
       shape: () => shape,
@@ -2893,7 +2893,10 @@ export class ZodObject<
     }) as any;
   };
-  static strictCreate = <T extends ZodRawShape>(shape: T, params?: RawCreateParams): ZodObject<T, "strict"> => {
+  static strictCreate = <Shape extends ZodRawShape>(
+    shape: Shape,
+    params?: RawCreateParams
+  ): ZodObject<Shape, "strict"> => {
     return new ZodObject({
       shape: () => shape,
       unknownKeys: "strict",
@@ -2903,7 +2906,10 @@ export class ZodObject<
     }) as any;
   };
-  static lazycreate = <T extends ZodRawShape>(shape: () => T, params?: RawCreateParams): ZodObject<T, "strip"> => {
+  static lazycreate = <Shape extends ZodRawShape>(
+    shape: () => Shape,
+    params?: RawCreateParams
+  ): ZodObject<Shape, "strip"> => {
     return new ZodObject({
       shape,
       unknownKeys: "strip",
@@ -3035,10 +3041,10 @@ export class ZodUnion<T extends ZodUnionOptions> extends ZodType<
     return this._def.options;
   }
-  static create = <T extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(
-    types: T,
+  static create = <Options extends Readonly<[ZodTypeAny, ZodTypeAny, ...ZodTypeAny[]]>>(
+    types: Options,
     params?: RawCreateParams
-  ): ZodUnion<T> => {
+  ): ZodUnion<Options> => {
     return new ZodUnion({
       options: types,
       typeName: ZodFirstPartyTypeKind.ZodUnion,
@@ -3335,11 +3341,11 @@ export class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny> extends
     }
   }
-  static create = <T extends ZodTypeAny, U extends ZodTypeAny>(
-    left: T,
-    right: U,
+  static create = <TSchema extends ZodTypeAny, USchema extends ZodTypeAny>(
+    left: TSchema,
+    right: USchema,
     params?: RawCreateParams
-  ): ZodIntersection<T, U> => {
+  ): ZodIntersection<TSchema, USchema> => {
     return new ZodIntersection({
       left: left,
       right: right,
@@ -3451,10 +3457,10 @@ export class ZodTuple<
     });
   }
-  static create = <T extends [ZodTypeAny, ...ZodTypeAny[]] | []>(
-    schemas: T,
+  static create = <Items extends [ZodTypeAny, ...ZodTypeAny[]] | []>(
+    schemas: Items,
     params?: RawCreateParams
-  ): ZodTuple<T, null> => {
+  ): ZodTuple<Items, null> => {
     if (!Array.isArray(schemas)) {
       throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
     }
@@ -3646,11 +3652,11 @@ export class ZodMap<Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAn
       return { status: status.value, value: finalMap };
     }
   }
-  static create = <Key extends ZodTypeAny = ZodTypeAny, Value extends ZodTypeAny = ZodTypeAny>(
-    keyType: Key,
-    valueType: Value,
+  static create = <KeySchema extends ZodTypeAny = ZodTypeAny, ValueSchema extends ZodTypeAny = ZodTypeAny>(
+    keyType: KeySchema,
+    valueType: ValueSchema,
     params?: RawCreateParams
-  ): ZodMap<Key, Value> => {
+  ): ZodMap<KeySchema, ValueSchema> => {
     return new ZodMap({
       valueType,
       keyType,
@@ -3765,10 +3771,10 @@ export class ZodSet<Value extends ZodTypeAny = ZodTypeAny> extends ZodType<
     return this.min(1, message) as any;
   }
-  static create = <Value extends ZodTypeAny = ZodTypeAny>(
-    valueType: Value,
+  static create = <ValueSchema extends ZodTypeAny = ZodTypeAny>(
+    valueType: ValueSchema,
     params?: RawCreateParams
-  ): ZodSet<Value> => {
+  ): ZodSet<ValueSchema> => {
     return new ZodSet({
       valueType,
       minSize: null,
@@ -3973,7 +3979,7 @@ export class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, ZodLazyDef
     return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
   }
-  static create = <T extends ZodTypeAny>(getter: () => T, params?: RawCreateParams): ZodLazy<T> => {
+  static create = <Inner extends ZodTypeAny>(getter: () => Inner, params?: RawCreateParams): ZodLazy<Inner> => {
     return new ZodLazy({
       getter: getter,
       typeName: ZodFirstPartyTypeKind.ZodLazy,
@@ -4012,7 +4018,7 @@ export class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>, T> {
     return this._def.value;
   }
-  static create = <T extends Primitive>(value: T, params?: RawCreateParams): ZodLiteral<T> => {
+  static create = <Value extends Primitive>(value: Value, params?: RawCreateParams): ZodLiteral<Value> => {
     return new ZodLiteral({
       value: value,
       typeName: ZodFirstPartyTypeKind.ZodLiteral,
@@ -4202,7 +4208,7 @@ export class ZodNativeEnum<T extends EnumLike> extends ZodType<T[keyof T], ZodNa
     return this._def.values;
   }
-  static create = <T extends EnumLike>(values: T, params?: RawCreateParams): ZodNativeEnum<T> => {
+  static create = <Elements extends EnumLike>(values: Elements, params?: RawCreateParams): ZodNativeEnum<Elements> => {
     return new ZodNativeEnum({
       values: values,
       typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
@@ -4255,7 +4261,7 @@ export class ZodPromise<T extends ZodTypeAny> extends ZodType<
     );
   }
-  static create = <T extends ZodTypeAny>(schema: T, params?: RawCreateParams): ZodPromise<T> => {
+  static create = <Inner extends ZodTypeAny>(schema: Inner, params?: RawCreateParams): ZodPromise<Inner> => {
     return new ZodPromise({
       type: schema,
       typeName: ZodFirstPartyTypeKind.ZodPromise,
@@ -4490,7 +4496,7 @@ export class ZodOptional<T extends ZodTypeAny> extends ZodType<
     return this._def.innerType;
   }
-  static create = <T extends ZodTypeAny>(type: T, params?: RawCreateParams): ZodOptional<T> => {
+  static create = <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams): ZodOptional<Inner> => {
     return new ZodOptional({
       innerType: type,
       typeName: ZodFirstPartyTypeKind.ZodOptional,
@@ -4530,7 +4536,7 @@ export class ZodNullable<T extends ZodTypeAny> extends ZodType<
     return this._def.innerType;
   }
-  static create = <T extends ZodTypeAny>(type: T, params?: RawCreateParams): ZodNullable<T> => {
+  static create = <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams): ZodNullable<Inner> => {
     return new ZodNullable({
       innerType: type,
       typeName: ZodFirstPartyTypeKind.ZodNullable,
@@ -4574,12 +4580,12 @@ export class ZodDefault<T extends ZodTypeAny> extends ZodType<
     return this._def.innerType;
   }
-  static create = <T extends ZodTypeAny>(
-    type: T,
+  static create = <Inner extends ZodTypeAny>(
+    type: Inner,
     params: RawCreateParams & {
-      default: T["_input"] | (() => util.noUndefined<T["_input"]>);
+      default: Inner["_input"] | (() => util.noUndefined<Inner["_input"]>);
     }
-  ): ZodDefault<T> => {
+  ): ZodDefault<Inner> => {
     return new ZodDefault({
       innerType: type,
       typeName: ZodFirstPartyTypeKind.ZodDefault,
@@ -4662,12 +4668,12 @@ export class ZodCatch<T extends ZodTypeAny> extends ZodType<
     return this._def.innerType;
   }
-  static create = <T extends ZodTypeAny>(
-    type: T,
+  static create = <Inner extends ZodTypeAny>(
+    type: Inner,
     params: RawCreateParams & {
-      catch: T["_output"] | (() => T["_output"]);
+      catch: Inner["_output"] | (() => Inner["_output"]);
     }
-  ): ZodCatch<T> => {
+  ): ZodCatch<Inner> => {
     return new ZodCatch({
       innerType: type,
       typeName: ZodFirstPartyTypeKind.ZodCatch,
@@ -4815,7 +4821,10 @@ export class ZodPipeline<A extends ZodTypeAny, B extends ZodTypeAny> extends Zod
     }
   }
-  static create<A extends ZodTypeAny, B extends ZodTypeAny>(a: A, b: B): ZodPipeline<A, B> {
+  static create<ASchema extends ZodTypeAny, BSchema extends ZodTypeAny>(
+    a: ASchema,
+    b: BSchema
+  ): ZodPipeline<ASchema, BSchema> {
     return new ZodPipeline({
       in: a,
       out: b,
@@ -4873,7 +4882,7 @@ export class ZodReadonly<T extends ZodTypeAny> extends ZodType<
     return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
   }
-  static create = <T extends ZodTypeAny>(type: T, params?: RawCreateParams): ZodReadonly<T> => {
+  static create = <Inner extends ZodTypeAny>(type: Inner, params?: RawCreateParams): ZodReadonly<Inner> => {
     return new ZodReadonly({
       innerType: type,
       typeName: ZodFirstPartyTypeKind.ZodReadonly,