Deprecated rules

@typescript-eslint/no-type-alias
Disallow type aliases
callback-return
global-require
handle-callback-err
id-blacklist
Replaced by id-denylist
jest/no-if
Disallow conditional logic
no-buffer-constructor
no-mixed-requires
no-new-object
no-new-require
no-path-concat
no-process-env
no-process-exit
no-restricted-modules
no-return-await
no-sync
react/jsx-sort-default-props

Active rules

RuleStatusConfiguration
react/boolean-prop-namingoff
 - 
react/button-has-typewarn
 - 
react/default-props-match-prop-typeswarn
 - 
react/destructuring-assignmentoff
 - 
react/display-nameoff
 - 
react/forbid-component-propsoff
 - 
react/forbid-dom-propsoff
 - 
react/forbid-elementsoff
 - 
react/forbid-foreign-prop-typesoff
 - 
react/forbid-prop-typesoff
 - 
react/function-component-definitionoff
 - 
react/jsx-curly-newlinewarn
 - 
react/jsx-no-script-urlerror
 - 
react/jsx-no-useless-fragmentwarn
{
	"allowExpressions": true
}
react/jsx-props-no-spreadingoff
 - 
react/no-access-state-in-setstatewarn
 - 
react/no-adjacent-inline-elementswarn
 - 
react/no-array-index-keywarn
 - 
react/no-children-properror
 - 
react/no-dangeroff
 - 
react/no-danger-with-childrenerror
 - 
react/no-deprecatedwarn
 - 
react/no-did-mount-set-statewarn
 - 
react/no-did-update-set-statewarn
 - 
react/no-direct-mutation-statewarn
 - 
react/no-find-dom-nodeerror
 - 
react/no-is-mountederror
 - 
react/no-multi-compwarn
{
	"ignoreStateless": true
}
react/no-redundant-should-component-updateoff
 - 
react/no-render-return-valueerror
 - 
react/no-set-stateoff
 - 
react/no-string-refserror
 - 
react/no-this-in-sfcerror
 - 
react/no-typoserror
 - 
react/no-unescaped-entitieserror
 - 
react/no-unknown-propertyoff
 - 
react/no-unsafeoff
 - 
react/no-unused-prop-typeswarn
 - 
react/no-unused-statewarn
 - 
react/no-will-update-set-stateerror
 - 
react/prefer-es6-classwarn
 - 
react/prefer-read-only-propsoff
 - 
react/prefer-stateless-functionwarn
{
	"ignorePureComponents": true
}
react/prop-typeswarn
{
	"ignore": [
		"children",
		"params"
	]
}
react/react-in-jsx-scopeerror
 - 
react/require-default-propsoff
 - 
react/require-optimizationoff
 - 
react/require-render-returnerror
 - 
react/self-closing-compwarn
 - 
react/sort-compwarn
{
	"order": [
		"static-variables",
		"static-methods",
		"instance-variables",
		"lifecycle",
		"everything-else",
		"render"
	],
	"groups": {
		"lifecycle": [
			"displayName",
			"propTypes",
			"contextTypes",
			"childContextTypes",
			"mixins",
			"statics",
			"defaultProps",
			"getDefaultProps",
			"state",
			"getInitialState",
			"constructor",
			"getChildContext",
			"getDerivedStateFromProps",
			"componentWillMount",
			"UNSAFE_componentWillMount",
			"componentDidMount",
			"componentWillReceiveProps",
			"UNSAFE_componentWillReceiveProps",
			"shouldComponentUpdate",
			"componentWillUpdate",
			"UNSAFE_componentWillUpdate",
			"getSnapshotBeforeUpdate",
			"componentDidUpdate",
			"componentDidCatch",
			"componentWillUnmount"
		]
	}
}
react/sort-prop-typesoff
 - 
react/state-in-constructoroff
 - 
react/style-prop-objectoff
 - 
react/void-dom-elements-no-childrenoff
 - 
react/jsx-boolean-valuewarn
"always"
react/jsx-child-element-spacingoff
 - 
react/jsx-closing-bracket-locationwarn
"tag-aligned"
react/jsx-closing-tag-locationwarn
 - 
react/jsx-curly-brace-presencewarn
{
	"props": "never",
	"children": "never"
}
react/jsx-curly-spacingwarn
"never"
react/jsx-equals-spacingwarn
"never"
react/jsx-filename-extensionerror
{
	"extensions": [
		".js",
		".jsx",
		".tsx",
		".mdx"
	]
}
react/jsx-first-prop-new-lineoff
 - 
react/jsx-fragmentswarn
"element"
react/jsx-handler-nameswarn
 - 
react/jsx-indentwarn
4
react/jsx-indent-propsoff
 - 
react/jsx-keyerror
 - 
react/jsx-max-depthwarn
{
	"max": 13
}
react/jsx-one-expression-per-lineoff
 - 
react/jsx-max-props-per-linewarn
{
	"maximum": 1,
	"when": "multiline"
}
react/jsx-no-bindwarn
{
	"ignoreRefs": true,
	"ignoreDOMComponents": false,
	"allowArrowFunctions": false,
	"allowBind": false,
	"allowFunctions": false
}
react/jsx-no-comment-textnodeserror
 - 
