[V4] `z.union` members with overridden recursive getters are typed as `any`

[andyburris]

This is quite an edge case, but recursive typing breaks when a getter method is

1. overriding a getter method in the object it's extending and
2. one of nodes in the recursion is a z.union that contains the schema holding the getter.

In this case, the getter will be typed as any, and thus the schema holding that getter is also any. More confusingly, only the first member of the union will be typed as any if there are multiple such cases. It's kinda confusing, so hopefully this code makes sense of it:

import { z } from "zod";

const NodeBase = z.object({
    id: z.string(),
    get children() { return z.array(Node).optional() },
});

// typed as any
const NodeOne = NodeBase.extend({
    name: z.literal("nodeOne"),
    // if this is commented out, NodeTwo becomes any
    get children() { return z.array(Node) },
});

// also typed as any
// const NodeOne = z.object({
//     ...NodeBase.shape,
//     name: z.literal("nodeOne"),
//     get children() { return z.array(Node) },
// });

// oddly, this is typed correctly
const NodeTwo = NodeBase.extend({
    name: z.literal("nodeTwo"),
    get children() { return z.array(Node) },
});

const Node = z.union([NodeOne, NodeTwo]);

I'm wondering if this is a bug in Zod or if it's an inherent Typescript limitation, and either way, is there any way to work around it?

[dosubot]

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

This is a TypeScript type inference limitation, not a Zod bug. TypeScript can't always resolve recursive types in union members—especially when using overridden getters—so it falls back to any for the recursive property. This is a well-documented issue with recursive schemas and unions in Zod 4 and earlier. You can find more details and discussion in this issue and the docs.

Workarounds include:

• Adding an explicit type annotation to the getter, e.g.

  get children(): z.ZodOptional<z.ZodArray<typeof Node>> { return z.array(Node).optional(); }

• Using z.lazy() to break the cycle, which often helps TypeScript infer the type correctly (example).

Zod 4 improved cyclical inference for plain objects, but recursive inference in unions and discriminated unions still requires these workarounds (reference). If this answers your question, feel free to close the issue! If you need more help or want to share a minimal repro, let me know.

To reply, just mention @dosu.

---

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