How to fix Type alias 'X' circularly references itself in TypeScript

Start with the alias named in the error message and look at everything to the right of the equals sign. The offending pattern usually looks like this:

type Bar<A> = { x: A };
type Foo = Bar<Foo>; // TS2456

Here, Foo is referenced as a generic parameter, so the compiler never sees the property-level indirection and raises the circularity error.

If possible, rewrite the alias so Foo refers to itself inside an object property, which always satisfies the recursion guard:

type Foo = {
  payload: Foo;
};

// or for trees
type TreeNode = {
  value: string;
  children: TreeNode[];
};

This keeps the self-reference visible to the checker at the property level.

When you want to keep a helper alias like Bar or reuse a field definition, convert that helper into an interface or pass a concrete property that still obeys the rule:

interface Bar<A> {
  x: A;
}

type Foo = Bar<{ next: Foo }>; // Allowed because Foo only appears inside properties

Interfaces are evaluated lazily enough that TypeScript can confirm the recursion stays inside the object structure.

TypeScript's depth-first checker may see a circularity if inherited properties are ordered differently than declared ones. In the example that raised issue #61443, moving the discriminant field before recursive children made the error go away:

type FooType = { foo?: boolean };

type BaseElement<T> = FooType & {
  children: CustomElement[];
  type: T;
};

type CustomElement = BaseElement<'h1'>;

Flip type above children if necessary or split the intersection into named interfaces to give the checker a stable path.

After refactoring, run the compiler (or targeted file check) to ensure TS2456 disappears. If you still see the message, double-check for other aliases or intersections in the same file that might carry the circularity.