This rule takes one option, an object, with the following properties:

- `"builtinGlobals"`

- `"hoist"`

- `"allow"`

- `"ignoreOnInitialization"`

- `"ignoreTypeValueShadow"` (TypeScript only)

- `"ignoreFunctionTypeParameterNameValueShadow"` (TypeScript only)

The `hoist` option has five settings:

- `functions` (by default) - reports shadowing before the outer functions are defined.

- `all` - reports all shadowing before the outer variables/functions are defined.

- `never` - never report shadowing before the outer variables/functions are defined.

- `types` (TypeScript only) - reports shadowing before the outer types are defined.

- `functions-and-types` (TypeScript only) - reports shadowing before the outer functions and types are defined.

Examples of **incorrect** code for the `{ "hoist": "types" }` option:

::: incorrect

type Bar<Foo> = 1;

type Foo = 1;

:::

Examples of **incorrect** code for the `{ "hoist": "functions-and-types" }` option:

::: incorrect

type Bar<Foo> = 1;

type Foo = 1;

if (true) {

const b = 6;

}

function b() {}

:::

Whether to ignore types named the same as a variable. Default: `true`.

This is generally safe because you cannot use variables in type locations without a typeof operator, so there's little risk of confusion.

Examples of **correct** code with `{ "ignoreTypeValueShadow": true }`:

::: correct

type Foo = number;

interface Bar {

prop: number;

}

function f() {

const Foo = 1;

const Bar = 'test';

}

:::

**Note:** Shadowing specifically refers to two identical identifiers that are in different, nested scopes. This is different from redeclaration, which is when two identical identifiers are in the same scope. Redeclaration is covered by the [`no-redeclare`](/rules/no-redeclare) rule instead.

Whether to ignore function parameters named the same as a variable. Default: `true`.

Each of a function type's arguments creates a value variable within the scope of the function type. This is done so that you can reference the type later using the typeof operator:

type Func = (test: string) => typeof test;

declare const fn: Func;

const result = fn('str'); // typeof result === string

This means that function type arguments shadow value variable names in parent scopes:

let test = 1;

type TestType = typeof test; // === number

type Func = (test: string) => typeof test; // this "test" references the argument, not the variable

declare const fn: Func;

const result = fn('str'); // typeof result === string

If you do not use the `typeof` operator in a function type return type position, you can safely turn this option on.

Examples of **correct** code with `{ "ignoreFunctionTypeParameterNameValueShadow": true }`:

::: correct

const test = 1;

type Func = (test: string) => typeof test;

:::

This isn't a bug — the rule is working exactly as intended! The report is correct because of a lesser-known aspect of enums: enum members introduce a variable within the enum's own scope, allowing them to be referenced without needing a qualifier.

Here's a simple example to explain:

const A = 2;

enum Test {

A = 1,

B = A,

}

console.log(Test.B); // what should be logged?

At first glance, you might think it should log `2`, because the outer variable A's value is `2`. However, it actually logs `1`, the value of `Test.A`. This happens because inside the enum `B = A` is treated as `B = Test.A`. Due to this behavior, the enum member has shadowed the outer variable declaration.