react/jsx-no-duplicate-propswarn
 - 
react/jsx-no-literalsoff
 - 
react/jsx-no-target-blankoff
 - 
react/jsx-no-undeferror
 - 
react/jsx-pascal-casewarn
 - 
react/jsx-props-no-multi-spaceswarn
 - 
react/jsx-sort-default-propsoff
 - 
react/jsx-sort-propsoff
 - 
react/jsx-tag-spacingwarn
{
	"closingSlash": "never",
	"beforeSelfClosing": "never",
	"afterOpening": "never",
	"beforeClosing": "never"
}
react/jsx-uses-reacterror
 - 
react/jsx-uses-varserror
 - 
react/jsx-wrap-multilineswarn
 - 
react/static-property-placementwarn
 - 
react-hooks/rules-of-hookserror
 - 
react-hooks/exhaustive-depserror
 - 
react/prefer-exact-propsoff
 - 
react/no-unstable-nested-componentserror
{
	"allowAsProps": true
}
react/no-namespaceerror
 - 
react/no-arrow-function-lifecyclewarn
 - 
react/jsx-no-leaked-rendererror
{
	"validStrategies": [
		"ternary"
	]
}
react/jsx-no-constructed-context-valueserror
 - 
react/iframe-missing-sandboxerror
 - 
@typescript-eslint/brace-style
Enforce consistent brace style for blocks
off
 - 
camelcase
Enforce camelcase naming convention
off
 - 
@typescript-eslint/comma-spacing
Enforce consistent spacing before and after commas
warn
 - 
default-param-last
Enforce default parameters to be last
off
 - 
@typescript-eslint/default-param-last
Enforce default parameters to be last
error
 - 
@typescript-eslint/explicit-function-return-type
Require explicit return types on functions and class methods
off
 - 
@typescript-eslint/explicit-member-accessibility
Require explicit accessibility modifiers on class properties and methods
off
 - 
@typescript-eslint/explicit-module-boundary-types
Require explicit return and argument types on exported functions' and classes' public class methods
off
 - 
func-call-spacingoff
 - 
@typescript-eslint/func-call-spacing
Require or disallow spacing between function identifiers and their invocations
warn
 - 
indentoff
4
@typescript-eslint/indent
Enforce consistent indentation
warn
4
@typescript-eslint/member-delimiter-style
Require a specific member delimiter style for interfaces and type literals
warn
 - 
@typescript-eslint/member-namingoff
 - 
@typescript-eslint/member-ordering
Require a consistent member declaration order
off
 - 
@typescript-eslint/naming-convention
Enforce naming conventions for everything across a codebase
off
 - 
no-array-constructor
Disallow Array constructors
off
 - 
@typescript-eslint/no-array-constructor
Disallow generic Array constructors
error
 - 
no-dupe-class-members
Disallow duplicate class members
off
 - 
@typescript-eslint/no-dupe-class-members
Disallow duplicate class members
error
 - 
@typescript-eslint/no-dynamic-delete
Disallow using the delete operator on computed key expressions
off
 - 
no-empty-function
Disallow empty functions
off
 - 
@typescript-eslint/no-empty-function
Disallow empty functions
warn
 - 
@typescript-eslint/no-explicit-any
Disallow the any type
warn
{
	"ignoreRestArgs": true
}
@typescript-eslint/no-extra-non-null-assertion
Disallow extra non-null assertions
warn
 - 
@typescript-eslint/no-extra-parens
Disallow unnecessary parentheses
off
 - 
no-extra-semioff
 - 
@typescript-eslint/no-extra-semi
Disallow unnecessary semicolons
warn
 - 
@typescript-eslint/no-extraneous-class
Disallow classes used as namespaces
off
 - 
@typescript-eslint/no-magic-numbers
Disallow magic numbers
off
 - 
@typescript-eslint/no-misused-new
Enforce valid definition of new and constructor
error
 - 
@typescript-eslint/no-non-null-asserted-optional-chain
Disallow non-null assertions after an optional chain expression
warn
 - 
@typescript-eslint/no-non-null-assertion
Disallow non-null assertions using the ! postfix operator
off
 - 
@typescript-eslint/no-parameter-propertiesoff
 - 
@typescript-eslint/no-require-imports
Disallow invocation of require()
warn
 - 
@typescript-eslint/no-this-alias
Disallow aliasing this
warn
 - 
no-unused-expressions
Disallow unused expressions
off
 - 
@typescript-eslint/no-unused-expressions
Disallow unused expressions
warn
{
	"allowTernary": true,
	"allowShortCircuit": false,
	"allowTaggedTemplates": false,
	"enforceForJSX": false
}
no-unused-vars
Disallow unused variables
off
{
	"ignoreRestSiblings": true
}
@typescript-eslint/no-unused-vars
Disallow unused variables
warn
{
	"ignoreRestSiblings": true
}
@typescript-eslint/no-use-before-define
Disallow the use of variables before they are defined
warn
{
	"functions": false,
	"classes": false,
	"enums": true,
	"variables": true,
	"typedefs": false
}
no-useless-constructor
Disallow unnecessary constructors
off
 - 
