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

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` variables

Disallow expressions where the operation doesn't affect the value

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 empty block statements

Disallow empty character classes in regular expressions

Disallow empty destructuring patterns

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 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 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 calls to the `Object` constructor without an argument

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 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 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 unused expressions

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

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

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

Disallow async functions which have no `await` expression

Require generator functions to contain `yield`

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

Disallow unused variables

Disallow unused variables

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 error handling in callbacks

Disallow deprecated APIs

Disallow the assignment to `exports`

Disallow `new` operators with calls to `require`

Disallow string concatenation with `__dirname` and `__filename`

Disallow unsupported ECMAScript built-ins on the specified version

Enforce either `Buffer` or `require("buffer").Buffer`

Enforce either `process` or `require("process")`

Require that `process.exit()` expressions use the same code path as `throw`

Checks that `@access` tags have a valid value.

Ensures that parameter names in JSDoc match those in the function declaration.

Ensures that property names in JSDoc are not duplicated on the same block and that nested properties have defined roots.

Reports invalid types.

Expects specific tags to be empty of any content.

Reports an issue with any non-constructor function using `@implements`.

This rule reports defaults being used on the relevant portion of `@param` or `@default`.

Prevents use of multiple asterisks at the beginning of lines.

Requires that all function parameters have names.

Requires that all `@typedef` and `@namespace` tags have `@property` when their type is a plain `object`, `Object`, or `PlainObject`.

Requires that each `@property` tag has a `description` value.

Requires that all function `@property` tags have names.

Requires a return statement in function body if a `@returns` tag is specified in jsdoc comment.

Requires that the `@returns` tag has a `description` value.

Requires a yield statement in function body if a `@yields` tag is specified in jsdoc comment.

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

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

Enforce or ban the use of inline type-only markers for named imports.

Forbid a module from importing itself.

Forbid named default exports.

Forbid repeated import of the same module in multiple places.

Ensure all imports appear before other statements.

Forbid webpack loader syntax in imports.

Enforce a newline after import statements.

Enforce a specific parameter name in catch clauses.

Prefer consistent types when spreading a ternary in an array literal.

Enforce consistent style for element existence checks with `indexOf()`, `lastIndexOf()`, `findIndex()`, and `findLastIndex()`.

Enforce correct `Error` subclassing.

Enforce no spaces between braces.

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

Require escape sequences to use uppercase or lowercase values.

Enforce the use of `new` for all builtins, except `String`, `Number`, `Boolean`, `Symbol` and `BigInt`.

Disallow using the `this` argument in array methods.

Disallow using `await` in `Promise` method parameters.

Do not use leading/trailing space between `console.log` parameters.

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

Enforce the use of Unicode escapes instead of hexadecimal escapes.

Disallow `instanceof` with built-in objects

Prevent calling `EventTarget#removeEventListener()` with the result of an expression.

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

Disallow negated expression in equality check.

Disallow nested ternary expressions.

Disallow `new Array()`.

Enforce the use of `Buffer.from()` and `Buffer.alloc()` instead of the deprecated `new Buffer()`.

Disallow passing single-element arrays to `Promise` methods.

Disallow classes that only have static members.

Disallow using `1` as the `depth` argument of `Array#flat()`.

Disallow using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#{splice,toSpliced}()`.

Disallow awaiting non-promise values.

Disallow using `.length` or `Infinity` as the `end` argument of `{Array,String,TypedArray}#slice()`.

Disallow number literals with zero fractions or dangling dots.

Enforce proper case for numeric literals.

Prefer `.addEventListener()` and `.removeEventListener()` over `on`-functions.

Prefer `.find(…)` and `.findLast(…)` over the first or last element from `.filter(…)`.

Prefer `.flatMap(…)` over `.map(…).flat()`.

Prefer `Array#{indexOf,lastIndexOf}()` over `Array#{findIndex,findLastIndex}()` when looking for the index of an item.

Prefer `.some(…)` over `.filter(…).length` check and `.{find,findLast,findIndex,findLastIndex}(…)`.

Prefer `.at()` method for index access and `String#charAt()`.

Prefer `Blob#arrayBuffer()` over `FileReader#readAsArrayBuffer(…)` and `Blob#text()` over `FileReader#readAsText(…)`.

Prefer `Date.now()` to get the number of milliseconds since the Unix Epoch.

Prefer `Node#append()` over `Node#appendChild()`.

Prefer using `.dataset` on DOM elements over calling attribute methods.

Prefer `childNode.remove()` over `parentNode.removeChild(childNode)`.

Prefer `.textContent` over `.innerText`.

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

Prefer `KeyboardEvent#key` over `KeyboardEvent#keyCode`.

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

