Enforce getter and setter pairs in objects and classes

Enforce `return` statements in callbacks of array methods

Require braces around arrow function bodies

Enforce the use of variables within the scope they are defined

Require `super()` calls in constructors

Enforce consistent brace style for all control statements

Enforce `default` clauses in `switch` statements to be last

Enforce dot notation whenever possible

Require the use of `===` and `!==`

Enforce `for` loop update clause moving the counter in the right direction

Enforce `return` statements in getters

Enforce minimum and maximum identifier lengths

Require or disallow logical assignment operator shorthand

Enforce a maximum number of classes per file

Enforce a maximum depth that blocks can be nested

Enforce a maximum number of lines per file

Enforce a maximum number of lines of code in a function

Require constructor names to begin with a capital letter

Disallow the use of `alert`, `confirm`, and `prompt`

Disallow `Array` constructors

Disallow using an async function as a Promise executor

Disallow the use of `arguments.caller` or `arguments.callee`

Disallow lexical declarations in case clauses

Disallow reassigning class members

Disallow comparing against `-0`

Disallow assignment operators in conditional expressions

Disallow the use of `console`

Disallow reassigning `const`, `using`, and `await using` variables

Disallow constant expressions in conditions

Disallow control characters in regular expressions

Disallow the use of `debugger`

Disallow deleting variables

Disallow duplicate arguments in `function` definitions

Disallow duplicate class members

Disallow duplicate keys in object literals

Disallow duplicate case labels

Disallow `else` blocks after `return` statements in `if` statements

Disallow empty block statements

Disallow empty character classes in regular expressions

Disallow empty functions

Disallow empty destructuring patterns

Disallow empty static blocks

Disallow the use of `eval()`

Disallow reassigning exceptions in `catch` clauses

Disallow extending native types

Disallow unnecessary calls to `.bind()`

Disallow unnecessary boolean casts

Disallow fallthrough of `case` statements

Disallow reassigning `function` declarations

Disallow assignments to native objects or read-only global variables

Disallow the use of `eval()`-like methods

Disallow assigning to imported bindings

Disallow inline comments after code

Disallow invalid regular expression strings in `RegExp` constructors

Disallow irregular whitespace

Disallow the use of the `__iterator__` property

Disallow labeled statements

Disallow unnecessary nested blocks

Disallow `if` statements as the only statement in `else` blocks

Disallow literal numbers that lose precision

Disallow characters which are made with multiple code points in character class syntax

Disallow multiline strings

Disallow `new` operators outside of assignments or comparisons

Disallow `new` operators with the `Function` object

Disallow `new` operators with global non-constructor functions

Disallow `new` operators with the `String`, `Number`, and `Boolean` objects

Disallow calling global object properties as functions

Disallow octal literals

Disallow octal escape sequences in string literals

Disallow the use of the `__proto__` property

Disallow calling some `Object.prototype` methods directly on objects

Disallow variable redeclaration

Disallow multiple spaces in regular expressions

Disallow specified global variables

Disallow certain properties on certain objects

Disallow specified syntax

Disallow assignment operators in `return` statements

Disallow assignments where both sides are exactly the same

Disallow comparisons where both sides are exactly the same

Disallow comma operators

Disallow returning values from setters

Disallow variable declarations from shadowing variables declared in the outer scope

Disallow identifiers from shadowing restricted names

Disallow sparse arrays

Disallow template literal placeholder syntax in regular strings

Disallow `this`/`super` before calling `super()` in constructors

Disallow throwing literals as exceptions

Disallow the use of undeclared variables unless mentioned in `/*global */` comments

Disallow initializing variables to `undefined`

Disallow confusing multiline expressions

Disallow unmodified loop conditions

Disallow ternary operators when simpler alternatives exist

Disallow unreachable code after `return`, `throw`, `continue`, and `break` statements

Disallow loops with a body that allows only one iteration

Disallow control flow statements in `finally` blocks

Disallow negating the left operand of relational operators

Disallow use of optional chaining in contexts where the `undefined` value is not allowed

Disallow unused expressions

Disallow unused labels

Disallow unused private class members

Disallow unused variables

Disallow the use of variables before they are defined

Disallow useless backreferences in regular expressions

Disallow unnecessary calls to `.call()` and `.apply()`