@typescript-eslint/no-useless-constructor
Disallow unnecessary constructors
warn
 - 
@typescript-eslint/no-var-requires
Disallow require statements except in import statements
off
 - 
@typescript-eslint/prefer-function-type
Enforce using function types instead of interfaces with call signatures
off
 - 
quotesoff
"single"
@typescript-eslint/quotes
Enforce the consistent use of either backticks, double, or single quotes
warn
"single"
@typescript-eslint/require-array-sort-compare
Require Array#sort calls to always provide a compareFunction
off
 - 
semioff
"always"
@typescript-eslint/semi
Require or disallow semicolons instead of ASI
warn
"always"
space-before-function-parenoff
{
	"anonymous": "always",
	"named": "never"
}
@typescript-eslint/space-before-function-paren
Enforce consistent spacing before function parenthesis
warn
{
	"anonymous": "always",
	"named": "never"
}
@typescript-eslint/strict-boolean-expressions
Disallow certain types in boolean expressions
off
 - 
@typescript-eslint/switch-exhaustiveness-check
Require switch-case statements to be exhaustive
off
 - 
no-redeclare
Disallow variable redeclaration
off
 - 
@typescript-eslint/no-redeclare
Disallow variable redeclaration
error
 - 
no-shadow
Disallow variable declarations from shadowing variables declared in the outer scope
off
{
	"ignoreOnInitialization": true,
	"builtinGlobals": false,
	"hoist": "functions"
}
@typescript-eslint/no-shadow
Disallow variable declarations from shadowing variables declared in the outer scope
warn
{
	"ignoreOnInitialization": true
}
@typescript-eslint/array-type
Require consistently using either T[] or Array<T> for arrays
warn
{
	"default": "array-simple"
}
@typescript-eslint/adjacent-overload-signatures
Require that function overload signatures be consecutive
warn
 - 
@typescript-eslint/await-thenable
Disallow awaiting a value that is not a Thenable
off
 - 
@typescript-eslint/ban-ts-comment
Disallow @ts-<directive> comments or require descriptions after directives
warn
 - 
@typescript-eslint/ban-types
Disallow certain types
warn
{
	"extendDefaults": true,
	"types": {
		"object": false
	}
}
@typescript-eslint/consistent-type-assertions
Enforce consistent usage of type assertions
warn
{
	"assertionStyle": "as"
}
@typescript-eslint/consistent-type-definitions
Enforce type definitions to consistently use either interface or type
off
 - 
@typescript-eslint/generic-type-namingoff
 - 
@typescript-eslint/interface-name-prefixoff
 - 
@typescript-eslint/no-empty-interface
Disallow the declaration of empty interfaces
off
 - 
@typescript-eslint/no-floating-promises
Require Promise-like statements to be handled appropriately
off
 - 
@typescript-eslint/no-for-in-array
Disallow iterating over an array with a for-in loop
error
 - 
@typescript-eslint/no-implied-eval
Disallow the use of eval()-like methods
error
 - 
@typescript-eslint/no-inferrable-types
Disallow explicit type declarations for variables or parameters initialized to a number, string, or boolean
warn
{
	"ignoreParameters": true,
	"ignoreProperties": true
}
@typescript-eslint/no-misused-promises
Disallow Promises in places not designed to handle them
error
{
	"checksVoidReturn": false
}
@typescript-eslint/no-namespace
Disallow TypeScript namespaces
off
 - 
no-throw-literal
Disallow throwing literals as exceptions
off
 - 
@typescript-eslint/no-throw-literal
Disallow throwing literals as exceptions
warn
 - 
@typescript-eslint/no-type-alias
Disallow type aliases
off
 - 
@typescript-eslint/no-unnecessary-boolean-literal-compare
Disallow unnecessary equality comparisons against boolean literals
off
 - 
@typescript-eslint/no-unnecessary-condition
Disallow conditionals where the type is always truthy or always falsy
off
 - 
@typescript-eslint/no-unnecessary-qualifier
Disallow unnecessary namespace qualifiers
warn
 - 
@typescript-eslint/no-unnecessary-type-arguments
Disallow type arguments that are equal to the default
warn
 - 
@typescript-eslint/no-unnecessary-type-assertion
Disallow type assertions that do not change the type of an expression
off
 - 
@typescript-eslint/no-unused-vars-experimentaloff
 - 
@typescript-eslint/prefer-as-const
Enforce the use of as const over literal type
warn
 - 
@typescript-eslint/prefer-for-of
Enforce the use of for-of loop over the standard for loop where possible
warn
 - 
@typescript-eslint/prefer-includes
Enforce includes method over indexOf method
warn
 - 
@typescript-eslint/prefer-namespace-keyword
Require using namespace keyword over module keyword to declare custom TypeScript modules
error
 - 
@typescript-eslint/prefer-nullish-coalescing
Enforce using the nullish coalescing operator instead of logical assignments or chaining
off
 - 
@typescript-eslint/prefer-optional-chain
Enforce using concise optional chain expressions instead of chained logical ands, negated logical ors, or empty objects
warn
 - 