Enforce the use of `Math.trunc` instead of bitwise operators.

Prefer `.before()` over `.insertBefore()`, `.replaceWith()` over `.replaceChild()`, prefer one of `.before()`, `.after()`, `.append()` or `.prepend()` over `insertAdjacentText()` and `insertAdjacentElement()`.

Prefer modern `Math` APIs over legacy patterns.

Prefer negative index over `.length - index` when possible.

Prefer using the `node:` protocol when importing Node.js builtin modules.

Prefer `Number` static properties over global ones.

Prefer omitting the `catch` binding parameter.

Prefer borrowing methods from the prototype instead of the instance.

Prefer `.querySelector()` over `.getElementById()`, `.querySelectorAll()` over `.getElementsByClassName()` and `.getElementsByTagName()` and `.getElementsByName()`.

Prefer `Reflect.apply()` over `Function#apply()`.

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

Prefer `String#replaceAll()` over regex searches with the global flag.

Prefer `String#slice()` over `String#substr()` and `String#substring()`.

Prefer `String#startsWith()` & `String#endsWith()` over `RegExp#test()`.

Prefer `String#trimStart()` / `String#trimEnd()` over `String#trimLeft()` / `String#trimRight()`.

Enforce throwing `TypeError` in type checking conditions.

Fix whitespace-insensitive template indentation.

Require `new` when creating an error.

Comment-as-command for one-off codemod with ESLint

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

Enforce sorted named imports.

Enforce sorted named exports.

Enforce sorted imports.

Enforce sorted exports.

Enforce sorted objects.

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

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

Enforce consistent usage of type imports

Require explicit return types on functions and class methods

Enforce using a particular method signature syntax

Disallow generic `Array` constructors

Disallow duplicate class members

Disallow duplicate enum member values

Disallow using the `delete` operator on computed key expressions

Disallow accidentally using the "empty object" type

Disallow the `any` type

Disallow extra non-null assertions

Disallow classes used as namespaces

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

Disallow `void` type outside of generic or return types

Enforce valid definition of `new` and `constructor`

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 invocation of `require()`

Disallow aliasing `this`

Disallow unnecessary constraints on generic types

Disallow unsafe declaration merging

Disallow using the unsafe built-in Function type

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 the use of `as const` over literal type

Require all enum members to be literal values

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

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

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

Disallow confusing quantifiers

Enforce consistent escaping of control characters

Enforce match any character style

Enforce use of escapes on negation

Disallow elements that contradict assertions

Disallow duplicate characters in the RegExp character class

Disallow duplicate disjunctions

Disallow alternatives without elements

Disallow capturing group that captures empty.

Disallow character classes that match no characters

Disallow empty group

Disallow empty lookahead assertion or empty lookbehind assertion

Disallow empty string literals in character classes

Disallow escape backspace (`[\b]`)

Disallow unnecessary nested lookaround assertions

Disallow invalid regular expression strings in `RegExp` constructors

Disallow invisible raw character

Disallow lazy quantifiers at the end of an expression

Disallow legacy RegExp features

Disallow capturing groups that do not behave as one would expect

Disallow multi-code-point characters in character classes and quantifiers

Disallow missing `g` flag in patterns used in `String#matchAll` and `String#replaceAll`

Disallow non-standard flags

Disallow obscure character ranges

Disallow optional assertions

Disallow backreferences that reference a group that might not be matched

Disallow exponential and polynomial backtracking

Disallow trivially nested assertions

Disallow nested quantifiers that can be rewritten as one quantifier

Disallow unused capturing group

Disallow assertions that are known to always accept (or reject)

Disallow useless backreferences in regular expressions

Disallow character class with one character

Disallow useless `$` replacements in replacement string

Disallow unnecessary escape characters in RegExp

Disallow unnecessary regex flags

Disallow unnecessarily non-greedy quantifiers

Disallow unnecessary non-capturing group

Disallow quantifiers that can be removed

Disallow unnecessary character ranges

Disallow unnecessary elements in expression character classes

Disallow string disjunction of single characters in `\q{...}`

Disallow unnecessary `{n,m}` quantifier

Disallow quantifiers with a maximum of zero

Disallow the alternatives of lookarounds that end with a non-constant quantifier

Require optimal quantifiers for concatenated quantifiers

Enforce using character class

Enforce using `\d`

Enforce using `+` quantifier

Prefer predefined assertion over equivalent lookarounds

Enforce using `?` quantifier

Enforce using character class range

Prefer character class set operations instead of lookarounds

Enforce using `*` quantifier

Enforce use of unicode codepoint escapes

Enforce using `\w`

Require simplify set operations

Require regex flags to be sorted