Disallow unnecessary `catch` clauses

Disallow unnecessary computed property keys in objects and classes

Disallow unnecessary constructors

Disallow renaming import, export, and destructured assignments to the same name

Disallow redundant return statements

Require `let` or `const` instead of `var`

Disallow `with` statements

Require or disallow method and property shorthand syntax for object literals

Enforce variables to be declared either together or separately in functions

Require using arrow functions for callbacks

Require `const` declarations for variables that are never reassigned after declared

Require destructuring from arrays and/or objects

Disallow the use of `Math.pow` in favor of the `**` operator

Require using Error objects as Promise rejection reasons

Disallow use of the `RegExp` constructor in favor of regular expression literals

Require rest parameters instead of `arguments`

Require spread operators instead of `.apply()`

Require template literals instead of string concatenation

Require or disallow strict mode directives

Require symbol descriptions

Require or disallow Unicode byte order mark (BOM)

Require calls to `isNaN()` when checking for `NaN`

Enforce comparing `typeof` expressions against valid strings

Require `var` declarations be placed at the top of their containing scope

Require or disallow "Yoda" conditions

Reflows single-line comments to ensure that blocks never exceed the configured length

Require a `eslint-enable` comment for every `eslint-disable` comment

Disallow a `eslint-enable` comment for multiple `eslint-disable` comments

Disallow duplicate `eslint-disable` comments

Disallow `eslint-disable` comments without rule names

Disallow unused `eslint-enable` comments

Require include descriptions in ESLint directive-comments

Enforce linebreaks after opening and before closing array brackets

Enforce consistent spacing inside array brackets

Enforce line breaks after each array element

Require parentheses around arrow function arguments

Enforce consistent spacing before and after the arrow in arrow functions

Disallow or enforce spaces inside of blocks after opening block and before closing block

Enforce consistent brace style for blocks

Require or disallow trailing commas

Enforce consistent spacing before and after commas

Enforce consistent comma style

Enforce consistent spacing inside computed property brackets

Enforce consistent newlines before and after dots

Require or disallow newline at the end of files

Require or disallow spacing between function identifiers and their invocations

Enforce line breaks between arguments of a function call

Require or disallow spacing between function identifiers and their invocations

Enforce consistent line breaks inside function parentheses

Enforce consistent spacing around `*` operators in generator functions

Enforce the location of arrow function bodies

Enforce consistent indentation

Indentation for binary operators

Enforce or disallow spaces inside of curly braces in JSX attributes and expressions

Enforce closing bracket location in JSX

Enforce closing tag location for multiline JSX

Disallow unnecessary JSX expressions when literals alone are sufficient or enforce JSX expressions on literals in JSX children or attributes

Enforce consistent linebreaks in curly braces in JSX attributes and expressions

Enforce or disallow spaces inside of curly braces in JSX attributes and expressions

Enforce or disallow spaces around equal signs in JSX attributes

Enforce proper position of the first property in JSX

Enforce line breaks before and after JSX elements when they are used as arguments to a function.

Enforce props indentation in JSX

Enforce maximum of props on a single line in JSX

Require or prevent a new line after jsx elements and expressions.

Require one JSX element per line

Disallow multiple spaces between inline JSX props

Enforce the consistent use of either double or single quotes in JSX attributes

Disallow extra closing tags for components without children

Enforce props alphabetical sorting

Enforce whitespace in and around the JSX opening and closing brackets

Disallow missing parentheses around multiline JSX

Enforce consistent spacing between property names and type annotations in types and interfaces

Enforce consistent spacing before and after keywords

Enforce consistent linebreak style

Require empty lines around comments

Require or disallow an empty line between class members

Enforce a maximum line length

Enforce a maximum number of statements allowed per line

Require a specific member delimiter style for interfaces and type literals

Enforce a particular style for multiline comments

Enforce newlines between operands of ternary expressions

Enforce or disallow parentheses when invoking a constructor with no arguments

Require a newline after each call in a method chain

Disallow arrow functions where they could be confused with comparisons

Disallow unnecessary parentheses

Disallow unnecessary semicolons

Disallow leading or trailing decimal points in numeric literals

Disallow mixed binary operators

Disallow mixed spaces and tabs for indentation

Disallow multiple spaces

Disallow multiple empty lines

