Skip to main content

Overview

@typescript-eslint/eslint-plugin includes over 100 rules that detect best practice violations, bugs, and/or stylistic issues specifically for TypeScript code. All of our rules are listed below.

tip

Instead of enabling rules one by one, we recommend using one of our pre-defined configs to enable a large set of recommended rules.

Rules

The rules are listed in alphabetical order. You can optionally filter them based on these categories:

Config Group (⚙️)
Metadata

(These categories are explained in more detail below.)

Rule
⚙️
🔧
💭
🧱
💀
@typescript-eslint/adjacent-overload-signatures
Require that function overload signatures be consecutive
🎨
@typescript-eslint/array-type
Require consistently using either T[] or Array<T> for arrays
🎨🔧
@typescript-eslint/await-thenable
Disallow awaiting a value that is not a Thenable
💡💭
@typescript-eslint/ban-ts-comment
Disallow @ts-<directive> comments or require descriptions after directives
💡
@typescript-eslint/ban-tslint-comment
Disallow // tslint:<rule-flag> comments
🎨🔧
@typescript-eslint/class-literal-property-style
Enforce that literals on classes are exposed in a consistent style
🎨💡
@typescript-eslint/class-methods-use-this
Enforce that class methods utilize this
🧱
@typescript-eslint/consistent-generic-constructors
Enforce specifying generic type arguments on type annotation or constructor name of a constructor call
🎨🔧
@typescript-eslint/consistent-indexed-object-style
Require or disallow the Record type
🎨🔧
@typescript-eslint/consistent-return
Require return statements to either always or never specify values
💭🧱
@typescript-eslint/consistent-type-assertions
Enforce consistent usage of type assertions
🎨🔧
💡
@typescript-eslint/consistent-type-definitions
Enforce type definitions to consistently use either interface or type
🎨🔧
@typescript-eslint/consistent-type-exports
Enforce consistent usage of type exports
🔧💭
@typescript-eslint/consistent-type-imports
Enforce consistent usage of type imports
🔧
@typescript-eslint/default-param-last
Enforce default parameters to be last
🧱
@typescript-eslint/dot-notation
Enforce dot notation whenever possible
🎨🔧💭🧱
@typescript-eslint/explicit-function-return-type
Require explicit return types on functions and class methods
@typescript-eslint/explicit-member-accessibility
Require explicit accessibility modifiers on class properties and methods
🔧
💡
@typescript-eslint/explicit-module-boundary-types
Require explicit return and argument types on exported functions' and classes' public class methods
@typescript-eslint/init-declarations
Require or disallow initialization in variable declarations
🧱
@typescript-eslint/max-params
Enforce a maximum number of parameters in function definitions
🧱
@typescript-eslint/member-ordering
Require a consistent member declaration order
@typescript-eslint/method-signature-style
Enforce using a particular method signature syntax
🔧
@typescript-eslint/naming-convention
Enforce naming conventions for everything across a codebase
💭
@typescript-eslint/no-array-constructor
Disallow generic Array constructors
🔧🧱
@typescript-eslint/no-array-delete
Disallow using the delete operator on array values
💡💭
@typescript-eslint/no-base-to-string
Require .toString() to only be called on objects which provide useful information when stringified
💭
@typescript-eslint/no-confusing-non-null-assertion
Disallow non-null assertion in locations that may be confusing
🎨💡
@typescript-eslint/no-confusing-void-expression
Require expressions of type void to appear in statement position
🔒🔧
💡
💭
@typescript-eslint/no-dupe-class-members
Disallow duplicate class members
🧱
@typescript-eslint/no-duplicate-enum-values
Disallow duplicate enum member values
@typescript-eslint/no-duplicate-type-constituents
Disallow duplicate constituents of union or intersection types
🔧💭
@typescript-eslint/no-dynamic-delete
Disallow using the delete operator on computed key expressions
🔒🔧
@typescript-eslint/no-empty-function
Disallow empty functions
🎨🧱
@typescript-eslint/no-empty-interface
Disallow the declaration of empty interfaces
🔧
💡
💀
@typescript-eslint/no-empty-object-type
Disallow accidentally using the "empty object" type
💡
@typescript-eslint/no-explicit-any
Disallow the any type
🔧
💡
@typescript-eslint/no-extra-non-null-assertion
Disallow extra non-null assertions
🔧
@typescript-eslint/no-extraneous-class
Disallow classes used as namespaces
🔒
@typescript-eslint/no-floating-promises
Require Promise-like statements to be handled appropriately
💡💭
@typescript-eslint/no-for-in-array
Disallow iterating over an array with a for-in loop
💭
@typescript-eslint/no-implied-eval
Disallow the use of eval()-like methods
💭🧱
@typescript-eslint/no-import-type-side-effects
Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers
🔧
@typescript-eslint/no-inferrable-types
Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean
🎨🔧
@typescript-eslint/no-invalid-this
Disallow this keywords outside of classes or class-like objects
🧱
@typescript-eslint/no-invalid-void-type
Disallow void type outside of generic or return types
🔒
@typescript-eslint/no-loop-func
Disallow function declarations that contain unsafe references inside loop statements
🧱
@typescript-eslint/no-loss-of-precision
Disallow literal numbers that lose precision
🧱💀
@typescript-eslint/no-magic-numbers
Disallow magic numbers
🧱
@typescript-eslint/no-meaningless-void-operator
Disallow the void operator except when used to discard a value
🔒🔧
💡
💭
@typescript-eslint/no-misused-new
Enforce valid definition of new and constructor
@typescript-eslint/no-misused-promises
Disallow Promises in places not designed to handle them
💭
@typescript-eslint/no-mixed-enums
Disallow enums from having both number and string members
🔒💭
@typescript-eslint/no-namespace
Disallow TypeScript namespaces
@typescript-eslint/no-non-null-asserted-nullish-coalescing
Disallow non-null assertions in the left operand of a nullish coalescing operator
🔒💡
@typescript-eslint/no-non-null-asserted-optional-chain
Disallow non-null assertions after an optional chain expression
💡
@typescript-eslint/no-non-null-assertion
Disallow non-null assertions using the ! postfix operator
🔒💡
@typescript-eslint/no-redeclare
Disallow variable redeclaration
🧱
@typescript-eslint/no-redundant-type-constituents
Disallow members of unions and intersections that do nothing or override type information
💭
@typescript-eslint/no-require-imports
Disallow invocation of require()
@typescript-eslint/no-restricted-imports
Disallow specified modules when loaded by import
🧱
@typescript-eslint/no-restricted-types
Disallow certain types
🔧
💡
@typescript-eslint/no-shadow
Disallow variable declarations from shadowing variables declared in the outer scope
🧱
@typescript-eslint/no-this-alias
Disallow aliasing this
@typescript-eslint/no-type-alias
Disallow type aliases
💀
@typescript-eslint/no-unnecessary-boolean-literal-compare
Disallow unnecessary equality comparisons against boolean literals
🔒🔧💭
@typescript-eslint/no-unnecessary-condition
Disallow conditionals where the type is always truthy or always falsy
🔒🔧💭
@typescript-eslint/no-unnecessary-parameter-property-assignment
Disallow unnecessary assignment of constructor property parameter
@typescript-eslint/no-unnecessary-qualifier
Disallow unnecessary namespace qualifiers
🔧💭
@typescript-eslint/no-unnecessary-template-expression
Disallow unnecessary template expressions
🔒🔧💭
@typescript-eslint/no-unnecessary-type-arguments
Disallow type arguments that are equal to the default
🔒🔧💭
@typescript-eslint/no-unnecessary-type-assertion
Disallow type assertions that do not change the type of an expression
🔧💭
@typescript-eslint/no-unnecessary-type-constraint
Disallow unnecessary constraints on generic types
💡
@typescript-eslint/no-unnecessary-type-parameters
Disallow type parameters that only appear once
🔒💭
@typescript-eslint/no-unsafe-argument
Disallow calling a function with a value with type any
💭
@typescript-eslint/no-unsafe-assignment
Disallow assigning a value with type any to variables and properties
💭
@typescript-eslint/no-unsafe-call
Disallow calling a value with type any
💭
@typescript-eslint/no-unsafe-declaration-merging
Disallow unsafe declaration merging
@typescript-eslint/no-unsafe-enum-comparison
Disallow comparing an enum value with a non-enum value
💡💭
@typescript-eslint/no-unsafe-function-type
Disallow using the unsafe built-in Function type
🔧
@typescript-eslint/no-unsafe-member-access
Disallow member access on a value with type any
💭
@typescript-eslint/no-unsafe-return
Disallow returning a value with type any from a function
💭
@typescript-eslint/no-unsafe-unary-minus
Require unary negation to take a number
💭
@typescript-eslint/no-unused-expressions
Disallow unused expressions
🧱
@typescript-eslint/no-unused-vars
Disallow unused variables
🧱
@typescript-eslint/no-use-before-define
Disallow the use of variables before they are defined
🧱
@typescript-eslint/no-useless-constructor
Disallow unnecessary constructors
🔒🧱
@typescript-eslint/no-useless-empty-export
Disallow empty exports that don't change anything in a module file
🔧
@typescript-eslint/no-var-requires
Disallow require statements except in import statements
💀
@typescript-eslint/no-wrapper-object-types
Disallow using confusing built-in primitive class wrappers
🔧
@typescript-eslint/non-nullable-type-assertion-style
Enforce non-null assertions over explicit type casts
🎨🔧💭
@typescript-eslint/only-throw-error
Disallow throwing non-Error values as exceptions
💭🧱
@typescript-eslint/parameter-properties
Require or disallow parameter properties in class constructors
@typescript-eslint/prefer-as-const
Enforce the use of as const over literal type
🔧
💡
@typescript-eslint/prefer-destructuring
Require destructuring from arrays and/or objects
🔧💭🧱
@typescript-eslint/prefer-enum-initializers
Require each enum member value to be explicitly initialized
💡
@typescript-eslint/prefer-find
Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result
🎨💡💭
@typescript-eslint/prefer-for-of
Enforce the use of for-of loop over the standard for loop where possible
🎨
@typescript-eslint/prefer-function-type
Enforce using function types instead of interfaces with call signatures
🎨🔧
@typescript-eslint/prefer-includes
Enforce includes method over indexOf method
🎨🔧💭
@typescript-eslint/prefer-literal-enum-member
Require all enum members to be literal values
🔒
@typescript-eslint/prefer-namespace-keyword
Require using namespace keyword over module keyword to declare custom TypeScript modules
🔧
@typescript-eslint/prefer-nullish-coalescing
Enforce using the nullish coalescing operator instead of logical assignments or chaining
🎨💡💭
@typescript-eslint/prefer-optional-chain
Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects
🎨🔧
💡
💭
@typescript-eslint/prefer-promise-reject-errors
Require using Error objects as Promise rejection reasons
💭🧱
@typescript-eslint/prefer-readonly
Require private members to be marked as readonly if they're never modified outside of the constructor
🔧💭
@typescript-eslint/prefer-readonly-parameter-types
Require function parameters to be typed as readonly to prevent accidental mutation of inputs
💭
@typescript-eslint/prefer-reduce-type-parameter
Enforce using type parameter when calling Array#reduce instead of casting
🔒🔧💭
@typescript-eslint/prefer-regexp-exec
Enforce RegExp#exec over String#match if no global flag is provided
🎨🔧💭
@typescript-eslint/prefer-return-this-type
Enforce that this is used when only this type is returned
🔒🔧💭
@typescript-eslint/prefer-string-starts-ends-with
Enforce using String#startsWith and String#endsWith over other equivalent methods of checking substrings
🎨🔧💭
@typescript-eslint/prefer-ts-expect-error
Enforce using @ts-expect-error over @ts-ignore
🔧💀
@typescript-eslint/promise-function-async
Require any function or method that returns a Promise to be marked async
🔧💭
@typescript-eslint/require-array-sort-compare
Require Array#sort and Array#toSorted calls to always provide a compareFunction
💭
@typescript-eslint/require-await
Disallow async functions which do not return promises and have no await expression
💭🧱
@typescript-eslint/restrict-plus-operands
Require both operands of addition to be the same type and be bigint, number, or string
💭
@typescript-eslint/restrict-template-expressions
Enforce template literal expressions to be of string type
💭
@typescript-eslint/return-await
Enforce consistent awaiting of returned promises
🔧
💡
💭🧱
@typescript-eslint/sort-type-constituents
Enforce constituents of a type union/intersection to be sorted alphabetically
🔧
💡
💀
@typescript-eslint/strict-boolean-expressions
Disallow certain types in boolean expressions
🔧
💡
💭
@typescript-eslint/switch-exhaustiveness-check
Require switch-case statements to be exhaustive
💡💭
@typescript-eslint/triple-slash-reference
Disallow certain triple slash directives in favor of ES6-style import declarations
@typescript-eslint/typedef
Require type annotations in certain places
@typescript-eslint/unbound-method
Enforce unbound methods are called with their expected scope
💭
@typescript-eslint/unified-signatures
Disallow two overloads that could be unified into one with a union or an optional/rest parameter
🔒
@typescript-eslint/use-unknown-in-catch-callback-variable
Enforce typing arguments in .catch() callbacks as unknown
🔒🔧
💡
💭