@typescript-eslint/prefer-readonly
Require private members to be marked as readonly if they're never modified outside of the constructor
off
 - 
@typescript-eslint/prefer-regexp-exec
Enforce RegExp#exec over String#match if no global flag is provided
off
 - 
@typescript-eslint/prefer-string-starts-ends-with
Enforce using String#startsWith and String#endsWith over other equivalent methods of checking substrings
warn
 - 
@typescript-eslint/promise-function-async
Require any function or method that returns a Promise to be marked async
off
 - 
@typescript-eslint/require-await
Disallow async functions which have no await expression
error
 - 
@typescript-eslint/restrict-plus-operands
Require both operands of addition to be the same type and be bigint, number, or string
off
 - 
@typescript-eslint/restrict-template-expressions
Enforce template literal expressions to be of string type
off
 - 
no-return-awaitoff
 - 
@typescript-eslint/return-await
Enforce consistent returning of awaited values
off
 - 
@typescript-eslint/triple-slash-reference
Disallow certain triple slash directives in favor of ES6-style import declarations
error
 - 
@typescript-eslint/type-annotation-spacing
Require consistent spacing around type annotations
warn
 - 
@typescript-eslint/typedef
Require type annotations in certain places
warn
{
	"arrayDestructuring": false,
	"arrowParameter": false,
	"memberVariableDeclaration": false,
	"objectDestructuring": false,
	"parameter": true,
	"propertyDeclaration": true,
	"variableDeclaration": false
}
@typescript-eslint/unbound-method
Enforce unbound methods are called with their expected scope
off
 - 
@typescript-eslint/unified-signatures
Disallow two overloads that could be unified into one with a union or an optional/rest parameter
off
 - 
@typescript-eslint/prefer-ts-expect-error
Enforce using @ts-expect-error over @ts-ignore
warn
 - 
no-undef
Disallow the use of undeclared variables unless mentioned in /*global */ comments
off
 - 
@typescript-eslint/no-duplicate-type-constituents
Disallow duplicate constituents of union or intersection types
warn
 - 
@typescript-eslint/consistent-type-imports
Enforce consistent usage of type imports
warn
{
	"prefer": "type-imports",
	"fixStyle": "inline-type-imports",
	"disallowTypeAnnotations": false
}
jest/consistent-test-it
Enforce `test` and `it` usage conventions
error
{
	"fn": "test",
	"withinDescribe": "it"
}
jest/expect-expect
Enforce assertion to be made in a test body
off
 - 
jest/prefer-lowercase-title
Enforce lowercase test names
warn
{
	"ignore": [
		"describe"
	],
	"ignoreTopLevelDescribe": false
}
jest/no-alias-methods
Disallow alias methods
off
 - 
jest/no-commented-out-tests
Disallow commented out tests
error
 - 
jest/no-conditional-expect
Disallow calling `expect` conditionally
warn
 - 
jest/no-deprecated-functions
Disallow use of deprecated functions
off
 - 
jest/no-disabled-tests
Disallow disabled tests
warn
 - 
jest/no-done-callback
Disallow using a callback in asynchronous tests and hooks
off
 - 
jest/no-duplicate-hooks
Disallow duplicate setup and teardown hooks
error
 - 
jest/no-export
Disallow using `exports` in files containing tests
error
 - 
jest/no-focused-tests
Disallow focused tests
warn
 - 
jest/no-hooks
Disallow setup and teardown hooks
off
 - 
jest/no-identical-title
Disallow identical titles
error
 - 
jest/no-if
Disallow conditional logic
warn
 - 
jest/no-interpolation-in-snapshots
Disallow string interpolation inside snapshots
off
 - 
jest/no-jasmine-globals
Disallow Jasmine globals
error
 - 
jest/no-large-snapshots
Disallow large snapshots
off
 - 
jest/no-mocks-import
Disallow manually importing from `__mocks__`
error
 - 
jest/no-restricted-matchers
Disallow specific matchers & modifiers
warn
{
	"toBeTruthy": "Avoid `toBeTruthy`",
	"toBeFalsy": "Avoid `toBeFalsy`"
}
jest/no-standalone-expect
Disallow using `expect` outside of `it` or `test` blocks
error
 - 
jest/no-test-prefixes
Require using `.only` and `.skip` over `f` and `x`
warn
 - 
jest/no-test-return-statement
Disallow explicitly returning from tests
off
 - 
jest/prefer-called-with
Suggest using `toBeCalledWith()` or `toHaveBeenCalledWith()`
off
 - 
jest/prefer-expect-assertions
Suggest using `expect.assertions()` OR `expect.hasAssertions()`
off
 - 
jest/prefer-hooks-on-top
Suggest having hooks before any test cases
warn
 - 
jest/prefer-spy-on
Suggest using `jest.spyOn()`
off
 - 
jest/prefer-strict-equal
Suggest using `toStrictEqual()`
off
 - 
jest/prefer-to-be
Suggest using `toBe()` for primitive literals
warn
 - 
jest/prefer-to-contain
Suggest using `toContain()`
warn
 - 