Disallow all tabs

Disallow trailing whitespace at the end of lines

Disallow whitespace before properties

Enforce the location of single-line statements

Enforce consistent line breaks after opening and before closing braces

Enforce consistent spacing inside braces

Enforce placing object properties on separate lines

Require or disallow newlines around variable declarations

Enforce consistent linebreak style for operators

Require or disallow padding within blocks

Require or disallow padding lines between statements

Require quotes around object literal, type literal, interfaces and enums property names

Enforce the consistent use of either backticks, double, or single quotes

Enforce spacing between rest and spread operators and their expressions

Require or disallow semicolons instead of ASI

Enforce consistent spacing before and after semicolons

Enforce location of semicolons

Enforce consistent spacing before blocks

Enforce consistent spacing before function parenthesis

Enforce consistent spacing inside parentheses

Require spacing around infix operators

Enforce consistent spacing before or after unary operators

Enforce consistent spacing after the `//` or `/*` in a comment

Enforce spacing around colons of switch statements

Require or disallow spacing around embedded expressions of template strings

Require or disallow spacing between template tags and their literals

Require consistent spacing around type annotations

Enforces consistent spacing inside TypeScript type generics

Expect space before the type declaration in the named tuple

Require parentheses around immediate `function` invocations

Require parenthesis around regex literals

Require or disallow spacing around the `*` in `yield*` expressions

Having line breaks styles to object, array and named imports

Newline after if

Fix duplication in imports

Prevent importing modules in `dist` folder

Prevent importing modules in `node_modules` folder by relative or absolute path

Prevent using top-level await

Enforce top-level functions to be declared with function keyword

Ensure all imports appear before other statements.

Enforce a newline after import statements.

Forbid default exports.

Forbid repeated import of the same module in multiple places.

Forbid the use of mutable exports with `var` or `let`.

Forbid named default exports.

Reports on unnecessary empty arrays and objects.

Prevents adding unnecessary / redundant files.

Package properties must be declared in standard order

Requires the `author` property to be present.

Requires the `description` property to be present.

Requires the `files` property to be present.

Requires the `keywords` property to be present.

Requires the `name` property to be present.

Requires the `type` property to be present.

Requires the `types` property to be present.

Requires the `version` property to be present.

Enforce either object or shorthand declaration for repository.

Selected collections must be in a consistent order (lexicographical for most; lifecycle-aware for scripts).

Checks a dependency isn't specified more than once (i.e. in `dependencies` and `devDependencies`)

Enforce that the `author` property is valid.

Enforce that the `bundleDependencies` (also: `bundledDependencies`) property is valid.

Enforce that the `config` property is valid.

Enforce that the `cpu` property is valid.

Enforce that the `directories` property is valid.

Enforce that the `exports` property is valid.

Enforce that the `license` property is valid.

Enforce that the `scripts` property is valid.

Enforce that the `type` property is valid.

Enforce that the `bin` property is valid.

Enforce that package names are valid npm package names

Enforce that package.json has all properties required by the npm spec

Enforce that if repository directory is specified, it matches the path to the package.json file

Enforce that package versions are valid semver specifiers

Set a max param number for your constructors, functions, methods etc.

Transforms the negation of a conjunction !(A && B) into the equivalent !A || !B according to De Morgan’s law

Transforms the negation of a disjunction !(A || B) into the equivalent !A && !B according to De Morgan’s law

Disallow unused variables

Disallow unused variables

Enforce consistent param names and ordering when creating new promises.

Disallow wrapping values in `Promise.resolve` or `Promise.reject` when not needed.

Require returning inside each `then()` to create readable and reusable Promise chains.

Enforce the use of `catch()` on un-returned promises.

Prefer `async`/`await` to the callback pattern.

Prefer `await` to `then()`/`catch()`/`finally()` for reading Promise values.

Require creating a `Promise` constructor before using it in an ES5 environment.

Disallow calling `cb()` inside of a `then()` (use [util.callbackify][] instead).

Disallow using promises inside of callbacks.

Disallow nested `then()` or `catch()` statements.

Disallow creating `new` promises outside of utility libs (use [util.promisify][] instead).

Disallow calling `new` on a Promise static method.

Disallow return statements in `finally()`.

Disallow creating new promises with paths that resolve multiple times.