Filtering

Config Group (⚙️)

"Config Group" refers to the pre-defined config that includes the rule. Extending from a configuration preset allow for enabling a large set of recommended rules all at once.

Metadata

  • 🔧 fixable refers to whether the rule contains an ESLint --fix auto-fixer.
  • 💡 has suggestions refers to whether the rule contains an ESLint suggestion fixer.
    • Sometimes, it is not safe to automatically fix the code with an auto-fixer. But in these cases, we often have a good guess of what the correct fix should be, and we can provide it as a suggestion to the developer.
  • 💭 requires type information refers to whether the rule requires typed linting.
  • 🧱 extension rule means that the rule is an extension of an core ESLint rule (see Extension Rules).
  • 💀 deprecated rule means that the rule should no longer be used and will be removed from the plugin in a future version.

Extension Rules

Some core ESLint rules do not support TypeScript syntax: either they crash, ignore the syntax, or falsely report against it. In these cases, we create what we call an "extension rule": a rule within our plugin that has the same functionality, but also supports TypeScript.

Extension rules generally completely replace the base rule from ESLint core. If the base rule is enabled in a config you extend from, you'll need to disable the base rule:

module.exports = {
extends: ['eslint:recommended'],
rules: {
// Note: you must disable the base rule as it can report incorrect errors
'no-unused-vars': 'off',
'@typescript-eslint/no-unused-vars': 'error',
},
};

Search for 🧱 extension rules in this page to see all extension rules.