jest/prefer-to-have-length
Suggest using `toHaveLength()`
warn
 - 
jest/prefer-todo
Suggest using `test.todo`
warn
 - 
jest/require-to-throw-message
Require a message for `toThrow()`
off
 - 
jest/require-top-level-describe
Require test cases and hooks to be inside a `describe` block
warn
 - 
jest/unbound-method
Enforce unbound methods are called with their expected scope
off
 - 
jest/valid-describe-callback
Enforce valid `describe()` callback
error
 - 
jest/valid-expect
Enforce valid `expect()` usage
error
 - 
jest/valid-expect-in-promise
Require promises that have expectations in their chain to be valid
error
 - 
jest/valid-title
Enforce valid titles
warn
 - 
init-declarations
Require or disallow initialization in variable declarations
off
 - 
no-delete-var
Disallow deleting variables
off
 - 
no-label-var
Disallow labels that share a name with a variable
off
 - 
no-restricted-globals
Disallow specified global variables
off
 - 
no-shadow-restricted-names
Disallow identifiers from shadowing restricted names
error
 - 
no-undef-init
Disallow initializing variables to undefined
off
 - 
no-undefined
Disallow the use of undefined as an identifier
off
 - 
no-use-before-define
Disallow the use of variables before they are defined
off
 - 
array-bracket-newlineoff
 - 
array-bracket-spacingwarn
 - 
array-element-newlineoff
 - 
block-spacingwarn
 - 
brace-styleoff
 - 
capitalized-comments
Enforce or disallow capitalization of the first letter of a comment
off
 - 
comma-danglewarn
{
	"arrays": "always-multiline",
	"objects": "always-multiline",
	"imports": "always-multiline",
	"exports": "always-multiline",
	"functions": "always-multiline"
}
comma-spacingwarn
 - 
comma-stylewarn
 - 
computed-property-spacingwarn
 - 
consistent-this
Enforce consistent naming when capturing the current execution context
off
 - 
eol-lastwarn
 - 
func-name-matching
Require function names to match the name of the variable or property to which they are assigned
warn
 - 
func-names
Require or disallow named function expressions
warn
 - 
func-style
Enforce the consistent use of either function declarations or expressions
off
 - 
function-call-argument-newlinewarn
"consistent"
function-paren-newlineoff
 - 
grouped-accessor-pairs
Require grouped accessor pairs in object literals and classes
warn
 - 
id-blacklist
Replaced by id-denylist
off
 - 
id-length
Enforce minimum and maximum identifier lengths
off
 - 
id-match
Require identifiers to match a specified regular expression
off
 - 
implicit-arrow-linebreakoff
 - 
jsx-quoteswarn
"prefer-double"
key-spacingwarn
 - 
keyword-spacingwarn
 - 
line-comment-position
Enforce position of line comments
off
 - 
linebreak-styleoff
 - 
lines-around-commentoff
 - 
lines-between-class-memberswarn
"always"
max-depth
Enforce a maximum depth that blocks can be nested
off
 - 
max-lenwarn
140
max-lines
Enforce a maximum number of lines per file
off
 - 
max-nested-callbacks
Enforce a maximum depth that callbacks can be nested
off
 - 
max-params
Enforce a maximum number of parameters in function definitions
off
 - 
max-statements
Enforce a maximum number of statements allowed in function blocks
off
 - 
max-statements-per-lineoff
 - 
multiline-comment-style
Enforce a particular style for multiline comments
off
 - 
multiline-ternaryoff
 - 
new-cap
Require constructor names to begin with a capital letter
off
 - 
new-parensoff
 - 
newline-per-chained-callwarn
{
	"ignoreChainWithDepth": 3
}
no-bitwise
Disallow bitwise operators
off
 - 
no-continue
Disallow continue statements
off
 - 
no-inline-comments
Disallow inline comments after code
off
 - 
no-lonely-if
Disallow if statements as the only statement in else blocks
error
 - 
no-mixed-operatorsoff
 - 
no-mixed-spaces-and-tabswarn
 - 
no-multi-assign
Disallow use of chained assignment expressions
off
 - 
no-multiple-empty-lineswarn
{
	"max": 1
}
no-negated-condition
Disallow negated conditions
warn
 - 
no-nested-ternary
Disallow nested ternary expressions
warn
 - 
no-new-objecterror
 - 
no-plusplus
Disallow the unary operators ++ and --
off
 - 
no-restricted-syntax
Disallow specified syntax
off
 - 
no-tabswarn
 - 
no-ternary
Disallow ternary operators
off
 - 
no-trailing-spaceswarn
 - 
no-underscore-dangle
Disallow dangling underscores in identifiers
off
 - 
no-unneeded-ternary
Disallow ternary operators when simpler alternatives exist
warn
 - 
no-whitespace-before-propertywarn
 - 
nonblock-statement-body-positionoff
 - 
object-curly-newlineoff
 - 
object-curly-spacingwarn
"always"
object-property-newlineoff
 - 
one-var
Enforce variables to be declared either together or separately in functions
warn
{
	"var": "always",
	"let": "never",
	"const": "never"
}
one-var-declaration-per-lineoff
 - 
