Discriminated union discriminator is no longer generic in V4

[joemckie]

In V3, z.discriminatedUnion was typed as such, with Discriminator being generic:

export class ZodDiscriminatedUnion<
  Discriminator extends string,
  Options extends readonly ZodDiscriminatedUnionOption<Discriminator>[],
> extends ZodType<output<Options[number]>, ZodDiscriminatedUnionDef<Discriminator, Options>, input<Options[number]>>

In V4, this has been removed, and discriminator resolves to string:

export function discriminatedUnion<
  Types extends readonly [core.$ZodTypeDiscriminable, ...core.$ZodTypeDiscriminable[]],
>(
  discriminator: string,
  options: Types,
  params?: string | core.$ZodDiscriminatedUnionParams
): ZodDiscriminatedUnion<Types> {
  // const [options, params] = args;
  return new ZodDiscriminatedUnion({
    type: "union",
    options,
    discriminator,
    ...util.normalizeParams(params),
  }) as any;
}

Unless I'm mistaken, this means it's no longer possible for TypeScript to pull the value of the discriminator, and in turn, the possible options that it can have.

[dosubot]

Hi @joemckie! I'm Dosu and I’m helping the zod team.

You're correct—starting in Zod V4, the discriminator parameter for z.discriminatedUnion is typed as a plain string, not as a generic type parameter. This means TypeScript can no longer infer the literal type of the discriminator or its possible values from the API, which reduces type inference precision compared to V3. This change was intentional and made to simplify the implementation, improve performance, and enhance error reporting, as discussed by @colinhacks in several issues (#4403, #4399, #4615).

If you need to work around this, you can use explicit type assertions (like Extract) after checking the discriminator, or define all possible schemas statically before creating the discriminated union to preserve type inference (discussion). For runtime introspection of possible discriminator values, you can access the internal _zod.propValues property (example), but this isn't reflected in the TypeScript type system.

Let me know if you need concrete code examples or further details. If this answers your question, please feel free to close the issue.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}    

[joemckie]

FWIW, this seems to be working for me (at least, type-wise it throws no errors). Will conduct further testing :)

import { z, type ZodDiscriminatedUnion } from "zod";

declare module "zod" {
  function discriminatedUnion<
    D extends string,
    Types extends readonly [
      z.core.$ZodTypeDiscriminable,
      ...z.core.$ZodTypeDiscriminable[],
    ],
  >(
    discriminator: D,
    options: Types,
    params?: string | z.core.$ZodDiscriminatedUnionParams,
  ): ZodDiscriminatedUnion<Types> & {
    _zod: {
      def: {
        discriminator: D;
      };
    };
  };
}