---
description: 'Disallow duplicate constituents of union or intersection types.'
---

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

> 🛑 This file is source code, not the primary documentation location! 🛑
>
> See **https://typescript-eslint.io/rules/no-duplicate-type-constituents** for documentation.

TypeScript supports types ("constituents") within union and intersection types being duplicates of each other.
However, developers typically expect each constituent to be unique within its intersection or union.
Duplicate values make the code overly verbose and generally reduce readability.

This rule disallows duplicate union or intersection constituents.
We consider types to be duplicate if they evaluate to the same result in the type system.
For example, given `type A = string` and `type T = string | A`, this rule would flag that `A` is the same type as `string`.

This rule also disallows explicitly listing `undefined` in a type union when a function parameter is marked as optional.
Doing so is unnecessary.
Please note that this check only applies to parameters, not properties.
Therefore, it does not conflict with the [`exactOptionalPropertyTypes`](https://www.typescriptlang.org/tsconfig/#exactOptionalPropertyTypes) TypeScript compiler setting.

<Tabs>
<TabItem value="❌ Incorrect">

```ts
type T1 = 'A' | 'A';

type T2 = string | string | number;

type T3 = { a: string } & { a: string };

type T4 = [1, 2, 3] | [1, 2, 3];

type StringA = string;
type StringB = string;
type T5 = StringA | StringB;

const fn = (a?: string | undefined) => {};
```

</TabItem>
<TabItem value="✅ Correct">

```ts
type T1 = 'A' | 'B';

type T2 = string | number | boolean;

type T3 = { a: string } & { b: string };

type T4 = [1, 2, 3] | [1, 2, 3, 4];

type StringA = string;
type NumberB = number;
type T5 = StringA | NumberB;

const fn = (a?: string) => {};
```

</TabItem>
</Tabs>

## Options

### `ignoreIntersections`

{/* insert option description */}

When set to true, duplicate checks on intersection type constituents are ignored.

### `ignoreUnions`

{/* insert option description */}

When set to true, duplicate checks on union type constituents are ignored.

## When Not To Use It

It can sometimes be useful for the sake of documentation to include aliases for the same type.
You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) for those specific situations instead of completely disabling this rule.

> In some of those cases, [branded types](https://basarat.gitbook.io/typescript/main-1/nominaltyping#using-interfaces) might be a type-safe way to represent the underlying data types.

## Related To

- [no-redundant-type-constituents](./no-redundant-type-constituents.mdx)