operator-assignment
Require or disallow assignment operator shorthand where possible
off
 - 
operator-linebreakoff
 - 
padded-blockswarn
{
	"blocks": "never",
	"classes": "always",
	"switches": "never"
}
padding-line-between-statementsoff
 - 
prefer-exponentiation-operator
Disallow the use of Math.pow in favor of the ** operator
off
 - 
quote-propswarn
"as-needed"
semi-spacingwarn
 - 
semi-styleoff
 - 
sort-keys
Require object keys to be sorted
off
 - 
sort-vars
Require variables within the same declaration block to be sorted
off
 - 
space-before-blockswarn
 - 
space-in-parenswarn
 - 
space-infix-opsoff
 - 
space-unary-opsoff
 - 
spaced-commentoff
 - 
switch-colon-spacingoff
 - 
template-tag-spacingwarn
 - 
unicode-bom
Require or disallow Unicode byte order mark (BOM)
off
 - 
wrap-regexoff
 - 
callback-returnoff
 - 
global-requireoff
 - 
handle-callback-erroff
 - 
no-buffer-constructorerror
 - 
no-mixed-requiresoff
 - 
no-new-requireerror
 - 
no-path-concaterror
 - 
no-process-envoff
 - 
no-process-exitoff
 - 
no-restricted-modulesoff
 - 
no-syncoff
 - 
arrow-body-style
Require braces around arrow function bodies
warn
"as-needed"
arrow-parensoff
 - 
arrow-spacingwarn
 - 
constructor-super
Require super() calls in constructors
error
 - 
generator-star-spacingoff
 - 
no-class-assign
Disallow reassigning class members
error
 - 
no-confusing-arrowoff
 - 
no-const-assign
Disallow reassigning const variables
error
 - 
no-duplicate-imports
Disallow duplicate module imports
error
 - 
no-new-symbol
Disallow new operators with the Symbol object
error
 - 
no-restricted-exports
Disallow specified names in exports
off
 - 
no-restricted-imports
Disallow specified modules when loaded by import
off
 - 
no-this-before-super
Disallow this/super before calling super() in constructors
error
 - 
no-useless-computed-key
Disallow unnecessary computed property keys in objects and classes
off
 - 
no-useless-rename
Disallow renaming import, export, and destructured assignments to the same name
warn
 - 
no-var
Require let or const instead of var
off
 - 
object-shorthand
Require or disallow method and property shorthand syntax for object literals
warn
"always"
prefer-arrow-callback
Require using arrow functions for callbacks
warn
 - 
prefer-const
Require const declarations for variables that are never reassigned after declared
warn
 - 
prefer-destructuring
Require destructuring from arrays and/or objects
warn
{
	"VariableDeclarator": {
		"array": false,
		"object": true
	}
}
prefer-numeric-literals
Disallow parseInt() and Number.parseInt() in favor of binary, octal, and hexadecimal literals
off
 - 
prefer-rest-params
Require rest parameters instead of arguments
warn
 - 
prefer-spread
Require spread operators instead of .apply()
warn
 - 
prefer-template
Require template literals instead of string concatenation
warn
 - 
require-yield
Require generator functions to contain yield
off
 - 
rest-spread-spacingwarn
 - 
sort-imports
Enforce sorted import declarations within modules
off
 - 
symbol-description
Require symbol descriptions
off
 - 
template-curly-spacingwarn
 - 
yield-star-spacingoff
 - 
prefer-object-has-own
Disallow use of Object.prototype.hasOwnProperty.call() and prefer use of Object.hasOwn()
warn
 - 
for-direction
Enforce “for” loop update clause moving the counter in the right direction
error
 - 
getter-return
Enforce return statements in getters
error
{
	"allowImplicit": true
}
no-await-in-loop
Disallow await inside of loops
warn
 - 
no-compare-neg-zero
Disallow comparing against -0
error
 - 
no-cond-assign
Disallow assignment operators in conditional expressions
error
 - 
no-console
Disallow the use of console
warn
 - 
no-constant-condition
Disallow constant expressions in conditions
off
 - 
no-control-regex
Disallow control characters in regular expressions
off
 - 
no-debugger
Disallow the use of debugger
warn
 - 
no-dupe-args
Disallow duplicate arguments in function definitions
error
 - 
no-dupe-else-if
Disallow duplicate conditions in if-else-if chains
error
 - 
no-dupe-keys
Disallow duplicate keys in object literals
error
 - 
no-duplicate-case
Disallow duplicate case labels
error
 - 
no-empty
Disallow empty block statements
warn
{
	"allowEmptyCatch": true
}
no-empty-character-class
Disallow empty character classes in regular expressions
warn
 - 
no-ex-assign
Disallow reassigning exceptions in catch clauses
error
 - 
no-extra-boolean-cast
Disallow unnecessary boolean casts
warn
 - 
no-extra-parensoff
 - 
no-func-assign
Disallow reassigning function declarations
error
 - 
no-import-assign
Disallow assigning to imported bindings
error
 - 
no-inner-declarations
Disallow variable or function declarations in nested blocks
error
 - 
no-invalid-regexp
Disallow invalid regular expression strings in RegExp constructors
warn
 - 
