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/ban-types
Disallow certain types
🔧
💡
@typescript-eslint/block-spacing
Disallow or enforce spaces inside of blocks after opening block and before closing block
🔧🧱📐💀
@typescript-eslint/brace-style
Enforce consistent brace style for blocks
🔧🧱📐💀
@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/comma-dangle
Require or disallow trailing commas
🔧🧱📐💀
@typescript-eslint/comma-spacing
Enforce consistent spacing before and after commas
🔧🧱📐💀
@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/func-call-spacing
Require or disallow spacing between function identifiers and their invocations
🔧🧱📐💀
@typescript-eslint/indent
Enforce consistent indentation
🔧🧱📐💀
@typescript-eslint/init-declarations
Require or disallow initialization in variable declarations
🧱
@typescript-eslint/key-spacing
Enforce consistent spacing between property names and type annotations in types and interfaces
🔧🧱📐💀
@typescript-eslint/keyword-spacing
Enforce consistent spacing before and after keywords
🔧🧱📐💀
@typescript-eslint/lines-around-comment
Require empty lines around comments
🔧🧱📐💀
@typescript-eslint/lines-between-class-members
Require or disallow an empty line between class members
🔧🧱📐💀
@typescript-eslint/max-params
Enforce a maximum number of parameters in function definitions
🧱
@typescript-eslint/member-delimiter-style
Require a specific member delimiter style for interfaces and type literals
🔧📐💀
@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-explicit-any
Disallow the any type
🔧
💡
@typescript-eslint/no-extra-non-null-assertion
Disallow extra non-null assertions
🔧
@typescript-eslint/no-extra-parens
Disallow unnecessary parentheses
🔧🧱📐💀
@typescript-eslint/no-extra-semi
Disallow unnecessary semicolons
🔧🧱💀
@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-shadow
Disallow variable declarations from shadowing variables declared in the outer scope
🧱
@typescript-eslint/no-this-alias
Disallow aliasing this
@typescript-eslint/no-throw-literal
Disallow throwing literals as exceptions
💭🧱💀
@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-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-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-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-useless-template-literals
Disallow unnecessary template expressions
🔧💭💀
@typescript-eslint/no-var-requires
Disallow require statements except in import statements
@typescript-eslint/non-nullable-type-assertion-style
Enforce non-null assertions over explicit type casts
🎨🔧💭
@typescript-eslint/object-curly-spacing
Enforce consistent spacing inside braces
🔧🧱📐💀
@typescript-eslint/only-throw-error
Disallow throwing non-Error values as exceptions
🔒💭🧱
@typescript-eslint/padding-line-between-statements
Require or disallow padding lines between statements
🔧🧱📐💀
@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/quotes
Enforce the consistent use of either backticks, double, or single quotes
🔧🧱📐💀
@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/semi
Require or disallow semicolons instead of ASI
🔧🧱📐💀
@typescript-eslint/sort-type-constituents
Enforce constituents of a type union/intersection to be sorted alphabetically
🔧
💡
💀
@typescript-eslint/space-before-blocks
Enforce consistent spacing before blocks
🔧🧱📐💀
@typescript-eslint/space-before-function-paren
Enforce consistent spacing before function parenthesis
🔧🧱📐💀
@typescript-eslint/space-infix-ops
Require spacing around infix operators
🔧🧱📐💀
@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/type-annotation-spacing
Require consistent spacing around type annotations
🔧📐💀
@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).
  • 📐 formatting rule means that the rule has to do with formatting.
  • 💀 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.