Disallow not strictly valid regular expressions

Use the `i` flag if it simplifies the pattern

Enforce lowercase titles

Disallow identical titles

Enforce using test or it but not both

Disallow importing `node:test`

Enforce having hooks in consistent order

Disallow .only blocks in tests

Enforce linebreaks after opening and before closing array brackets in `<template>`

Enforce consistent spacing inside array brackets in `<template>`

Enforce line breaks after each array element in `<template>`

Enforce consistent spacing before and after the arrow in arrow functions in `<template>`

Enforce attribute naming style on custom components in template

Enforce order of attributes

Enforce order of component top-level elements

Disallow or enforce spaces inside of blocks after opening block and before closing block in `<template>`

Enforce line breaks after opening and before closing block-level tags

Enforce consistent brace style for blocks in `<template>`

Require or disallow trailing commas in `<template>`

Enforce consistent spacing before and after commas in `<template>`

Enforce consistent comma style in `<template>`

Support comment-directives in `<template>`

Enforce specific casing for component definition name

Enforce specific casing for the component naming style in template

Enforce the casing of component name in `components` options

Enforce specific casing for custom event name

Enforce order of compiler macros (`defineProps`, `defineEmits`, etc.)

Enforce consistent newlines before and after dots in `<template>`

Require the use of `===` and `!==` in `<template>`

Enforce the location of first attribute

Require or disallow spacing between function identifiers and their invocations in `<template>`

Require or disallow a line break before tag's closing brackets

Require or disallow a space before tag's closing brackets

Enforce end tag style

Enforce consistent indentation in `<template>`

Enforce quotes style of HTML attributes

Enforce self-closing style

Prevent variables used in JSX to be marked as unused

Enforce consistent spacing between keys and values in object literal properties in `<template>`

Enforce consistent spacing before and after keywords in `<template>`

Enforce the maximum number of attributes per line

Enforce a maximum line length in `.vue` files

Require component names to be always multi-word

Require a line break before and after the contents of a multiline element

Enforce newlines between operands of ternary expressions in `<template>`

Enforce unified spacing in mustache interpolations

Disallow using arrow functions to define watcher

Disallow asynchronous actions in computed properties

Disallow element's child contents which would be overwritten by a directive like `v-html` or `v-text`

Disallow accessing computed properties in `data`

Disallow constant expressions in conditions in `<template>`

Disallow using deprecated object declaration on data (in Vue.js 3.0.0+)

Disallow using deprecated `$delete` and `$set` (in Vue.js 3.0.0+)

Disallow using deprecated `destroyed` and `beforeDestroy` lifecycle hooks (in Vue.js 3.0.0+)

Disallow using deprecated `$listeners` (in Vue.js 3.0.0+)

Disallow using deprecated `$scopedSlots` (in Vue.js 3.0.0+)

Disallow using deprecated events api (in Vue.js 3.0.0+)

Disallow using deprecated filters syntax (in Vue.js 3.0.0+)

Disallow using deprecated the `functional` template (in Vue.js 3.0.0+)

Disallow using deprecated the `is` attribute on HTML elements (in Vue.js 3.0.0+)

Disallow using deprecated `inline-template` attribute (in Vue.js 3.0.0+)

Disallow deprecated `model` definition (in Vue.js 3.0.0+)

Disallow deprecated `this` access in props default function (in Vue.js 3.0.0+)

Disallow using deprecated `tag` property on `RouterLink` (in Vue.js 3.0.0+)

Disallow deprecated `scope` attribute (in Vue.js 2.5.0+)

Disallow deprecated `slot` attribute (in Vue.js 2.6.0+)

Disallow deprecated `slot-scope` attribute (in Vue.js 2.6.0+)

Disallow use of deprecated `.sync` modifier on `v-bind` directive (in Vue.js 3.0.0+)

Disallow deprecated `v-is` directive (in Vue.js 3.1.0+)

Disallow using deprecated `.native` modifiers (in Vue.js 3.0.0+)

Disallow using deprecated number (keycode) modifiers (in Vue.js 3.0.0+)

Disallow using deprecated `Vue.config.keyCodes` (in Vue.js 3.0.0+)

Disallow duplication of field names

Disallow duplicate conditions in `v-if` / `v-else-if` chains

Enforce `inheritAttrs` to be set to `false` when using `v-bind="$attrs"`

Disallow duplication of attributes

Disallow empty destructuring patterns in `<template>`

Disallow `export` in `<script setup>`

Disallow asynchronously registered `expose`

Disallow unnecessary parentheses in `<template>`

Disallow irregular whitespace in `.vue` files

Disallow asynchronously registered lifecycle hooks

Disallow unnecessary `<template>`

