@rspack/core 1.3.13 → 1.3.14

package/compiled/zod/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). */
@@ -49,17 +44,19 @@ export interface $ZodTypeInternals<out O = unknown, out I = unknown> {
     /** @internal Indicates that a schema output type should be considered optional inside objects.
      * @default Required
      */
+    /** @internal */
     optin?: "optional" | undefined;
+    /** @internal */
     optout?: "optional" | undefined;
-    /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
-    disc: util.DiscriminatorMap | undefined;
     /** @internal The set of literal values that will pass validation. Must be an exhaustive set. Used to determine optionality in z.record().
      *
      * Defined on: enum, const, literal, null, undefined
      * Passthrough: optional, nullable, branded, default, catch, pipe
      * Todo: unions?
      */
-    values: util.PrimitiveSet | undefined;
+    values?: util.PrimitiveSet | undefined;
+    /** @internal A set of literal discriminators used for the fast path in discriminated unions. */
+    propValues?: util.PropValues | undefined;
     /** @internal This flag indicates that a schema validation can be represented with a regular expression. Used to determine allowable schemas in z.templateLiteral(). */
     pattern: RegExp | undefined;
     /** @internal The constructor function of this schema. */
@@ -73,9 +70,20 @@ 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 interface $ZodType<O = unknown, I = unknown> {
-    _zod: $ZodTypeInternals<O, I>;
-    "~standard": StandardSchemaV1.Props<core.input<this>, core.output<this>>;
+/** @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>;
 export { clone } from "./util.js";
@@ -93,8 +101,9 @@ export interface $ZodStringInternals<Input> extends $ZodTypeInternals<string, In
     bag: util.LoosePartial<{
         minimum: number;
         maximum: number;
-        pattern: RegExp;
+        patterns: Set<RegExp>;
         format: string;
+        contentEncoding: string;
     }>;
 }
 export interface $ZodString<Input = unknown> extends $ZodType {
@@ -492,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>;
@@ -514,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<any, any> {
+out Shape extends Readonly<$ZodShape> = Readonly<$ZodShape>, out Config extends $ZodObjectConfig = $ZodObjectConfig> extends _$ZodTypeInternals {
     def: $ZodObjectDef<Shape>;
     config: Config;
     isst: errors.$ZodIssueInvalidType | errors.$ZodIssueUnrecognizedKeys;
-    disc: util.DiscriminatorMap;
-    "~output": $InferObjectOutput<Shape, Config["out"]>;
-    "~input": $InferObjectInput<Shape, Config["in"]>;
+    propValues: util.PropValues;
+    output: $InferObjectOutput<Shape, Config["out"]>;
+    input: $InferObjectInput<Shape, Config["in"]>;
 }
 export type $ZodLooseShape = Record<string, any>;
 type OptionalOutSchema = {
@@ -533,6 +542,12 @@ type OptionalInSchema = {
         optin: "optional";
     };
 };
+export type $InferObjectOutputFallback<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+    -readonly [k in keyof T]: core.output<T[k]>;
+} & Extra>;
+export type $InferObjectInputFallback<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
+    -readonly [k in keyof T]: core.input<T[k]>;
+} & Extra>;
 export type $InferObjectOutput<T extends $ZodLooseShape, Extra extends Record<string, unknown>> = string extends keyof T ? object : keyof (T & Extra) extends never ? Record<string, never> : util.Prettify<{
     -readonly [k in keyof T as T[k] extends OptionalOutSchema ? never : k]: core.output<T[k]>;
 } & {
@@ -559,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>;
     };
@@ -569,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>;
-    disc: util.DiscriminatorMap;
+    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;
 }
-type $InferZodRecordOutput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends Key["_zod"]["output"] ? Record<Key["_zod"]["output"], core.output<Value>> : number extends Key["_zod"]["output"] ? Record<Key["_zod"]["output"], core.output<Value>> : symbol extends Key["_zod"]["output"] ? Record<Key["_zod"]["output"], core.output<Value>> : Partial<Record<Key["_zod"]["output"], core.output<Value>>> : Record<Key["_zod"]["output"], core.output<Value>>;
-type $InferZodRecordInput<Key extends $ZodRecordKey = $ZodRecordKey, Value extends $ZodType = $ZodType> = undefined extends Key["_zod"]["values"] ? string extends Key["_zod"]["input"] ? Record<Key["_zod"]["input"], Value["_zod"]["input"]> : number extends Key["_zod"]["input"] ? Record<Key["_zod"]["input"], Value["_zod"]["input"]> : symbol extends Key["_zod"]["input"] ? Record<Key["_zod"]["input"], Value["_zod"]["input"]> : Partial<Record<Key["_zod"]["input"], Value["_zod"]["input"]>> : Record<Key["_zod"]["input"], Value["_zod"]["input"]>;
-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>;
@@ -733,6 +748,11 @@ export interface $ZodFileDef extends $ZodTypeDef {
 export interface $ZodFileInternals extends $ZodTypeInternals<File, File> {
     def: $ZodFileDef;
     isst: errors.$ZodIssueInvalidType;
+    bag: util.LoosePartial<{
+        minimum: number;
+        maximum: number;
+        mime: util.MimeTypes[];
+    }>;
 }
 export interface $ZodFile extends $ZodType {
     _zod: $ZodFileInternals;
@@ -750,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";
@@ -762,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"];
@@ -778,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>;
@@ -847,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>;
@@ -874,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;
-    disc: T["_zod"]["disc"];
+    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>;
@@ -926,36 +946,44 @@ 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;
     pattern: T["_zod"]["pattern"];
-    disc: T["_zod"]["disc"];
+    propValues: T["_zod"]["propValues"];
     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/compiled/zod/dist/types/v4/core/util.d.ts

@@ -5,7 +5,7 @@ import type * as schemas from "./schemas.js";
 export type JSONType = string | number | boolean | null | JSONType[] | {
     [key: string]: JSONType;
 };
-export type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512";
+export type JWTAlgorithm = "HS256" | "HS384" | "HS512" | "RS256" | "RS384" | "RS512" | "ES256" | "ES384" | "ES512" | "PS256" | "PS384" | "PS512" | "EdDSA" | (string & {});
 export type IPVersion = "v4" | "v6";
 export type MimeTypes = "application/json" | "application/xml" | "application/x-www-form-urlencoded" | "application/javascript" | "application/pdf" | "application/zip" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/octet-stream" | "application/graphql" | "text/html" | "text/plain" | "text/css" | "text/javascript" | "text/csv" | "image/png" | "image/jpeg" | "image/gif" | "image/svg+xml" | "image/webp" | "audio/mpeg" | "audio/ogg" | "audio/wav" | "audio/webm" | "video/mp4" | "video/webm" | "video/ogg" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf" | "multipart/form-data" | (string & {});
 export type ParsedTypes = "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" | "file" | "date" | "array" | "map" | "set" | "nan" | "null" | "promise";
@@ -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;
@@ -103,18 +103,14 @@ export type SafeParseError<T> = {
     data?: never;
     error: errors.$ZodError<T>;
 };
-export type DiscriminatorMapElement = {
-    values: Set<Primitive>;
-    maps: DiscriminatorMap[];
-};
-export type DiscriminatorMap = Map<PropertyKey, DiscriminatorMapElement>;
+export type PropValues = Record<string, Set<Primitive>>;
 export type PrimitiveSet = Set<Primitive>;
 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;
 export declare function assertNever(_x: never): never;
 export declare function assert<T>(_: any): asserts _ is T;
-export declare function getValidEnumValues(obj: any): any;
+export declare function getEnumValues(entries: EnumLike): EnumValue[];
 export declare function joinValues<T extends Primitive[]>(array: T, separator?: string): string;
 export declare function jsonStringifyReplacer(_: string, value: any): any;
 export declare function cached<T>(getter: () => T): {

package/compiled/zod/dist/types/v4/locales/ar.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };

package/compiled/zod/dist/types/v4/locales/az.d.ts

@@ -1,7 +1,4 @@
 import type * as errors from "../core/errors.js";
-export declare const parsedType: (data: any) => string;
-declare const error: errors.$ZodErrorMap;
-export { error };
 export default function (): {
     localeError: errors.$ZodErrorMap;
 };