no-irregular-whitespace
Disallow irregular whitespace
warn
{
	"skipStrings": true,
	"skipComments": false,
	"skipTemplates": false,
	"skipRegExps": false,
	"skipJSXText": false
}
no-loss-of-precision
Disallow literal numbers that lose precision
error
 - 
no-misleading-character-class
Disallow characters which are made with multiple code points in character class syntax
error
 - 
no-obj-calls
Disallow calling global object properties as functions
error
 - 
no-promise-executor-return
Disallow returning values from Promise executor functions
off
 - 
no-prototype-builtins
Disallow calling some Object.prototype methods directly on objects
off
 - 
no-regex-spaces
Disallow multiple spaces in regular expressions
off
 - 
no-setter-return
Disallow returning values from setters
error
 - 
no-sparse-arrays
Disallow sparse arrays
warn
 - 
no-template-curly-in-string
Disallow template literal placeholder syntax in regular strings
error
 - 
no-unexpected-multiline
Disallow confusing multiline expressions
warn
 - 
no-unreachable
Disallow unreachable code after return, throw, continue, and break statements
warn
 - 
no-unsafe-finally
Disallow control flow statements in finally blocks
off
 - 
no-unsafe-negation
Disallow negating the left operand of relational operators
error
 - 
no-unsafe-optional-chaining
Disallow use of optional chaining in contexts where the undefined value is not allowed
error
 - 
no-useless-backreference
Disallow useless backreferences in regular expressions
warn
 - 
require-atomic-updates
Disallow assignments that can lead to race conditions due to usage of await or yield
warn
 - 
require-unicode-regexp
Enforce the use of u or v flag on RegExp
off
 - 
use-isnan
Require calls to isNaN() when checking for NaN
error
 - 
valid-typeof
Enforce comparing typeof expressions against valid strings
error
 - 
no-unused-private-class-members
Disallow unused private class members
warn
 - 
no-constant-binary-expression
Disallow expressions where the operation doesn’t affect the value
error
 - 
accessor-pairs
Enforce getter and setter pairs in objects and classes
error
 - 
array-callback-return
Enforce return statements in callbacks of array methods
error
 - 
block-scoped-var
Enforce the use of variables within the scope they are defined
off
 - 
class-methods-use-this
Enforce that class methods utilize this
off
 - 
complexity
Enforce a maximum cyclomatic complexity allowed in a program
off
 - 
consistent-return
Require return statements to either always or never specify values
off
 - 
curly
Enforce consistent brace style for all control statements
warn
 - 
default-case
Require default cases in switch statements
off
 - 
default-case-last
Enforce default clauses in switch statements to be last
off
 - 
dot-locationwarn
"property"
dot-notation
Enforce dot notation whenever possible
off
 - 
eqeqeq
Require the use of === and !==
warn
 - 
guard-for-in
Require for-in loops to include an if statement
warn
 - 
max-classes-per-file
Enforce a maximum number of classes per file
off
 - 
max-lines-per-function
Enforce a maximum number of lines of code in a function
off
 - 
no-alert
Disallow the use of alert, confirm, and prompt
off
 - 
no-async-promise-executor
Disallow using an async function as a Promise executor
off
 - 
no-caller
Disallow the use of arguments.caller or arguments.callee
error
 - 
no-case-declarations
Disallow lexical declarations in case clauses
off
 - 
no-constructor-return
Disallow returning value from constructor
warn
 - 
no-div-regex
Disallow equal signs explicitly at the beginning of regular expressions
off
 - 
no-else-return
Disallow else blocks after return statements in if statements
off
 - 
no-empty-pattern
Disallow empty destructuring patterns
warn
 - 
no-eq-null
Disallow null comparisons without type-checking operators
off
 - 
no-eval
Disallow the use of eval()
error
 - 
no-extend-native
Disallow extending native types
error
 - 
no-extra-bind
Disallow unnecessary calls to .bind()
warn
 - 
no-extra-label
Disallow unnecessary labels
off
 - 
no-fallthrough
Disallow fallthrough of case statements
off
 - 
no-floating-decimalwarn
 - 
no-global-assign
Disallow assignments to native objects or read-only global variables
error
 - 
no-implicit-coercion
Disallow shorthand type conversions
off
 - 
no-implicit-globals
Disallow declarations in the global scope
off
 - 
no-implied-eval
Disallow the use of eval()-like methods
error
 - 
no-invalid-this
Disallow use of this in contexts where the value of this is undefined
off
 - 
no-iterator
Disallow the use of the __iterator__ property
error
 - 
no-labels
Disallow labeled statements
error
 - 
no-lone-blocks
Disallow unnecessary nested blocks
error
 - 
no-loop-func
Disallow function declarations that contain unsafe references inside loop statements
error
 - 
no-magic-numbers
Disallow magic numbers
off
 - 
no-multi-spaceswarn
 - 
no-multi-str
Disallow multiline strings
off
 - 
no-new
Disallow new operators outside of assignments or comparisons
off
 - 
no-new-func
Disallow new operators with the Function object
error
 - 
