zod 3.25.49 → 3.25.50

package/dist/types/v4/core/schemas.d.ts

@@ -26,18 +26,13 @@ export interface $ZodTypeDef {
     error?: errors.$ZodErrorMap<never> | undefined;
     checks?: checks.$ZodCheck<never>[];
 }
-/** @internal */
-export interface $ZodTypeInternals<out O = unknown, out I = unknown> {
+export interface _$ZodTypeInternals {
     /** The `@zod/core` version of this schema */
     version: typeof version;
     /** Schema definition. */
     def: $ZodTypeDef;
     /** @internal Randomly generated ID for this schema. */
     id: string;
-    /** @internal The inferred output type */
-    output: O;
-    /** @internal The inferred input type */
-    input: I;
     /** @internal List of deferred initializers. */
     deferred: util.AnyFunc[] | undefined;
     /** @internal Parses input and runs all checks (refinements). */
@@ -75,9 +70,19 @@ export interface $ZodTypeInternals<out O = unknown, out I = unknown> {
     /** @internal The parent of this schema. Only set during certain clone operations. */
     parent?: $ZodType | undefined;
 }
-export type $ZodStandardSchema<T extends $ZodType> = StandardSchemaV1.Props<core.input<T>, core.output<T>>;
-export interface $ZodType<O = unknown, I = unknown> {
-    _zod: $ZodTypeInternals<O, I>;
+/** @internal */
+export interface $ZodTypeInternals<out O = unknown, out I = unknown> extends _$ZodTypeInternals {
+    /** @internal The inferred output type */
+    output: O;
+    /** @internal The inferred input type */
+    input: I;
+}
+export type $ZodStandardSchema<T> = StandardSchemaV1.Props<core.input<T>, core.output<T>>;
+export interface _$ZodType<T extends _$ZodTypeInternals = _$ZodTypeInternals> {
+    _zod: T;
+}
+export type SomeType = _$ZodType;
+export interface $ZodType<O = unknown, I = unknown, Internals extends $ZodTypeInternals<O, I> = $ZodTypeInternals<O, I>> extends _$ZodType<Internals> {
     "~standard": $ZodStandardSchema<this>;
 }
 export declare const $ZodType: core.$constructor<$ZodType>;
@@ -496,15 +501,15 @@ export interface $ZodDate<T = unknown> extends $ZodType {
     _zod: $ZodDateInternals<T>;
 }
 export declare const $ZodDate: core.$constructor<$ZodDate>;
-export interface $ZodArrayDef<T extends $ZodType = $ZodType> extends $ZodTypeDef {
+export interface $ZodArrayDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "array";
     element: T;
 }
-export interface $ZodArrayInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<core.output<T>[], core.input<T>[]> {
+export interface $ZodArrayInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>[], core.input<T>[]> {
     def: $ZodArrayDef<T>;
     isst: errors.$ZodIssueInvalidType;
 }
-export interface $ZodArray<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodArray<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodArrayInternals<T>;
 }
 export declare const $ZodArray: core.$constructor<$ZodArray>;
@@ -518,13 +523,13 @@ export interface $ZodObjectDef<Shape extends $ZodShape = $ZodShape> extends $Zod
 }
 export interface $ZodObjectInternals<
 /** @ts-ignore Cast variance */
-out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodTypeInternals<$InferObjectOutputFallback<Shape, Config["out"]>, $InferObjectInputFallback<Shape, Config["in"]>> {
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
     def: $ZodObjectDef<Shape>;
     config: Config;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
     propValues: util.PropValues;
-    "~output": $InferObjectOutput<Shape, Config["out"]>;
-    "~input": $InferObjectInput<Shape, Config["in"]>;
+    output: $InferObjectOutput<Shape, Config["out"]>;
+    input: $InferObjectInput<Shape, Config["in"]>;
 }
 export type $ZodLooseShape = Record<string, any>;
 type OptionalOutSchema = {
@@ -569,7 +574,7 @@ export type $strip = {
     out: {};
     in: {};
 };
-export type $catchall<T extends $ZodType> = {
+export type $catchall<T extends _$ZodType> = {
     out: {
         [k: string]: core.output<T>;
     };
@@ -579,123 +584,123 @@ export type $catchall<T extends $ZodType> = {
 };
 export interface $ZodObject<
 /** @ts-ignore Cast variance */
-out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType {
-    _zod: $ZodObjectInternals<Shape, Params>;
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Params extends $ZodObjectConfig = $ZodObjectConfig> extends $ZodType<any, any, $ZodObjectInternals<Shape, Params>> {
+    "~standard": $ZodStandardSchema<this>;
 }
 export declare const $ZodObject: core.$constructor<$ZodObject>;
-export type $InferUnionOutput<T extends $ZodType> = T extends any ? core.output<T> : never;
-export type $InferUnionInput<T extends $ZodType> = T extends any ? core.input<T> : never;
-export interface $ZodUnionDef<Options extends readonly $ZodType[] = readonly $ZodType[]> extends $ZodTypeDef {
+export type $InferUnionOutput<T extends SomeType> = T extends any ? core.output<T> : never;
+export type $InferUnionInput<T extends SomeType> = T extends any ? core.input<T> : never;
+export interface $ZodUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeDef {
     type: "union";
     options: Options;
 }
-export interface $ZodUnionInternals<T extends readonly $ZodType[] = readonly $ZodType[]> extends $ZodTypeInternals<$InferUnionOutput<T[number]>, $InferUnionInput<T[number]>> {
+export interface $ZodUnionInternals<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodTypeInternals<$InferUnionOutput<T[number]>, $InferUnionInput<T[number]>> {
     def: $ZodUnionDef<T>;
     isst: errors.$ZodIssueInvalidUnion;
     pattern: T[number]["_zod"]["pattern"];
 }
-export interface $ZodUnion<T extends readonly $ZodType[] = readonly $ZodType[]> extends $ZodType {
+export interface $ZodUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
     _zod: $ZodUnionInternals<T>;
 }
 export declare const $ZodUnion: core.$constructor<$ZodUnion>;
-export interface $ZodDiscriminatedUnionDef<Options extends readonly $ZodType[] = readonly $ZodType[]> extends $ZodUnionDef<Options> {
+export interface $ZodDiscriminatedUnionDef<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionDef<Options> {
     discriminator: string;
     unionFallback?: boolean;
 }
-export interface $ZodDiscriminatedUnionInternals<Options extends readonly $ZodType[] = readonly $ZodType[]> extends $ZodUnionInternals<Options> {
+export interface $ZodDiscriminatedUnionInternals<Options extends readonly SomeType[] = readonly $ZodType[]> extends $ZodUnionInternals<Options> {
     def: $ZodDiscriminatedUnionDef<Options>;
     propValues: util.PropValues;
 }
-export interface $ZodDiscriminatedUnion<T extends readonly $ZodType[] = readonly $ZodType[]> extends $ZodType {
+export interface $ZodDiscriminatedUnion<T extends readonly SomeType[] = readonly $ZodType[]> extends $ZodType {
     _zod: $ZodDiscriminatedUnionInternals<T>;
 }
 export declare const $ZodDiscriminatedUnion: core.$constructor<$ZodDiscriminatedUnion>;
-export interface $ZodIntersectionDef extends $ZodTypeDef {
+export interface $ZodIntersectionDef<Left extends SomeType = $ZodType, Right extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "intersection";
-    left: $ZodType;
-    right: $ZodType;
+    left: Left;
+    right: Right;
 }
-export interface $ZodIntersectionInternals<A extends $ZodType = $ZodType, B extends $ZodType = $ZodType> extends $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>> {
-    def: $ZodIntersectionDef;
+export interface $ZodIntersectionInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<A> & core.output<B>, core.input<A> & core.input<B>> {
+    def: $ZodIntersectionDef<A, B>;
     isst: never;
 }
-export interface $ZodIntersection<A extends $ZodType = $ZodType, B extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodIntersection<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodIntersectionInternals<A, B>;
 }
 export declare const $ZodIntersection: core.$constructor<$ZodIntersection>;
-export interface $ZodTupleDef<T extends util.TupleItems = util.TupleItems, Rest extends $ZodType | null = $ZodType | null> extends $ZodTypeDef {
+export interface $ZodTupleDef<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeDef {
     type: "tuple";
     items: T;
     rest: Rest;
 }
-export type $InferTupleInputType<T extends util.TupleItems, Rest extends $ZodType | null> = [
+export type $InferTupleInputType<T extends util.TupleItems, Rest extends SomeType | null> = [
     ...TupleInputTypeWithOptionals<T>,
-    ...(Rest extends $ZodType ? core.input<Rest>[] : [])
+    ...(Rest extends SomeType ? core.input<Rest>[] : [])
 ];
 type TupleInputTypeNoOptionals<T extends util.TupleItems> = {
     [k in keyof T]: core.input<T[k]>;
 };
 type TupleInputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
-    ...infer Prefix extends $ZodType[],
-    infer Tail extends $ZodType
-] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, Tail["_zod"]["input"]?] : TupleInputTypeNoOptionals<T> : [];
-export type $InferTupleOutputType<T extends util.TupleItems, Rest extends $ZodType | null> = [
+    ...infer Prefix extends SomeType[],
+    infer Tail extends SomeType
+] ? Tail["_zod"]["optin"] extends "optional" ? [...TupleInputTypeWithOptionals<Prefix>, core.input<Tail>?] : TupleInputTypeNoOptionals<T> : [];
+export type $InferTupleOutputType<T extends util.TupleItems, Rest extends SomeType | null> = [
     ...TupleOutputTypeWithOptionals<T>,
-    ...(Rest extends $ZodType ? core.output<Rest>[] : [])
+    ...(Rest extends SomeType ? core.output<Rest>[] : [])
 ];
 type TupleOutputTypeNoOptionals<T extends util.TupleItems> = {
     [k in keyof T]: core.output<T[k]>;
 };
 type TupleOutputTypeWithOptionals<T extends util.TupleItems> = T extends readonly [
-    ...infer Prefix extends $ZodType[],
-    infer Tail extends $ZodType
+    ...infer Prefix extends SomeType[],
+    infer Tail extends SomeType
 ] ? Tail["_zod"]["optout"] extends "optional" ? [...TupleOutputTypeWithOptionals<Prefix>, core.output<Tail>?] : TupleOutputTypeNoOptionals<T> : [];
-export interface $ZodTupleInternals<T extends util.TupleItems = util.TupleItems, Rest extends $ZodType | null = $ZodType | null> extends $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>> {
+export interface $ZodTupleInternals<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodTypeInternals<$InferTupleOutputType<T, Rest>, $InferTupleInputType<T, Rest>> {
     def: $ZodTupleDef<T, Rest>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueTooBig<unknown[]> | errors.$ZodIssueTooSmall<unknown[]>;
 }
-export interface $ZodTuple<T extends util.TupleItems = util.TupleItems, Rest extends $ZodType | null = $ZodType | null> extends $ZodType {
+export interface $ZodTuple<T extends util.TupleItems = readonly $ZodType[], Rest extends SomeType | null = $ZodType | null> extends $ZodType {
     _zod: $ZodTupleInternals<T, Rest>;
 }
 export declare const $ZodTuple: core.$constructor<$ZodTuple>;
 export type $ZodRecordKey = $ZodType<string | number | symbol, string | number | symbol>;
-export interface $ZodRecordDef extends $ZodTypeDef {
+export interface $ZodRecordDef<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "record";
-    keyType: $ZodRecordKey;
-    valueType: $ZodType;
+    keyType: Key;
+    valueType: Value;
 }
-export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : number extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : symbol extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
-export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : number extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : symbol extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : Partial<Record<core.input<Key>, core.input<Value>>> : Record<core.input<Key>, core.input<Value>>;
-export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
-    def: $ZodRecordDef;
+export type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : number extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : symbol extends core.output<Key> ? Record<core.output<Key>, core.output<Value>> : Partial<Record<core.output<Key>, core.output<Value>>> : Record<core.output<Key>, core.output<Value>>;
+export type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : number extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : symbol extends core.input<Key> ? Record<core.input<Key>, core.input<Value>> : Partial<Record<core.input<Key>, core.input<Value>>> : Record<core.input<Key>, core.input<Value>>;
+export interface $ZodRecordInternals<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodTypeInternals<$InferZodRecordOutput<Key, Value>, $InferZodRecordInput<Key, Value>> {
+    def: $ZodRecordDef<Key, Value>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey<Record<PropertyKey, unknown>>;
 }
-export interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodRecord<Key extends $ZodRecordKey = $ZodRecordKey, Value extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodRecordInternals<Key, Value>;
 }
 export declare const $ZodRecord: core.$constructor<$ZodRecord>;
-export interface $ZodMapDef extends $ZodTypeDef {
+export interface $ZodMapDef<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "map";
-    keyType: $ZodType;
-    valueType: $ZodType;
+    keyType: Key;
+    valueType: Value;
 }
-export interface $ZodMapInternals<Key extends $ZodType = $ZodType, Value extends $ZodType = $ZodType> extends $ZodTypeInternals<Map<core.output<Key>, core.output<Value>>, Map<core.input<Key>, core.input<Value>>> {
-    def: $ZodMapDef;
+export interface $ZodMapInternals<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodTypeInternals<Map<core.output<Key>, core.output<Value>>, Map<core.input<Key>, core.input<Value>>> {
+    def: $ZodMapDef<Key, Value>;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueInvalidKey | errors.$ZodIssueInvalidElement<unknown>;
 }
-export interface $ZodMap<Key extends $ZodType = $ZodType, Value extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodMap<Key extends SomeType = $ZodType, Value extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodMapInternals<Key, Value>;
 }
 export declare const $ZodMap: core.$constructor<$ZodMap>;
-export interface $ZodSetDef extends $ZodTypeDef {
+export interface $ZodSetDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "set";
-    valueType: $ZodType;
+    valueType: T;
 }
-export interface $ZodSetInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<Set<core.output<T>>, Set<core.input<T>>> {
-    def: $ZodSetDef;
+export interface $ZodSetInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<Set<core.output<T>>, Set<core.input<T>>> {
+    def: $ZodSetDef<T>;
     isst: errors.$ZodIssueInvalidType;
 }
-export interface $ZodSet<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodSet<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodSetInternals<T>;
 }
 export declare const $ZodSet: core.$constructor<$ZodSet>;
@@ -765,11 +770,11 @@ export interface $ZodTransform<O = unknown, I = unknown> extends $ZodType {
     _zod: $ZodTransformInternals<O, I>;
 }
 export declare const $ZodTransform: core.$constructor<$ZodTransform>;
-export interface $ZodOptionalDef<T extends $ZodType = $ZodType> extends $ZodTypeDef {
+export interface $ZodOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "optional";
     innerType: T;
 }
-export interface $ZodOptionalInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<core.output<T> | undefined, core.input<T> | undefined> {
+export interface $ZodOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T> | undefined, core.input<T> | undefined> {
     def: $ZodOptionalDef<T>;
     optin: "optional";
     optout: "optional";
@@ -777,15 +782,15 @@ export interface $ZodOptionalInternals<T extends $ZodType = $ZodType> extends $Z
     values: T["_zod"]["values"];
     pattern: T["_zod"]["pattern"];
 }
-export interface $ZodOptional<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodOptional<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodOptionalInternals<T>;
 }
 export declare const $ZodOptional: core.$constructor<$ZodOptional>;
-export interface $ZodNullableDef<T extends $ZodType = $ZodType> extends $ZodTypeDef {
+export interface $ZodNullableDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "nullable";
     innerType: T;
 }
-export interface $ZodNullableInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<core.output<T> | null, core.input<T> | null> {
+export interface $ZodNullableInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T> | null, core.input<T> | null> {
     def: $ZodNullableDef<T>;
     optin: T["_zod"]["optin"];
     optout: T["_zod"]["optout"];
@@ -793,64 +798,64 @@ export interface $ZodNullableInternals<T extends $ZodType = $ZodType> extends $Z
     values: T["_zod"]["values"];
     pattern: T["_zod"]["pattern"];
 }
-export interface $ZodNullable<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodNullable<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodNullableInternals<T>;
 }
 export declare const $ZodNullable: core.$constructor<$ZodNullable>;
-export interface $ZodDefaultDef<T extends $ZodType = $ZodType> extends $ZodTypeDef {
+export interface $ZodDefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "default";
     innerType: T;
     /** The default value. May be a getter. */
     defaultValue: util.NoUndefined<core.output<T>>;
 }
-export interface $ZodDefaultInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
+export interface $ZodDefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
     def: $ZodDefaultDef<T>;
     optin: "optional";
     isst: never;
     values: T["_zod"]["values"];
 }
-export interface $ZodDefault<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodDefault<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodDefaultInternals<T>;
 }
 export declare const $ZodDefault: core.$constructor<$ZodDefault>;
-export interface $ZodPrefaultDef<T extends $ZodType = $ZodType> extends $ZodTypeDef {
+export interface $ZodPrefaultDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "prefault";
     innerType: T;
     /** The default value. May be a getter. */
     defaultValue: core.input<T>;
 }
-export interface $ZodPrefaultInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
+export interface $ZodPrefaultInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, core.input<T> | undefined> {
     def: $ZodPrefaultDef<T>;
     optin: "optional";
     isst: never;
     values: T["_zod"]["values"];
 }
-export interface $ZodPrefault<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodPrefault<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodPrefaultInternals<T>;
 }
 export declare const $ZodPrefault: core.$constructor<$ZodPrefault>;
-export interface $ZodNonOptionalDef<T extends $ZodType = $ZodType> extends $ZodTypeDef {
+export interface $ZodNonOptionalDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "nonoptional";
     innerType: T;
 }
-export interface $ZodNonOptionalInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, util.NoUndefined<core.input<T>>> {
+export interface $ZodNonOptionalInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.NoUndefined<core.output<T>>, util.NoUndefined<core.input<T>>> {
     def: $ZodNonOptionalDef<T>;
     isst: errors.$ZodIssueInvalidType;
     values: T["_zod"]["values"];
 }
-export interface $ZodNonOptional<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodNonOptional<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodNonOptionalInternals<T>;
 }
 export declare const $ZodNonOptional: core.$constructor<$ZodNonOptional>;
-export interface $ZodSuccessDef extends $ZodTypeDef {
+export interface $ZodSuccessDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "success";
-    innerType: $ZodType;
+    innerType: T;
 }
-export interface $ZodSuccessInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<boolean, core.input<T>> {
-    def: $ZodSuccessDef;
+export interface $ZodSuccessInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<boolean, core.input<T>> {
+    def: $ZodSuccessDef<T>;
     isst: never;
 }
-export interface $ZodSuccess<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodSuccess<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodSuccessInternals<T>;
 }
 export declare const $ZodSuccess: core.$constructor<$ZodSuccess>;
@@ -862,19 +867,19 @@ export interface $ZodCatchCtx extends ParsePayload {
     /** @deprecated Use `ctx.value` */
     input: unknown;
 }
-export interface $ZodCatchDef extends $ZodTypeDef {
+export interface $ZodCatchDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "catch";
-    innerType: $ZodType;
+    innerType: T;
     catchValue: (ctx: $ZodCatchCtx) => unknown;
 }
-export interface $ZodCatchInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T> | util.Whatever> {
-    def: $ZodCatchDef;
+export interface $ZodCatchInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T> | util.Whatever> {
+    def: $ZodCatchDef<T>;
     optin: T["_zod"]["optin"];
     optout: T["_zod"]["optout"];
     isst: never;
     values: T["_zod"]["values"];
 }
-export interface $ZodCatch<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodCatch<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodCatchInternals<T>;
 }
 export declare const $ZodCatch: core.$constructor<$ZodCatch>;
@@ -889,34 +894,34 @@ export interface $ZodNaN extends $ZodType {
     _zod: $ZodNaNInternals;
 }
 export declare const $ZodNaN: core.$constructor<$ZodNaN>;
-export interface $ZodPipeDef<A extends $ZodType = $ZodType, B extends $ZodType = $ZodType> extends $ZodTypeDef {
+export interface $ZodPipeDef<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "pipe";
     in: A;
     out: B;
 }
-export interface $ZodPipeInternals<A extends $ZodType = $ZodType, B extends $ZodType = $ZodType> extends $ZodTypeInternals<core.output<B>, core.input<A>> {
+export interface $ZodPipeInternals<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<B>, core.input<A>> {
     def: $ZodPipeDef<A, B>;
     isst: never;
     values: A["_zod"]["values"];
     optin: A["_zod"]["optin"];
     optout: B["_zod"]["optout"];
 }
-export interface $ZodPipe<A extends $ZodType = $ZodType, B extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodPipe<A extends SomeType = $ZodType, B extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodPipeInternals<A, B>;
 }
 export declare const $ZodPipe: core.$constructor<$ZodPipe>;
-export interface $ZodReadonlyDef extends $ZodTypeDef {
+export interface $ZodReadonlyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "readonly";
-    innerType: $ZodType;
+    innerType: T;
 }
-export interface $ZodReadonlyInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<util.MakeReadonly<core.output<T>>, util.MakeReadonly<core.input<T>>> {
-    def: $ZodReadonlyDef;
+export interface $ZodReadonlyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<util.MakeReadonly<core.output<T>>, util.MakeReadonly<core.input<T>>> {
+    def: $ZodReadonlyDef<T>;
     optin: T["_zod"]["optin"];
     optout: T["_zod"]["optout"];
     isst: never;
     propValues: T["_zod"]["propValues"];
 }
-export interface $ZodReadonly<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodReadonly<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodReadonlyInternals<T>;
 }
 export declare const $ZodReadonly: core.$constructor<$ZodReadonly>;
@@ -941,27 +946,35 @@ interface SchemaPart extends $ZodType {
 }
 export type $ZodTemplateLiteralPart = LiteralPart | SchemaPart;
 type UndefinedToEmptyString<T> = T extends undefined ? "" : T;
-type AppendToTemplateLiteral<Template extends string, Suffix extends LiteralPart | $ZodType> = Suffix extends LiteralPart ? `${Template}${UndefinedToEmptyString<Suffix>}` : `${Template}${UndefinedToEmptyString<LiteralPart & core.output<Suffix & $ZodType>>}`;
-export type $PartsToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = [] extends Parts ? `` : Parts extends [...infer Rest extends $ZodTemplateLiteralPart[], infer Last extends $ZodTemplateLiteralPart] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never;
+type AppendToTemplateLiteral<Template extends string, Suffix extends LiteralPart | $ZodType> = Suffix extends LiteralPart ? `${Template}${UndefinedToEmptyString<Suffix>}` : Suffix extends $ZodType ? `${Template}${core.output<Suffix> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
+export type ConcatenateTupleOfStrings<T extends string[]> = T extends [
+    infer First extends string,
+    ...infer Rest extends string[]
+] ? Rest extends string[] ? First extends "" ? ConcatenateTupleOfStrings<Rest> : `${First}${ConcatenateTupleOfStrings<Rest>}` : never : "";
+export type ConvertPartsToStringTuple<Parts extends $ZodTemplateLiteralPart[]> = {
+    [K in keyof Parts]: Parts[K] extends LiteralPart ? `${UndefinedToEmptyString<Parts[K]>}` : Parts[K] extends $ZodType ? `${core.output<Parts[K]> extends infer T extends LiteralPart ? UndefinedToEmptyString<T> : never}` : never;
+};
+export type ToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = ConcatenateTupleOfStrings<ConvertPartsToStringTuple<Parts>>;
+export type $PartsToTemplateLiteral<Parts extends $ZodTemplateLiteralPart[]> = [] extends Parts ? `` : Parts extends [...infer Rest, infer Last extends $ZodTemplateLiteralPart] ? Rest extends $ZodTemplateLiteralPart[] ? AppendToTemplateLiteral<$PartsToTemplateLiteral<Rest>, Last> : never : never;
 export declare const $ZodTemplateLiteral: core.$constructor<$ZodTemplateLiteral>;
-export interface $ZodPromiseDef extends $ZodTypeDef {
+export interface $ZodPromiseDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "promise";
-    innerType: $ZodType;
+    innerType: T;
 }
-export interface $ZodPromiseInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<core.output<T>, util.MaybeAsync<core.input<T>>> {
-    def: $ZodPromiseDef;
+export interface $ZodPromiseInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, util.MaybeAsync<core.input<T>>> {
+    def: $ZodPromiseDef<T>;
     isst: never;
 }
-export interface $ZodPromise<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodPromise<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodPromiseInternals<T>;
 }
 export declare const $ZodPromise: core.$constructor<$ZodPromise>;
-export interface $ZodLazyDef extends $ZodTypeDef {
+export interface $ZodLazyDef<T extends SomeType = $ZodType> extends $ZodTypeDef {
     type: "lazy";
-    getter: () => $ZodType;
+    getter: () => T;
 }
-export interface $ZodLazyInternals<T extends $ZodType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T>> {
-    def: $ZodLazyDef;
+export interface $ZodLazyInternals<T extends SomeType = $ZodType> extends $ZodTypeInternals<core.output<T>, core.input<T>> {
+    def: $ZodLazyDef<T>;
     isst: never;
     /** Auto-cached way to retrieve the inner schema */
     innerType: T;
@@ -970,7 +983,7 @@ export interface $ZodLazyInternals<T extends $ZodType = $ZodType> extends $ZodTy
     optin: T["_zod"]["optin"];
     optout: T["_zod"]["optout"];
 }
-export interface $ZodLazy<T extends $ZodType = $ZodType> extends $ZodType {
+export interface $ZodLazy<T extends SomeType = $ZodType> extends $ZodType {
     _zod: $ZodLazyInternals<T>;
 }
 export declare const $ZodLazy: core.$constructor<$ZodLazy>;

package/dist/types/v4/core/util.d.ts

@@ -59,7 +59,7 @@ export type Extend<A extends SomeObject, B extends SomeObject> = Flatten<keyof A
 } & {
     [K in keyof B]: B[K];
 }>;
-export type TupleItems = ReadonlyArray<schemas.$ZodType>;
+export type TupleItems = ReadonlyArray<schemas.SomeType>;
 export type AnyFunc = (...args: any[]) => any;
 export type IsProp<T, K extends keyof T> = T[K] extends AnyFunc ? never : K;
 export type MaybeAsync<T> = T | Promise<T>;
@@ -71,7 +71,7 @@ export type ExtractIndexSignature<T> = {
     [K in keyof T as string extends K ? K : K extends string ? never : K]: T[K];
 };
 export type Keys<T extends object> = keyof OmitIndexSignature<T>;
-export type SchemaClass<T extends schemas.$ZodType> = {
+export type SchemaClass<T extends schemas.SomeType> = {
     new (def: T["_zod"]["def"]): T;
 };
 export type EnumValue = string | number;
@@ -105,7 +105,6 @@ export type SafeParseError<T> = {
 };
 export type PropValues = Record<string, Set<Primitive>>;
 export type PrimitiveSet = Set<Primitive>;
-export type DiscriminatorMap = Map<Primitive, schemas.$ZodType>;
 export declare function assertEqual<A, B>(val: AssertEqual<A, B>): AssertEqual<A, B>;
 export declare function assertNotEqual<A, B>(val: AssertNotEqual<A, B>): AssertNotEqual<A, B>;
 export declare function assertIs<T>(_arg: T): void;