Prefer class properties to assignment of literals in constructors.

Prefer early returns over full-body conditional wrapping in function declarations.

Prefer that screaming snake case variables always be defined using `const`, and always appear at module scope.

Restrict the number of returned items from React hooks.

Prevent module imports between components.

Prefer singular TypeScript enums.

Sections of code should not be commented out

"if ... else if" constructs should end with "else" clauses

Increment (++) and decrement (--) operators should not be used in a method call or mixed with other operators in an expression

Mergeable "if" statements should be combined

Boolean literals should not be used in comparisons

Return of boolean expressions should not be wrapped into an "if-then-else" statement

Track uses of "FIXME" tags

Track uses of "TODO" tags

String literals should not be duplicated

Initial values of parameters, caught exceptions, and loop variables should not be ignored

A "while" loop should be used instead of a "for" loop

Public "static" fields should be read-only

"switch" statements should not have too many "case" clauses

Local variables should not be declared and then immediately returned or thrown

Identical expressions should not be used on both sides of a binary operator

"switch" statements should not be nested

Objects should not be created to be dropped immediately without being used

Unused assignments should be removed

"if/else if" chains and "switch" cases should not have the same condition

Two branches in a conditional structure should not have exactly the same implementation

Boolean checks should not be inverted

"for" loop increment clauses should modify the loops' counters

Values should not be uselessly incremented

Return values from functions without side effects should not be ignored

Object literal syntax should be used

Boolean expressions should not be gratuitous

"catch" clauses should do more than rethrow

Non-existent operators '=+', '=-' and '=!' should not be used

Default export names and file names should match

Ternary operators should not be nested

Destructuring syntax should be used for assignments

Jump statements should not be redundant

The return value of void functions should not be used

Cognitive Complexity of functions should not be too high

"super()" should be invoked appropriately

All branches in a conditional structure should not have exactly the same implementation

Errors should not be created without being thrown

Collection contents should be used

Collection elements should not be replaced unconditionally

Functions should not have identical implementations

Empty collections should not be accessed or iterated

Type aliases should be used

Template literals should not be nested

Shorthand promises should be used

Optional property declarations should not use both '?' and 'undefined' syntax

Optional boolean parameters should have default value

Promise rejections should not be caught by "try" blocks

Constructors should not contain asynchronous operations

Require that function overload signatures be consecutive

Require consistently using either `T[]` or `Array<T>` for arrays

Disallow awaiting a value that is not a Thenable

Disallow `@ts-<directive>` comments or require descriptions after directives

Enforce specifying generic type arguments on type annotation or constructor name of a constructor call

Require or disallow the `Record` type

Enforce consistent usage of type assertions

Enforce type definitions to consistently use either `interface` or `type`

Enforce consistent usage of type imports

Enforce default parameters to be last

Enforce dot notation whenever possible

Require explicit return types on functions and class methods

Require explicit accessibility modifiers on class properties and methods

Enforce using a particular method signature syntax

Disallow generic `Array` constructors

Disallow non-null assertion in locations that may be confusing

Require expressions of type void to appear in statement position

Disallow duplicate class members

Disallow duplicate enum member values

Disallow duplicate constituents of union or intersection types

Disallow using the `delete` operator on computed key expressions

Disallow empty functions

Disallow accidentally using the "empty object" type

Disallow the `any` type

Disallow extra non-null assertions

Disallow classes used as namespaces

Require Promise-like statements to be handled appropriately

Disallow iterating over an array with a for-in loop

Disallow the use of `eval()`-like functions

Enforce the use of top-level import type qualifier when an import only has specifiers with inline type qualifiers

Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean

Disallow `void` type outside of generic or return types

Disallow the `void` operator except when used to discard a value

Enforce valid definition of `new` and `constructor`

Disallow Promises in places not designed to handle them

Disallow enums from having both number and string members

Disallow TypeScript namespaces

Disallow non-null assertions in the left operand of a nullish coalescing operator

Disallow non-null assertions after an optional chain expression

Disallow non-null assertions using the `!` postfix operator

Disallow variable redeclaration

Disallow members of unions and intersections that do nothing or override type information

Disallow invocation of `require()`

Disallow variable declarations from shadowing variables declared in the outer scope

Disallow aliasing `this`

Disallow unnecessary equality comparisons against boolean literals