no-new-wrappers
Disallow new operators with the String, Number, and Boolean objects
error
 - 
no-nonoctal-decimal-escape
Disallow \8 and \9 escape sequences in string literals
warn
 - 
no-octal
Disallow octal literals
off
 - 
no-octal-escape
Disallow octal escape sequences in string literals
off
 - 
no-param-reassign
Disallow reassigning function parameters
warn
 - 
no-proto
Disallow the use of the __proto__ property
error
 - 
no-restricted-properties
Disallow certain properties on certain objects
off
 - 
no-return-assign
Disallow assignment operators in return statements
off
 - 
no-script-url
Disallow javascript: urls
error
 - 
no-self-assign
Disallow assignments where both sides are exactly the same
warn
 - 
no-self-compare
Disallow comparisons where both sides are exactly the same
error
 - 
no-sequences
Disallow comma operators
off
 - 
no-unmodified-loop-condition
Disallow unmodified loop conditions
off
 - 
no-unreachable-loop
Disallow loops with a body that allows only one iteration
error
 - 
no-unused-labels
Disallow unused labels
off
 - 
no-useless-call
Disallow unnecessary calls to .call() and .apply()
warn
 - 
no-useless-catch
Disallow unnecessary catch clauses
warn
 - 
no-useless-concat
Disallow unnecessary concatenation of literals or template literals
warn
 - 
no-useless-escape
Disallow unnecessary escape characters
warn
 - 
no-useless-return
Disallow redundant return statements
warn
 - 
no-void
Disallow void operators
off
 - 
no-warning-comments
Disallow specified warning terms in comments
off
 - 
no-with
Disallow with statements
error
 - 
prefer-object-spread
Disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead
off
 - 
prefer-named-capture-group
Enforce using named capture group in regular expression
off
 - 
prefer-promise-reject-errors
Require using Error objects as Promise rejection reasons
off
 - 
prefer-regex-literals
Disallow use of the RegExp constructor in favor of regular expression literals
warn
 - 
radix
Enforce the consistent use of the radix argument when using parseInt()
off
 - 
require-await
Disallow async functions which have no await expression
off
 - 
vars-on-top
Require var declarations be placed at the top of their containing scope
warn
 - 
wrap-iifewarn
 - 
yoda
Require or disallow “Yoda” conditions
warn
 - 

Unused rules

@typescript-eslint/ban-tslint-comment
Disallow // tslint:<rule-flag> comments
@typescript-eslint/block-spacing
Disallow or enforce spaces inside of blocks after opening block and before closing block
@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/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-type-exports
Enforce consistent usage of type exports
@typescript-eslint/dot-notation
Enforce dot notation whenever possible
@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/method-signature-style
Enforce using a particular method signature syntax
@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-duplicate-enum-values
Disallow duplicate enum member values
@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-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-meaningless-void-operator
Disallow the void operator except when used to discard a value
@typescript-eslint/no-mixed-enums
Disallow enums from having both number and string members
@typescript-eslint/no-non-null-asserted-nullish-coalescing
Disallow non-null assertions in the left operand of a nullish coalescing operator
@typescript-eslint/no-redundant-type-constituents
Disallow members of unions and intersections that do nothing or override type information
@typescript-eslint/no-restricted-imports
Disallow specified modules when loaded by import
@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-useless-empty-export
Disallow empty exports that don't change anything in a module file
@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/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-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-literal-enum-member
Require all enum members to be literal values
@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-return-this-type
Enforce that this is used when only this type is returned
@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-infix-ops
Require spacing around infix operators
id-denylist
Disallow specified identifiers
jest/max-expects
Enforces a maximum number assertion calls in a test body
jest/max-nested-describe
Enforces a maximum depth to nested describe calls
jest/no-conditional-in-test
Disallow conditional logic in tests
jest/no-confusing-set-timeout
Disallow confusing usages of jest.setTimeout
jest/no-restricted-jest-methods
Disallow specific `jest.` methods
jest/no-untyped-mock-factory
Disallow using `jest.mock()` factories without an explicit type parameter
jest/prefer-comparison-matcher
Suggest using the built-in comparison matchers
jest/prefer-each
Prefer using `.each` rather than manual loops
jest/prefer-equality-matcher
Suggest using the built-in equality matchers
jest/prefer-expect-resolves
Prefer `await expect(...).resolves` over `expect(await ...)` syntax
jest/prefer-hooks-in-order
Prefer having hooks in a consistent order
jest/prefer-mock-promise-shorthand
Prefer mock resolved/rejected shorthands for promises
jest/prefer-snapshot-hint
Prefer including a hint with external snapshots
jest/require-hook
Require setup and teardown code to be within a hook
logical-assignment-operators
Require or disallow logical assignment operator shorthand
no-empty-static-block
Disallow empty static blocks
no-new-native-nonconstructor
Disallow new operators with global non-constructor functions
no-object-constructor
Disallow calls to the Object constructor without an argument
react/hook-use-state
react/jsx-newline
react/no-invalid-html-attribute
react/no-object-type-as-default-prop
react/no-unused-class-component-methods
react/sort-default-props
strict
Require or disallow strict mode directives