Disallow literal numbers that lose precision in `<template>`

Disallow multiple spaces

Disallow passing multiple arguments to scoped slots

Disallow mutation of component props

Disallow parsing errors in `<template>`

Disallow use of value wrapped by `ref()` (Composition API) as an operand

Enforce props with default values to be optional

Disallow the use of reserved names in component definitions

Disallow overwriting reserved keys

Disallow reserved names in props

Disallow specified syntax in `<template>`

Disallow specific argument in `v-bind`

Disallow usages that lose the reactivity of `props` passed to `setup`

Enforce component's data property to be a function

Disallow side effects in computed properties

Disallow spaces around equal signs in attribute

Disallow sparse arrays in `<template>`

Disallow `key` attribute on `<template>`

Disallow variable declarations from shadowing variables declared in the outer scope

Disallow mustaches in `<textarea>`

Disallow unsupported Vue.js syntax on the specified version

Disallow registering components that are not used inside templates

Disallow unused emit declarations

Disallow unused refs

Disallow unused variable definitions of v-for directives or scope attributes

Disallow use computed property like method

Disallow using `v-else-if`/`v-else` on the same element as `v-for`

Disallow using `v-if` on the same element as `v-for`

Disallow unnecessary mustache interpolations

Disallow useless attribute on `<template>`

Disallow unnecessary `v-bind` directives

Disallow key of `<template v-for>` placed on child elements

Disallow use of v-html to prevent XSS attack

Disallow v-text / v-html on component

Disallow use of v-text

Disallow asynchronously registered `watch`

Enforce consistent line breaks after opening and before closing braces in `<template>`

Enforce consistent spacing inside braces in `<template>`

Enforce placing object properties on separate lines in `<template>`

Require or disallow method and property shorthand syntax for object literals in `<template>`

Enforce that each component should be in its own file

Enforce consistent linebreak style for operators in `<template>`

Enforce order of properties in components

Require or disallow padding lines between blocks

Enforce use of `defineOptions` instead of default export

Enforce import from 'vue' instead of import from '@vue/*'

Require static class names in template to be in a separate `class` attribute

Require template literals instead of string concatenation in `<template>`

Enforce specific casing for the Prop name in Vue components

Require quotes around object literal property names in `<template>`

Require `v-bind:is` of `<component>` elements

Require default value for props

Require `emits` option with name triggered by `$emit()`

Require a certain macro variable name

Require prop type to be a constructor

Require type definitions in props

Enforce render function to always return value

Enforce properties of `$slots` to be used as a function

Require control the display of the content inside `<transition>`

Require `v-bind:key` with `v-for` directives

Enforce props default values to be valid

Enforce that a return statement is present in computed property

Enforce that a return statement is present in emits validator

Enforce consistent indentation in `<script>`

Require a line break before and after the contents of a singleline element

Enforce consistent spacing inside parentheses in `<template>`

Require spacing around infix operators in `<template>`

Enforce consistent spacing before or after unary operators in `<template>`

Require or disallow spacing around embedded expressions of template strings in `<template>`

Disallow usage of `this` in template

Enforce usage of `exact` modifier on `v-on`

Enforce `v-bind` directive style

Enforce v-on event naming style on custom components in template

Enforce `v-on` directive style

Enforce `v-slot` directive style

Require valid attribute names

Enforce valid `defineEmits` compiler macro

Enforce valid `defineOptions` compiler macro

Enforce valid `defineProps` compiler macro

Enforce valid `nextTick` function calls

Enforce valid template root

Enforce valid `v-bind` directives

Enforce valid `v-cloak` directives

Enforce valid `v-else-if` directives

Enforce valid `v-else` directives

Enforce valid `v-for` directives

Enforce valid `v-html` directives

Enforce valid `v-if` directives

Enforce valid `v-is` directives

Enforce valid `v-memo` directives

Enforce valid `v-model` directives

Enforce valid `v-on` directives

Enforce valid `v-once` directives

Enforce valid `v-pre` directives

Enforce valid `v-show` directives

Enforce valid `v-slot` directives

Enforce valid `v-text` directives

Disallow BigInt literals

Disallow binary expression

Disallow binary numeric literals

Disallow duplicate keys in object literals

Disallow escape sequences in identifiers.

Disallow leading or trailing decimal points in numeric literals

Disallow hexadecimal numeric literals

Disallow Infinity

Disallow multiline strings

Disallow NaN

Disallow number property keys

Disallow numeric separators

Disallow octal escape sequences in string literals

Disallow octal numeric literals

Disallow legacy octal literals

Disallow parentheses around the expression

Disallow plus sign

Disallow RegExp literals

Disallow sparse arrays