Disallow conditionals where the type is always truthy or always falsy

Disallow unnecessary assignment of constructor property parameter

Disallow unnecessary namespace qualifiers

Disallow unnecessary template expressions

Disallow type arguments that are equal to the default

Disallow type assertions that do not change the type of an expression

Disallow unnecessary constraints on generic types

Disallow type parameters that aren't used multiple times

Disallow calling a function with a value with type `any`

Disallow assigning a value with type `any` to variables and properties

Disallow calling a value with type `any`

Disallow unsafe declaration merging

Disallow comparing an enum value with a non-enum value

Disallow using the unsafe built-in Function type

Disallow member access on a value with type `any`

Disallow returning a value with type `any` from a function

Require unary negation to take a number

Disallow unused expressions

Disallow unused variables

Disallow the use of variables before they are defined

Disallow unnecessary constructors

Disallow using confusing built-in primitive class wrappers

Enforce non-null assertions over explicit type assertions

Disallow throwing non-`Error` values as exceptions

Enforce the use of `as const` over literal type

Require destructuring from arrays and/or objects

Enforce the use of Array.prototype.find() over Array.prototype.filter() followed by [0] when looking for a single result

Enforce the use of `for-of` loop over the standard `for` loop where possible

Enforce using function types instead of interfaces with call signatures

Enforce `includes` method over `indexOf` method

Require all enum members to be literal values

Require using `namespace` keyword over `module` keyword to declare custom TypeScript modules

Enforce using the nullish coalescing operator instead of logical assignments or chaining

Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects

Require using Error objects as Promise rejection reasons

Require private members to be marked as `readonly` if they're never modified outside of the constructor

Enforce using type parameter when calling `Array#reduce` instead of using a type assertion

Enforce that `this` is used when only `this` type is returned

Require any function or method that returns a Promise to be marked async

Require both operands of addition to be the same type and be `bigint`, `number`, or `string`

Enforce template literal expressions to be of `string` type

Enforce consistent awaiting of returned promises

Disallow certain types in boolean expressions

Require switch-case statements to be exhaustive

Disallow certain triple slash directives in favor of ES6-style import declarations

Enforce unbound methods are called with their expected scope

Disallow two overloads that could be unified into one with a union or an optional/rest parameter

Enforce typing arguments in Promise rejection callbacks as `unknown`

Avoid using TypeScript's enums.

Avoid using TypeScript's import aliases.

Avoid using TypeScript's namespaces.

Avoid using TypeScript's class parameter properties.

Enforce a specific parameter name in catch clauses.

Use destructured variables over properties.

Move function definitions to the highest possible scope.

Enforce no spaces between braces.

Enforce passing a `message` value when creating a built-in error.

Enforce a case style for filenames.

Prefer `for…of` over the `forEach` method.

Disallow member access from await expression.

Disallow empty files.

Do not use a `for` loop that can be replaced with a `for-of` loop.

Disallow identifiers starting with `new` or `class`.

Disallow `if` statements as the only statement in `if` blocks without `else`.

Disallow negated conditions.

Disallow negated expression in equality check.

Disallow nested ternary expressions.

Disallow the use of objects as default parameters.

Disallow classes that only have static members.

Disallow unreadable array destructuring.

Disallow unused object properties.

Disallow returning/yielding `Promise.resolve/reject()` in async functions or promise callbacks

Disallow unnecessary spread.

Disallow useless `undefined`.

Enforce proper case for numeric literals.

Prefer default parameters over reassignment.

Prefer `export…from` when re-exporting.

Prefer `.includes()` over `.indexOf()`, `.lastIndexOf()`, and `Array#some()` when checking for existence or non-existence.

Prefer using a logical operator over a ternary.

Prefer `Math.min()` and `Math.max()` over ternaries for simple comparisons.

Prefer omitting the `catch` binding parameter.

Prefer `Set#has()` over `Array#includes()` when checking for existence or non-existence.

Enforce combining multiple `Array#push()`, `Element#classList.{add,remove}()`, and `importScripts()` into one call.

Prefer `switch` over multiple `else-if`.

Prefer ternary expressions over simple `if-else` statements.

Prevent abbreviations.

Enforce consistent brace style for `case` clauses.

Fix whitespace-insensitive template indentation.