All Rules

This is a full table of all rules that will be implemented in the main Flint project. It includes rules from all three provided categories of plugins: Core, Focused, and Incubator.

Implemented: 521 of 1192 (43.7%)

Flint Rule	Plugin	Preset
`accessKeys`Disallow the use of the `accessKey` / `accesskey` attribute on JSX elements.	JSX	logical
`accessKeys`	Astro	logical
`accessorPairGroups`Reports getter and setter accessors for the same property that are not adjacent.	TypeScript	stylistic
`accessorPairTypes`Reports mismatched types between getter and setter accessor pairs.	TypeScript	logical
`accessorThisRecursion`Reports recursive access to this within getters and setters.	TypeScript	logical (strict)
`afterAllPaddingLines`Enforces padding around `afterAll` blocks.	Vitest	stylistic (strict)
`afterEachPaddingLines`Enforces padding around `afterEach` blocks.	Vitest	stylistic (strict)
`alerts`Reports uses of the global alert/confirm/prompt dialog APIs.	Browser	logical
`aliasMethods`	Vitest	stylistic
`allPaddingLines`Enforces padding around Vitest blocks.	Vitest	stylistic (strict)
`altTexts`Reports elements that require alt text but are missing it.	JSX	logical
`altTexts`	Astro	logical
`amdImports`	TypeScript	(none)
`anchorAmbiguousText`Reports anchor elements with ambiguous text that doesn't describe the link destination.	JSX	logical (strict)
`anchorAmbiguousText`	Astro	logical
`anchorContent`Reports anchor elements without accessible content.	JSX	logical
`anchorContent`	Astro	logical
`anchorNatives`	Next.js	logical
`anchorValidity`Reports invalid usage of anchor elements.	JSX	logical
`anchorValidity`	Astro	logical
`anonymousDefaultExports`	TypeScript	(none)
`anyArguments`Reports calling a function with a value typed as `any` as an argument.	TypeScript	logical
`anyAssignments`Reports assigning a value with type `any` to variables and properties.	TypeScript	logical
`anyCalls`Reports calling a value with type `any`.	TypeScript	logical
`anyMemberAccess`Reports member access on a value with type `any`.	TypeScript	logical
`anyReturns`Reports returning a value with type `any` from a function.	TypeScript	logical
`arguments`Reports using the arguments object instead of rest parameters.	TypeScript	logical
`ariaActiveDescendantTabIndex`Reports elements with aria-activedescendant without tabIndex.	JSX	logical
`ariaActiveDescendantTabIndex`	Astro	logical
`ariaHiddenFocusables`Reports elements with aria-hidden='true' that are focusable.	JSX	logical (strict)
`ariaHiddenFocusables`	Astro	logical
`ariaProps`Reports invalid ARIA properties.	JSX	logical
`ariaProps`	Astro	logical
`ariaPropTypes`Reports ARIA properties with invalid value types.	JSX	logical
`ariaPropTypes`	Astro	logical
`ariaRoleValidity`Reports invalid or abstract ARIA roles.	JSX	logical
`ariaRoleValidity`	Astro	logical
`ariaUnsupportedElements`Reports ARIA attributes on elements that don't support them.	JSX	logical
`ariaUnsupportedElements`	Astro	logical
`arrayCallbackReturns`Reports missing return statements in callbacks of array methods.	TypeScript	javascript
`arrayConstructors`Reports using the `Array` constructor to create arrays instead of array literal syntax.	TypeScript	logical
`arrayDeleteUnnecessaryCounts`Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.	TypeScript	stylistic
`arrayElementDeletions`Reports using the `delete` operator on array values.	TypeScript	logical
`arrayEmptyCallbackSlots`Reports array methods with callbacks that will never be invoked on arrays with empty slots.	TypeScript	logical
`arrayExistenceChecksConsistency`Reports inconsistent styles for checking element existence using index methods.	TypeScript	stylistic
`arrayFilteredFinds`Reports using `.filter()` when only the first or last matching element is needed.	TypeScript	stylistic (strict)
`arrayFinds`Reports using `.filter()[0]` instead of `.find()` when looking for a single element.	TypeScript	stylistic
`arrayFlatMapMethods`Reports using `.map().flat()` when `.flatMap()` can be used.	TypeScript	stylistic (strict)
`arrayFlatMethods`Reports legacy techniques to flatten arrays instead of using `.flat()`.	TypeScript	stylistic (strict)
`arrayFlatUnnecessaryDepths`Reports using `1` as the depth argument of `.flat()` since it is the default.	TypeScript	stylistic
`arrayHandlers`	SolidJS	(none)
`arrayIncludes`Reports using `.indexOf()` comparisons that can be replaced with `.includes()`.	TypeScript	stylistic
`arrayIncludesMethods`Reports using `Array#some()` with simple equality checks that can be replaced with `.includes()`.	TypeScript	stylistic (strict)
`arrayIncludesOrder`	TypeScript	(none)
`arrayIndexKeyes`	React	logical
`arrayIndexOfMethods`Reports using `.findIndex()` or `.findLastIndex()` with simple equality checks that can be replaced with `.indexOf()` or `.lastIndexOf()`.	TypeScript	stylistic (strict)
`arrayInstanceOfChecks`	TypeScript	logical
`arrayLoops`Reports using `.forEach()` when a for-of loop can be used.	TypeScript	stylistic
`arrayMapIdentities`Reports using `.flatMap()` with an identity function that returns its argument unchanged.	TypeScript	logical
`arrayMutableReverses`Reports `.reverse()` calls on arrays that mutate the original array.	TypeScript	stylistic
`arrayMutableSorts`Reports `.sort()` calls on arrays that mutate the original array.	TypeScript	stylistic
`arrayPushCalls`	TypeScript	stylistic
`arrayReduceTypeArguments`Reports `Array#reduce` calls using type assertions on initial values instead of type arguments.	TypeScript	logical (strict)
`arraySliceUnnecessaryEnd`Reports unnecessary `end` argument in `.slice()` calls when it equals the length or is `Infinity`.	TypeScript	stylistic
`arraySomeMethods`Reports patterns that can be replaced with `.some()` for checking array element existence.	TypeScript	stylistic (strict)
`arraysOrder`	TypeScript	(none)
`arrayTernarySpreadingConsistency`Reports inconsistent types when spreading a ternary in an array literal.	TypeScript	stylistic
`arrayTypes`Reports array type syntax that doesn't match the configured style.	TypeScript	stylistic
`arrayUnnecessaryLengthChecks`Reports unnecessary array length checks before `.some()` or `.every()` calls.	TypeScript	logical
`asConstAssertions`Reports using explicit literal types when `as const` can be used.	TypeScript	stylistic
`assertStrict`Prefer strict assertion mode from Node.js for better error messages and behavior.	Node.js	logical
`assertStyles`Prefer `assert.ok()` over `assert()` for explicit intent and better readability.	Node.js	stylistic
`assignmentOperatorShorthands`Prefer logical assignment operator shorthand expressions.	TypeScript	stylistic
`asyncFunctionAwaits`Reports async functions that do not use await.	TypeScript	logical
`asyncPromiseExecutors`Reports using async functions as Promise executor functions.	TypeScript	logical
`asyncUnnecessaryPromiseWrappers`Reports unnecessary `Promise.resolve()` or `Promise.reject()` in async contexts.	TypeScript	logical
`atAccesses`Prefer using .at() for accessing elements at negative indices.	TypeScript	stylistic (strict)
`atDebugTags`	Svelte	logical
`atHtmlTags`	Svelte	security
`attributeInheritanceDuplicates`	Vue	logical
`attributeNameCasing`	Vue	stylistic
`attributeOrders`	Vue	stylistic (strict)
`attributesOrder`	Astro	sorting
`attributeValidity`	JSX	logical
`attribution`Enforces that package.json declares author or contributor attribution.	PackageJSON	logical
`authorPresence`Enforces that the `author` property is present.	PackageJSON	(none)
`authorValidity`Enforces that the `author` property is valid.	PackageJSON	logical
`autocomplete`Ensure the autocomplete attribute is correct and suitable for the form field.	JSX	logical
`autocomplete`	Astro	logical
`autoFocusProps`Reports autoFocus props that are not set to false.	JSX	logical
`autoFocusProps`	Astro	logical
`automaticJsoncRules`	JSON	config
`awaitThenable`	TypeScript	logical
`bareUrls`Reports bare URLs that should be formatted as autolinks or links.	Markdown	stylistic (strict)
`beforeAllPaddingLines`Enforces padding around `beforeAll` blocks.	Vitest	stylistic (strict)
`beforeEachPaddingLines`Enforces padding around `beforeEach` blocks.	Vitest	stylistic (strict)
`beforeRouteEnterThisAccesses`	Vue	logical
`bindDirectiveValidity`	Vue	logical
`bindStyles`	Vue	stylistic
`bindSyncValidity`	Vue	logical
`binNameCasing`Enforce that names for bin properties are in kebab case.	PackageJSON	stylistic
`binPresence`Enforces that the `bin` property is present.	PackageJSON	(none)
`binValidity`Enforces that the `bin` property is valid.	PackageJSON	logical
`blobReadingMethods`Prefer direct Blob reading methods over wrapping in Response for simpler code.	Node.js	stylistic
`blockLang`	Svelte	logical (strict)
`blockLanguages`	Vue	logical
`blockLineLimits`	Vue	stylistic
`blockMappings`Prefer block-style mappings over flow-style mappings.	YAML	stylistic
`blockOrders`	Vue	sorting
`blockquoteBlankLineMultiples`	Markdown	stylistic (strict)
`blockSequences`Prefer block style sequences over flow style sequences.	YAML	stylistic
`booleanDefaults`	Vue	logical
`booleanPropNames`	JSX	stylistic (strict)
`booleanPropTypePositions`	Vue	logical
`booleanValues`Prefer shorthand boolean attributes over explicit {true} values in JSX.	JSX	stylistic
`bracedStatements`Disallow unnecessary JSX curly braces around literals and JSX elements.	JSX	stylistic
`browserPresence`Enforces that the `browser` property is present.	PackageJSON	(none)
`browserValidity`Enforces that the `browser` property is valid.	PackageJSON	logical
`bufferAllocators`Prefer modern Buffer allocation methods over the deprecated Buffer constructor.	Node.js	logical
`bugsPresence`Enforces that the `bugs` property is present.	PackageJSON	(none)
`bugsValidity`Enforces that the `bugs` property is valid.	PackageJSON	(none)
`builtinCoercions`Reports functions that wrap native coercion functions like `String`, `Number`, `BigInt`, `Boolean`, or `Symbol`.	TypeScript	stylistic (strict)
`builtinConstructorNews`Enforces using new for constructors that require it, and disallows new for primitive coercion functions.	TypeScript	stylistic
`bundleDependenciesPresence`Enforces that the `bundleDependencies` property is present.	PackageJSON	(none)
`bundleDependenciesValidity`Enforces that the `bundleDependencies` (also: `bundledDependencies`) property is valid.	PackageJSON	logical
`buttonTypes`Reports button elements without an explicit type attribute.	JSX	logical
`buttonTypes`	Svelte	logical (strict)
`buttonTypes`	Vue	logical
`calledOnceAssertions`	Vitest	(none)
`calledOnceWithAssertions`	Vitest	stylistic (strict)
`calledTimesAssertions`	Vitest	stylistic (strict)
`calledWithAssertions`	Vitest	stylistic (strict)
`camelCaseNames`	Vue	stylistic
`caseDeclarations`Reports lexical declarations in case clauses without wrapping them in blocks.	TypeScript	javascript
`caseDuplicates`Reports switch statements with duplicate case clause test expressions.	TypeScript	logical
`caseFallthroughs`Reports switch case clauses that fall through unexpectedly.	TypeScript	logical
`catchCallbackTypes`Reports `Promise` catch callback parameters that are not typed as unknown.	TypeScript	logical
`caughtErrorCauses`	TypeScript	logical (strict)
`caughtVariableNames`Enforces a consistent naming convention for catch clause error variables.	TypeScript	stylistic (strict)
`chainedAssignments`Reports using chained assignment expressions (e.g., a = b = c).	TypeScript	stylistic
`characterClassElementsOrder`	TypeScript	(none)
`charAtComparisons`Reports comparing charAt() results with strings longer than one character.	TypeScript	logical
`childContentOverrides`	Vue	logical
`childrenProps`Reports usage of the children prop.	JSX	stylistic
`childrenWhitespace`	JSX	logical (strict)
`classAssignments`Reports reassigning class declarations.	TypeScript	javascript
`classComponentStateDefinitions`	React	stylistic (strict)
`classComponentStateInitialization`	React	stylistic (strict)
`classDirectives`	Svelte	stylistic (strict)
`classesOrder`	TypeScript	sorting
`classFieldDeclarations`Reports assigning literal values to `this` in constructors instead of using class field declarations.	TypeScript	javascript
`classListDirectiveObjects`	Astro	stylistic
`classListDirectives`	Astro	stylistic
`classListDirectiveSplits`	Astro	stylistic
`classListProps`	SolidJS	(none)
`classListToggles`Prefer using classList.toggle() over conditional classList.add() and classList.remove().	Browser	stylistic
`classLiteralProperties`Reports getters that return literal values instead of using readonly class fields.	TypeScript	stylistic
`classMemberDuplicates`Reports duplicate class member names that will be overwritten.	TypeScript	javascript
`classMethodsThis`Reports class methods that do not use `this`.	TypeScript	stylistic (strict)
`classMultipleObjects`	Vue	stylistic
`classNameDuplicates`	Vue	stylistic
`clickEventKeyEvents`Reports onClick without keyboard event handlers.	JSX	logical
`clickEventKeyEvents`	Astro	logical
`clientComponentAsyncDefinitions`	Next.js	logical
`clientOnlyDirectiveValues`Reports `client:only` directives without a value, or with a value whose type cannot be a renderer hint string.	Astro	logical
`cloakDirectiveValidity`	Vue	logical
`codeSpaces`	Markdown	stylistic
`combinedPushes`Reports consecutive array.push() calls that could be combined into a single call.	TypeScript	stylistic (strict)
`commentDirectives`	Vue	logical
`commentedOutTests`	Vitest	logical (strict)
`commentTextNodes`Reports JSX text nodes that contain comment syntax but are rendered as text.	JSX	logical
`commonjsModules`	TypeScript	(none)
`comparisonMatcherAssertions`	Vitest	stylistic
`compilerMacroImports`	Vue	logical
`compilerOptions`	React	config
`componentApiStyles`	Vue	stylistic
`componentConditionalReturns`	SolidJS	logical
`componentDataSharing`	Vue	logical
`componentDefinitions`	React	stylistic
`componentDidMountSetStates`	React	logical (strict)
`componentDidUpdateSetStates`	React	logical (strict)
`componentDisplayNames`	React	logical (strict)
`componentFileExports`	Astro	logical
`componentFileNameMatches`	Vue	stylistic
`componentHookFactories`	React	logical
`componentHtmlTextProps`	Vue	logical
`componentImportNameMatches`	Vue	stylistic
`componentNameCasing`	Vue	stylistic
`componentNames`	Vue	stylistic
`componentNameValidity`	Vue	logical
`componentNesting`	React	logical
`componentOptionNameCasing`	Vue	stylistic
`componentOptionTypos`	Vue	logical
`componentPropertyOrder`	Vue	sorting
`componentPropMutations`	Vue	logical
`componentTemplateNameCasing`	Vue	stylistic
`componentVIsBinds`	Vue	logical
`componentWillUpdateSetStates`	React	logical (strict)
`computedAsyncProperties`	Vue	logical
`computedPropertyLikeMethods`	Vue	logical
`computedPropertyReturns`	Vue	logical
`computedPropertySideEffects`	Vue	logical
`conditionalExpects`	Vitest	stylistic (strict)
`configPresence`Enforces that the `config` property is present.	PackageJSON	(none)
`configValidity`Enforces that the `config` property is valid.	PackageJSON	logical
`consecutiveNonNullAssertions`Reports unnecessary extra non-null assertions.	TypeScript	stylistic
`consoleCalls`Reports calls to console methods.	TypeScript	(none)
`consoleCalls`	Vue	logical
`consoleSpaces`Disallow leading or trailing spaces in console method string arguments.	Node.js	stylistic (strict)
`constantAssignments`Reports attempting to reassign variables declared with const.	TypeScript	javascript
`constantConditions`	Vue	logical
`constructorGenericCalls`Reports inconsistent placement of type arguments in constructor calls.	TypeScript	stylistic
`constructorReturns`Reports returning values from constructor functions.	TypeScript	javascript
`constructorSupers`Reports constructors of derived classes that do not call `super()`, and constructors of non-derived classes that call `super()`.	TypeScript	javascript
`constVariables`	TypeScript	logical
`contextValueReferences`	React	logical (strict)
`contributorsPresence`Enforces that the `contributors` property is present.	PackageJSON	(none)
`contributorsValidity`Enforces that the `contributors` property is valid.	PackageJSON	logical
`controlAssociatedLabels`	Astro	logical
`controlAssociatedLabels`	JSX	logical
`coreModuleHiding`	Node.js	(none)
`cpuPresence`Enforces that the `cpu` property is present.	PackageJSON	(none)
`cpuValidity`Enforces that the `cpu` property is valid.	PackageJSON	logical
`cspell`Runs the CSpell spell checker on any source code file.	Spelling	logical
`cssManualStylesheets`	Next.js	logical
`customEventNameCasing`	Vue	stylistic
`customFontsInPages`	Next.js	logical
`customModelModifiers`	Vue	logical
`dangerouslySetInnerHTMLWithChildren`	React	logical
`dangerousProps`	React	logical (strict)
`dataComputedProperties`	Vue	logical
`dateConstructorClones`Prefer passing a `Date` directly to the `Date` constructor when cloning, rather than calling `getTime()`.	TypeScript	logical
`dateNowTimestamps`Prefer the shorter `Date.now()` to get the number of milliseconds since the Unix Epoch.	TypeScript	logical (strict)
`debuggerStatements`Reports using debugger statements.	TypeScript	logical
`decoratorsOrder`	TypeScript	sorting
`defaultCaseLast`Reports switch statements where the default clause is not last.	TypeScript	logical
`defaultExports`	TypeScript	(none)
`defaultExports`	Vue	logical
`defaultParameterLast`Enforce default parameters to be last.	TypeScript	javascript
`defaultPropsMatchingPropTypes`	React	logical
`defaultPropsOrder`	JSX	sorting
`defaultPropTypes`	Vue	logical
`defineEmitsDeclarations`	Vue	stylistic
`defineEmitsValidity`	Vue	logical
`defineMacrosOrder`	Vue	sorting
`defineOptionsMacros`	Vue	stylistic
`defineOptionsValidity`	Vue	logical
`definePropsDeclarations`	Vue	stylistic
`definePropsDestructuring`	Vue	stylistic
`definePropsValidity`	Vue	logical
`definitionContents`Reports definitions with empty URLs or only empty fragments.	Markdown	logical
`definitionDuplicates`Reports duplicate definition identifiers (case-insensitive).	Markdown	logical
`definitionUses`Reports unused reference definitions.	Markdown	logical
`deletes`Reports using the delete operator.	Performance	logical
`dependenciesPresence`Enforces that the `dependencies` property is present.	PackageJSON	(none)
`dependenciesValidity`Enforces that the `dependencies` property is valid.	PackageJSON	logical
`dependencyRanges`	PackageJSON	(none)
`dependencyUniqueness`Reports dependency names that are declared more than once in package.json.	PackageJSON	logical
`deprecated`Disallow using code marked as @deprecated.	TypeScript	logical
`deprecatedDataObjectDeclarations`	Vue	logical
`deprecatedDestroyedLifecycleHooks`	Vue	logical
`deprecatedFilters`	Vue	logical
`deprecatedFunctionalTemplates`	Vue	logical
`deprecatedImports`	TypeScript	(none)
`deprecatedThisDefaultProps`	Vue	logical
`describeCallbackValidity`	Vitest	logical
`describePaddingLines`Enforces padding around `describe` blocks.	Vitest	stylistic (strict)
`describeTitleReferences`	Vitest	stylistic
`descriptionPresence`Enforces that the `description` property is present.	PackageJSON	logical
`descriptionValidity`Enforces that the `description` property is valid.	PackageJSON	logical
`destructuring`	React	stylistic
`destructuringConsistency`Use destructured variables over properties for consistency.	TypeScript	stylistic (strict)
`devDependenciesPresence`Enforces that the `devDependencies` property is present.	PackageJSON	(none)
`devDependenciesValidity`Enforces that the `devDependencies` property is valid.	PackageJSON	logical
`devEnginesPresence`Enforces that the `devEngines` property is present.	PackageJSON	(none)
`devEnginesValidity`Enforces that the `devEngines` property is valid.	PackageJSON	logical
`directExports`	Vue	logical
`directivePairs`	TypeScript	logical (strict)
`directiveRequireDescriptions`	TypeScript	stylistic (strict)
`directoriesPresence`Enforces that the `directories` property is present.	PackageJSON	(none)
`directoriesValidity`Enforces that the `directories` property is valid.	PackageJSON	logical
`distractingElements`Reports distracting elements like <marquee> and <blink>.	JSX	logical
`distractingElements`	Astro	logical
`documentCookies`Reports uses of `document.cookie` which can be error-prone and has security implications.	Browser	logical (strict)
`documentDomains`Reports uses of `document.domain` which relaxes same-origin protections.	Browser	logical
`documentWrites`Reports uses of `document.write()` and `document.writeln()` which block HTML parsing.	Browser	logical
`doneCallbacks`	Vitest	(none)
`dotNotation`	Vue	stylistic
`duplicateArguments`Reports functions with duplicate parameter names in their signatures.	TypeScript	javascript
`duplicateAttributes`	Vue	logical
`duplicateElseIfBlocks`	Svelte	logical
`duplicateKeys`	JSON	logical
`duplicateStyleProperties`	Svelte	logical
`duplicateUseDirectives`	Svelte	logical
`duplicateVElseIfConditions`	Vue	logical
`dynamicDeletes`Disallow using the delete operator on computed key expressions.	TypeScript	logical
`dynamicImportChunkNames`	TypeScript	(none)
`dynamicRequires`	TypeScript	(none)
`eachBlockKeys`	Svelte	logical
`eachForConsistency`	Vitest	(none)
`eachLoops`	Vitest	stylistic
`effectSetStates`	React	logical
`elementChildrenValidity`Reports void DOM elements that have children, which is invalid HTML.	JSX	logical (strict)
`elseDirectivesWithForDirectives`	Vue	logical
`elseDirectiveValidity`	Vue	logical
`elseIfDirectiveValidity`	Vue	logical
`elseIfDuplicates`Reports duplicate conditions in if-else-if chains that make code unreachable.	TypeScript	logical
`elseReturns`Reports unnecessary `else` blocks following `if` statements that always return or throw.	TypeScript	stylistic (strict)
`emitsValidatorReturns`	Vue	logical
`emitValidators`	Vue	logical
`emptyBlocks`Reports empty block statements that should contain code.	TypeScript	stylistic
`emptyComponentBlocks`	Vue	stylistic
`emptyDestructures`Reports using empty destructuring patterns that destructure no values.	TypeScript	logical
`emptyDocuments`Reports empty YAML documents that contain only document markers.	YAML	logical
`emptyEnums`Reports empty enum declarations with no members.	TypeScript	logical
`emptyExports`Reports empty export statements that don't make a file a module.	TypeScript	logical
`emptyFields`Reports empty package.json fields that do not add package metadata.	PackageJSON	logical
`emptyFiles`Reports files that contain no meaningful code.	TypeScript	stylistic (strict)
`emptyFunctions`Reports empty functions that should contain code or a comment.	TypeScript	stylistic (strict)
`emptyMappingKeys`Reports empty mapping keys.	YAML	logical
`emptyMappingValues`Reports empty mapping values.	YAML	logical
`emptyModuleAttributes`Reports empty import/export attributes that serve no purpose.	TypeScript	stylistic
`emptyObjectTypes`Reports empty object type literals and empty interfaces that are often used incorrectly.	TypeScript	logical
`emptyPatterns`	Vue	logical
`emptySequenceEntries`Reports empty sequence entries.	YAML	logical
`emptyStaticBlocks`Reports empty static initialization blocks within class declarations.	TypeScript	stylistic
`emptyTypeParameterLists`Reports empty type parameter lists in type aliases and interfaces.	TypeScript	stylistic
`endTagPresence`	Vue	logical
`enginesPresence`Enforces that the `engines` property is present.	PackageJSON	(none)
`enginesValidity`Enforces that the `engines` property is valid.	PackageJSON	logical
`enumInitializers`Reports enum members without explicit initial values.	TypeScript	(none)
`enumMemberLiterals`Requires all enum members to be literal values.	TypeScript	logical (strict)
`enumMixedValues`	TypeScript	logical
`enumsOrder`	TypeScript	(none)
`enumValueConsistency`Reports enums that contain both string and number members.	TypeScript	logical
`enumValueDuplicates`Reports enum members with duplicate values.	TypeScript	logical
`equalityMatchers`	Vitest	stylistic
`equalityOperatorNegations`Reports negated expressions on the left side of equality checks.	TypeScript	(none)
`equalityOperators`Enforces consistent use of strict equality operators (=== and !==) over loose equality operators (== and !=) for non-nullish comparisons.	TypeScript	logical
`errorBoundaries`	React	logical
`errorMessages`Requires a message value when creating a built-in error.	TypeScript	logical (strict)
`errorSubclassProperties`Reports incorrect Error subclass definitions that don't follow best practices.	TypeScript	logical (strict)
`errorUnnecessaryCaptureStackTraces`Reports unnecessary Error.captureStackTrace() calls in Error subclass constructors.	TypeScript	logical
`escapeSequenceCasing`Reports escape sequences with lowercase hexadecimal characters.	TypeScript	stylistic (strict)
`evals`Reports uses of the eval function.	TypeScript	logical
`eventClasses`Prefer EventTarget over EventEmitter for cross-platform compatibility.	Node.js	logical (strict)
`eventHandlerCasing`	SolidJS	logical
`eventListenerSubscriptions`Prefer addEventListener over assigning to on* event handler properties.	Browser	logical (strict)
`eventPrefixes`	Svelte	stylistic (strict)
`eventTriggerExplicitEmits`	Vue	logical
`evolvingVariableTypes`Reports variables declared without type annotation or initializer.	TypeScript	(none)
`exceptionAssignments`Reports reassigning exception parameters in catch clauses.	TypeScript	logical
`exhaustiveDeps`	React	logical
`expectGroupPaddingLines`Enforces padding around `expect` groups.	Vitest	stylistic (strict)
`expectResolves`	Vitest	stylistic
`expectsOutsideTests`	Vitest	logical (strict)
`expectValidity`	Vitest	logical
`explicitAnys`Reports explicit uses of the any type.	TypeScript	logical
`explicitSlots`	Vue	logical
`exponentiationOperators`Prefers the ** operator over Math.pow().	TypeScript	stylistic
`exportAttributesOrder`	TypeScript	(none)
`exportDeclarationsOrder`	TypeScript	(none)
`exportFromImports`Reports imports that are re-exported and could use export...from syntax instead.	TypeScript	stylistic
`exportMutables`Reports exporting mutable bindings (let or var).	TypeScript	logical
`exportsAssignments`Prevent assignment to the `exports` variable in CommonJS modules.	Node.js	logical
`exportsOrder`	TypeScript	sorting
`exportsPresence`Enforces that the `exports` property is present.	PackageJSON	logical
`exportsSubpathsStyle`Enforce consistent root `exports` subpath style in package.json.	PackageJSON	stylistic
`exportsValidity`Enforces that the `exports` property is valid.	PackageJSON	logical
`exportUniqueNames`Reports duplicate export names in a module.	TypeScript	javascript
`exposeAfterAwaits`	Vue	logical
`exposeMacros`	Vue	logical
`extraneousClasses`Reports classes used as static namespaces.	TypeScript	logicalStrict
`falsyMatchers`	Vitest	(none)
`fencedCodeLanguages`Reports fenced code blocks without a language specified.	Markdown	stylistic (strict)
`fencedCodeMeta`	Markdown	stylistic
`fetchMethodBodies`Disallow providing a body with GET or HEAD fetch requests.	TypeScript	logical
`fileExtensions`Enforces consistent YAML file extensions.	YAML	stylistic (strict)
`filenames`	Vitest	(none)
`filePathsFromImportMeta`Prefer `import.meta.dirname` and `import.meta.filename` over legacy file path techniques.	Node.js	stylistic (strict)
`fileReadJSONBuffers`Prefer reading JSON files as buffers when using JSON.parse for better performance.	Node.js	stylistic (strict)
`filesPresence`Enforces that the `files` property is present.	PackageJSON	(none)
`filesRedundancy`	PackageJSON	logical
`filesValidity`Enforces that the `files` property is valid.	PackageJSON	logical
`finallyStatementSafety`Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.	TypeScript	logical
`floatingPromises`	TypeScript	logical
`forBindKeys`	Vue	logical
`forDelimiterStyles`	Vue	stylistic
`forDirections`Reports for loops with counter variables that move in the wrong direction.	TypeScript	stylistic
`forDirectiveValidity`	Vue	logical
`forInArrays`Reports iterating over an array with a for-in loop.	TypeScript	logical
`forInGuards`Reports for-in loops without an if statement to filter inherited properties.	TypeScript	(none)
`forMaps`	SolidJS	logical
`fragmentElements`	JSX	stylistic
`functionApplySpreads`Prefer the spread operator over `.apply()` calls.	TypeScript	stylistic
`functionAssignments`Reports reassigning variables declared with function declarations.	TypeScript	javascript
`functionComponentDefinitions`	React	stylistic
`functionComponentThisReferences`	React	javascript
`functionCurryingRedundancy`Reports using `.apply()` or `.call()` or when the context (`this` value) provides no benefit.	TypeScript	logical
`functionDeclarationStyles`Reports functions that don't match the configured style (declaration vs expression).	TypeScript	(none)
`functionDefinitionScopeConsistency`	TypeScript	stylistic (strict)
`functionNameMatches`Reports function names that don't match the variable or property they're assigned to.	TypeScript	(none)
`functionNewCalls`Reports using the Function constructor to create functions from strings.	TypeScript	logical
`functionTypeDeclarations`	TypeScript	stylistic
`fundingPresence`Enforces that the `funding` property is present.	PackageJSON	(none)
`fundingValidity`Enforces that the `funding` property is valid.	PackageJSON	logical
`gating`	React	config
`generatorFunctionYields`Reports generator functions that do not yield values.	TypeScript	logical
`getterReturns`Reports getter functions that do not return values.	TypeScript	javascript
`globalAssignments`Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.	TypeScript	javascript
`globalCrypto`	Node.js	(none)
`globalMutations`	React	logical
`globalObjectCalls`Reports calling global objects like Math, JSON, or Reflect as functions.	TypeScript	javascript
`globalThisAliases`Reports using window, self, or global instead of globalThis.	TypeScript	stylistic (strict)
`globalTimers`	Node.js	(none)
`googleAnalyticsInlineScript`	Next.js	logical
`googleFontDisplay`	Next.js	logical
`googleFontPreconnect`	Next.js	logical
`gypfilePresence`Enforces that the `gypfile` property is present.	PackageJSON	(none)
`gypfileValidity`Enforces that the `gypfile` property is valid.	PackageJSON	logical
`hashbangs`	Node.js	logical
`headDuplicates`	Next.js	logical
`headImportsInDocuments`	Next.js	logical
`headingContents`Reports heading elements without accessible content.	JSX	logical
`headingContents`	Astro	logical
`headingDuplicates`	Markdown	stylistic (strict)
`headingEmphasisEquivalents`	Markdown	stylistic (strict)
`headingIncrements`Reports heading levels incrementing by more than one.	Markdown	logical
`headingRootDuplicates`Reports multiple H1 headings in the same document.	Markdown	logical (strict)
`headingRootPresence`	Markdown	logical (strict)
`headingTrailingPunctuation`	Markdown	stylistic (strict)
`headNatives`	Next.js	logical
`heritageClausesOrder`	TypeScript	sorting
`hexColorValidity`Reports hex colors with invalid values.	CSS	logical
`hoistedApiPositions`	Vitest	logical (strict)
`homepagePresence`Enforces that the `homepage` property is present.	PackageJSON	logical
`homepageValidity`Enforces that the `homepage` property is valid.	PackageJSON	logical
`hookDuplicates`	Vitest	logical (strict)
`hookOrders`	Vitest	stylistic (strict)
`hooksBeforeTestCases`	Vitest	stylistic (strict)
`htmlCommentSpacing`	Svelte	stylistic (strict)
`htmlDirectiveValidity`	Vue	logical
`htmlLangs`Reports <html> elements without a lang prop.	JSX	logical
`htmlLangs`	Astro	logical
`ifDirectiveValidity`	Vue	logical
`ifElseKeys`	Vue	logical
`iframeSandboxes`	JSX	logical (strict)
`iframeTitles`Reports <iframe> elements without a title prop.	JSX	logical
`iframeTitles`	Astro	logical
`imageAltRedundancy`	Astro	logical
`imageAltTexts`Reports images without alternative text.	Markdown	logical
`imageContents`Reports images with empty URLs or only empty fragments.	Markdown	logical
`imgNatives`	Next.js	logical
`immediateMutations`	TypeScript	stylistic
`immutability`	React	logical
`implicitCoercions`	Vue	stylistic
`implicitGlobals`Prevents implicit global variable declarations in browser scripts.	Browser	logical
`impliedEvals`Reports using string arguments in setTimeout, setInterval, setImmediate, execScript, or the Function constructor.	TypeScript	logical
`importAssignments`	TypeScript	javascript
`importAttributesOrder`	TypeScript	(none)
`importCycles`	TypeScript	stylistic
`importDeclarationsFirst`	TypeScript	(none)
`importDeclarationsOrder`	TypeScript	(none)
`importDuplicates`	TypeScript	logical
`importedNamespaceDynamicAccesses`Disallow computed member access on imported namespace identifiers.	Performance	logical
`importEmptyBlocks`Reports empty named import blocks.	TypeScript	logical
`importExtensions`	TypeScript	(none)
`importExtraneousDependencies`	TypeScript	none
`importFileExtensions`	Node.js	(none)
`importMetaProperties`	Nuxt	stylistic
`importSelf`	TypeScript	logical
`importsInMocks`	Vitest	(none)
`importsOrder`	TypeScript	(none)
`importSpecifiersOrder`	TypeScript	(none)
`importTypeSideEffects`Reports imports that use inline type qualifiers on all specifiers when a top-level type qualifier should be used instead.	TypeScript	logical
`importUnnecessaryPathSegments`	TypeScript	stylistic
`incompatibleLibraries`	React	logical
`indexedObjectTypes`Reports indexed object types that don't match the configured style.	TypeScript	stylistic
`infiniteReactivityLoops`	Svelte	logical
`inlineScriptId`	Next.js	logical
`inlineStyles`	Svelte	logical (strict)
`innerHTMLProps`	SolidJS	logical (strict)
`inputCheckedMutability`	JSX	logical
`inspectRunes`	Svelte	logical
`instanceOfArrays`Reports using `instanceof Array` instead of `Array.isArray()`.	TypeScript	logical
`interactiveElementRoles`Reports interactive elements with non-interactive ARIA roles.	JSX	logical
`interactiveElementRoles`	Astro	logical
`interactiveElementsFocusable`Reports interactive elements that are not focusable via keyboard.	JSX	logical
`interactiveElementsFocusable`	Astro	logical
`interfacesOrder`	TypeScript	sorting
`internalModules`	TypeScript	(none)
`intersectionTypesOrder`	TypeScript	sorting
`invalidCodeLines`Reports cases for invalid code that isn't formatted across lines.	Flint	logical
`invalidThis`	TypeScript	javascript
`invalidVoidTypes`	TypeScript	logical (strict)
`irregularWhitespace`	YAML	stylistic
`irregularWhitespaces`Reports irregular whitespace characters that can cause issues with code parsing and display.	TypeScript	logical
`isDirectiveValidity`	Vue	logical
`isNaNComparisons`Reports comparisons with NaN, which should use Number.isNaN() instead.	TypeScript	logical
`isolatedFunctions`	TypeScript	logical
`iterableKeys`	React	logical (strict)
`jsdocAccessTags`	TypeScript	stylistic
`jsdocAnyTypes`	TypeScript	logical
`jsdocAsterisks`	TypeScript	stylistic (strict)
`jsdocEmptyBlocks`	TypeScript	stylistic
`jsdocEmptyTags`	TypeScript	stylistic
`jsdocExampleCodeValidity`	TypeScript	logical
`jsdocFunctionTypes`	TypeScript	logical
`jsdocImplementsTags`	TypeScript	stylistic
`jsdocImportTags`	TypeScript	stylistic
`jsdocInformativeDocs`	TypeScript	stylistic (strict)
`jsdocInlineTagEscapes`	TypeScript	stylistic
`jsdocMisleadingBlocks`	TypeScript	stylistic (strict)
`jsdocMultilineBlocks`	TypeScript	stylistic (strict)
`jsdocNextDescriptions`	TypeScript	stylistic
`jsdocNextTypes`	TypeScript	logical
`jsdocParameterDescriptionHyphens`	TypeScript	stylistic (strict)
`jsdocParameterNamePresence`	TypeScript	stylistic
`jsdocParameterNames`	TypeScript	stylistic
`jsdocPropertyNamePresence`	TypeScript	stylistic
`jsdocPropertyNames`	TypeScript	stylistic
`jsdocRedundantTypes`	TypeScript	stylistic
`jsdocRejects`	TypeScript	stylistic
`jsdocRequiredTags`	TypeScript	stylistic
`jsdocTagNames`	TypeScript	stylistic (strict)
`jsdocTagsOrder`	TypeScript	sorting
`jsdocTemplateDescriptions`	TypeScript	stylistic
`jsdocTemplateNames`	TypeScript	stylistic
`jsdocThrowDescriptions`	TypeScript	stylistic
`jsdocThrowTypes`	TypeScript	logical
`jsdocTypeChecks`	TypeScript	logical
`jsdocTypeScriptEmptyObjectTypes`	TypeScript	logical
`jsdocTypeScriptFunctionTypes`	TypeScript	stylistic
`jsdocTypeScriptMethodSignatureStyles`	TypeScript	stylistic
`jsdocTypeScriptUnnecessaryTemplateExpressions`	TypeScript	stylistic
`jsdocTypesSyntax`	TypeScript	stylistic
`jsdocUnnecessaryReturns`	TypeScript	stylistic
`jsdocUnnecessaryYields`	TypeScript	stylistic
`jsdocValidTypes`	TypeScript	stylistic
`jsdocValues`	TypeScript	stylistic
`jsdocYieldDescriptions`	TypeScript	stylistic
`jsdocYields`	TypeScript	stylistic
`jsdocYieldTypes`	TypeScript	logical
`jsonKeysOrder`	JSON	sorting
`jsxVariableUses`	Vue	logical
`keyboardEventKeys`Prefer KeyboardEvent.key over deprecated properties like keyCode, charCode, and which.	Browser	logical
`keyDuplicates`Reports unnecessary duplicate keys that override previous values.	JSON	logical
`keyDuplicates`	Vue	logical
`keyNormalization`Reports object keys that are not normalized using Unicode normalization forms.	JSON	logical
`keysOrder`	Vue	sorting
`keyValidity`	Vue	logical
`keywordsPresence`Enforces that the `keywords` property is present.	PackageJSON	(none)
`keywordsValidity`Enforces that the `keywords` property is valid.	PackageJSON	logical
`kitPagePropNames`	Svelte	logical
`labelAssociatedControls`Reports <label> elements without an associated control element.	JSX	logical
`labelAssociatedControls`	Astro	logical
`labelReferences`Reports missing label references.	Markdown	logical
`labelReferenceValidity`Reports invalid label references with whitespace.	Markdown	logical
`langValidity`Reports invalid lang attribute values.	JSX	logical (strict)
`langValidity`	Astro	logical
`legacyOctalLiterals`	JSON	logical
`libcPresence`Enforces that the `libc` property is present.	PackageJSON	(none)
`libcValidity`Enforces that the `libc` property is valid.	PackageJSON	logical
`licensePresence`Enforces that the `license` property is present.	PackageJSON	logical
`licenseValidity`Enforces that the `license` property is valid.	PackageJSON	logical
`lifecyclesAfterAwaits`	Vue	logical
`linkContents`Reports links with empty URLs or only empty fragments.	Markdown	logical
`linkDescriptions`	Markdown	logical (strict)
`linkFragments`Reports link fragments that don't exist in the document.	Markdown	logical
`literalConstructorWrappers`Prefers literal syntax over constructor function calls for primitive values.	TypeScript	stylistic
`loneTemplates`	Vue	logical (strict)
`loopAwaits`Reports using await expressions inside loops.	Performance	logical
`loopFunctions`Reports function declarations and expressions inside loops that reference variables modified by the loop.	Performance	logical
`macroVariableNames`	Vue	stylistic
`mainPresence`Enforces that the `main` property is present.	PackageJSON	(none)
`mainValidity`Enforces that the `main` property is valid.	PackageJSON	logical
`manPresence`Enforces that the `man` property is present.	PackageJSON	(none)
`manualDomManipulations`	Svelte	logical
`manualEventListeners`	Svelte	logical (strict)
`manualMemoizationPreservations`	React	logical
`manValidity`Enforces that the `man` property is valid.	PackageJSON	logical
`mapsOrder`	TypeScript	sorting
`mathMethods`Prefer modern Math methods over legacy patterns.	TypeScript	stylistic (strict)
`meaninglessVoidOperators`Reports using the void operator on expressions that are already void or undefined.	TypeScript	logical
`mediaCaptions`Reports media elements without captions.	JSX	logical
`mediaCaptions`	Astro	logical
`mediaSyntaxReversals`Reports reversed link and image syntax in Markdown.	Markdown	stylistic
`memoDirectiveValidity`	Vue	logical
`messagePhrases`	Flint	logical (strict)
`methodSignatureStyles`	TypeScript	stylistic
`misleadingVoidExpressions`Require expressions of type void to appear in statement position.	TypeScript	logical
`missingPlaceholders`Reports `context.report()` calls missing data for message placeholders.	Flint	logical
`misusedPromises`	TypeScript	logical
`mockedFunctionInstances`	Vitest	stylistic (strict)
`mockTypeParameters`	Vitest	stylistic (strict)
`modelDefinitionValidity`	Vue	logical
`modelDirectiveArguments`	Vue	logical
`modelDirectives`	Vue	stylistic
`modelDirectiveValidity`	Vue	logical
`moduleAssignments`	Next.js	javascript
`moduleExportImports`	TypeScript	(none)
`modulePresence`Enforces that the `module` property is present.	PackageJSON	(none)
`modulesOrder`	TypeScript	sorting
`moduleSpecifierLists`Require non-empty specifier lists in import and export statements.	TypeScript	logical
`moduleSyntaxDeclarations`	TypeScript	(none)
`moduleValidity`Enforces that the `module` property is valid.	PackageJSON	logical
`mouseEventKeyEvents`Reports mouse events without corresponding keyboard events.	JSX	logical
`mouseEventKeyEvents`	Astro	logical
`multilineAmbiguities`Reports ambiguous multiline expressions that could be misinterpreted.	TypeScript	stylistic
`multilineStrings`	JSON	logical
`multipleEmptyLines`	YAML	(none)
`mustacheObjects`	Svelte	logical
`namedDefaultExports`Reports anonymous functions and classes as the default export.	TypeScript	stylistic (strict)
`namedDefaultImports`	TypeScript	(none)
`namedDefaultMembers`	TypeScript	(none)
`namedDefaultSpecifiers`	TypeScript	(none)
`namedExports`	TypeScript	(none)
`namePresence`Enforces that the `name` property is present.	PackageJSON	logical
`nameProperties`	Vue	stylistic
`namespaceDeclarations`Reports using legacy `namespace` declarations.	TypeScript	logical
`namespaceImplicitAmbientImports`Reports declared namespaces that implicitly export all members.	TypeScript	stylistic (strict)
`namespaceKeywords`Reports using `module` keyword instead of `namespace` for TypeScript namespaces.	TypeScript	stylistic
`namespaceValidity`	SolidJS	javascript
`nameValidity`Enforces that the `name` property is valid.	PackageJSON	logical
`nativeObjectExtensions`Reports extending the prototype of native JavaScript objects.	TypeScript	javascript
`nativePromises`	TypeScript	(none)
`negatedConditions`	Vue	stylistic
`negatedIfConditions`	Vue	stylistic
`negativeIndexLengthMethods`Prefer negative index over `.length - index` for `at`, `slice`, `splice`, and similar methods.	TypeScript	stylistic (strict)
`negativeZeroComparisons`Reports comparisons with -0 that may not behave as expected.	TypeScript	logical
`nestedStandaloneIfs`Reports `if` statements that are the only statement inside an `else` block or inside another `if` without an `else`.	TypeScript	stylistic
`newDefinitions`Reports misleading constructor and `new` definitions in interfaces and classes.	TypeScript	logical
`newExpressions`Reports standalone new expressions that don't use the constructed object.	TypeScript	logical
`newNativeNonConstructors`Disallows using `new` with global non-constructor functions like Symbol and BigInt.	TypeScript	javascript
`nextDocumentOutsidePage`	Next.js	logical
`nextScriptInHeads`	Next.js	logical
`nextScriptInteractiveOutsideDocument`	Next.js	logical
`nextTickStyles`	Vue	stylistic
`nextTickValidity`	Vue	logical
`nodeAppendMethods`Prefer modern DOM append/prepend methods over appendChild/insertBefore.	Browser	logical (strict)
`nodeBuiltinImports`	TypeScript	(none)
`nodeDatasetAttributes`Prefer using element.dataset over getAttribute/setAttribute for data-* attributes.	Browser	logical (strict)
`nodeModificationMethods`Prefer modern DOM APIs like .replaceWith() and .before() over legacy methods like .replaceChild() and .insertBefore().	Browser	logical (strict)
`nodePropertyInChecks`Disallows using the `in` operator to check properties on TypeScript nodes.	Flint	logical
`nodeProtocols`Prefer the `node:` protocol prefix for Node.js built-in modules for clarity and consistency.	Node.js	logical
`nodeQueryMethods`Prefer modern `querySelector` and `querySelectorAll` over legacy DOM query methods.	Browser	stylistic (strict)
`nodeRemoveMethods`Prefer the modern `node.remove()` method over the legacy `parentNode.removeChild(node)` API.	Browser	logical (strict)
`nodeTestImports`Reports importing from `node:test`.	Vitest	logical
`nodeTextContents`Prefer `textContent` over `innerText` for DOM nodes.	Browser	logical (strict)
`nonInteractiveElementInteractions`Reports non-interactive elements with interactive event handlers.	JSX	logical
`nonInteractiveElementInteractions`	Astro	logical
`nonInteractiveElementRoles`Reports non-interactive elements with interactive ARIA roles.	JSX	logical
`nonInteractiveElementRoles`	Astro	logical
`nonInteractiveElementTabIndexes`Reports non-interactive elements with positive or zero tabIndex values.	JSX	logical
`nonInteractiveElementTabIndexes`	Astro	logical
`nonNullableTypeAssertions`Reports type assertions that can be replaced with non-null assertions.	TypeScript	stylistic
`nonNullAssertedNullishCoalesces`Reports non-null assertions on the left side of nullish coalescing operators.	TypeScript	logical (strict)
`nonNullAssertedOptionalChains`Reports non-null assertions on optional chain expressions.	TypeScript	logical
`nonNullAssertionPlacement`Reports confusing placement of non-null assertions next to comparison or assignment operators.	TypeScript	stylistic (strict)
`nonNullAssertions`	TypeScript	logical (strict)
`nonOctalDecimalEscapes`Reports non-octal decimal escape sequences (\8 and \9) in string literals.	TypeScript	logical
`nullishCheckStyle`Enforces consistent equality operator usage when comparing with null or undefined.	TypeScript	(none)
`nullishCoalescingOperators`Prefer nullish coalescing operator (??) over logical OR (\|\|) for nullish values.	TypeScript	stylistic
`numberMethodRanges`Reports when number method arguments are outside their valid range.	TypeScript	logical
`numberStaticMethods`Reports using legacy global functions instead of `Number` static methods.	TypeScript	logical (strict)
`numericErasingOperations`Reports operations that always result in zero, such as multiplication by zero.	TypeScript	logical
`numericLiteralParsing`Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.	TypeScript	stylistic
`numericPrecision`Reports numeric literals that lose precision when converted to JavaScript numbers.	TypeScript	logical
`numericSeparatorGroups`Reports numeric literals with inconsistent separator grouping.	TypeScript	stylistic (strict)
`numericTrailingZeros`Reports trailing zeros in numeric values.	YAML	stylistic (strict)
`nuxtConfigKeysOrder`	Nuxt	sorting
`nuxtConfigTestKeys`	Nuxt	logical
`objectAssignSpreads`Prefer object spread syntax over `Object.assign()` when the first argument is an object literal.	TypeScript	stylistic
`objectCalls`Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.	TypeScript	logical
`objectEntriesMethods`Prefer Object.fromEntries() over reduce patterns that build objects from key-value pairs.	TypeScript	stylistic (strict)
`objectHasOwns`Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.	TypeScript	stylistic
`objectKeyDuplicates`Reports unnecessary duplicate keys that override previous values.	TypeScript	javascript
`objectProto`Reports using the deprecated proto property to access or modify an object's prototype.	TypeScript	javascript
`objectPrototypeBuiltIns`Reports direct calls to Object.prototype methods on object instances.	TypeScript	logical
`objectShorthand`Object property and method definitions can use shorthand syntax when the key matches the value identifier or when a function expression is assigned.	TypeScript	stylistic
`objectShorthands`	Vue	stylistic
`objectsOrder`	TypeScript	sorting
`objectSpreadUnnecessaryFallbacks`Reports empty object fallbacks in object spread expressions that have no effect.	TypeScript	logical
`objectTypeDefinitions`Prefer interface declarations over type aliases for object types.	TypeScript	stylistic
`objectTypesOrder`	TypeScript	sorting
`octalEscapes`Reports using octal escape sequences in string literals.	TypeScript	javascript
`octalNumbers`Reports using legacy octal numeric literals.	TypeScript	javascript
`olPrefixes`	Markdown	stylistic (strict)
`onceDirectiveValidity`	Vue	logical
`onDirectiveValidity`	Vue	logical
`onEventHyphens`	Vue	stylistic
`onEventStyles`	Vue	stylistic
`onExactModifiers`	Vue	logical
`onHandlerStyles`	Vue	stylistic
`operatorAssignmentShorthand`Prefer assignment operator shorthand where possible.	TypeScript	stylistic
`optimizedStyleAttributes`	Svelte	logical (strict)
`optionalChainOperators`	TypeScript	stylistic
`optionalDependenciesPresence`Enforces that the `optionalDependencies` property is present.	PackageJSON	(none)
`optionalDependenciesValidity`Enforces that the `optionalDependencies` property is valid.	PackageJSON	logical
`optionalPropDefaults`	Vue	logical
`osPresence`Enforces that the `os` property is present.	PackageJSON	(none)
`osValidity`Enforces that the `os` property is valid.	PackageJSON	logical
`overloadSignaturesAdjacent`Require that function overload signatures be consecutive.	TypeScript	stylistic
`packageCollectionsOrder`	PackageJSON	sorting
`packageManagerPresence`Enforces that the `packageManager` property is present.	PackageJSON	(none)
`packageManagerValidity`Enforces that the `packageManager` property is valid.	PackageJSON	logical
`pageLoaders`	Svelte	logical
`pageMetaRuntimeValues`	Nuxt	logical
`parameterPropertyAssignment`	TypeScript	logical
`parameterReassignments`Disallow reassignment of function parameters.	TypeScript	logical
`parentRelativeImports`	TypeScript	(none)
`parseIntRadixes`Reports parseInt calls that are missing or have an invalid radix parameter.	TypeScript	logical
`peerDependenciesInstallation`Enforces that peer dependencies are installed through devDependencies.	PackageJSON	logical
`peerDependenciesMetaPresence`Enforces that the `peerDependenciesMeta` property is present.	PackageJSON	(none)
`peerDependenciesMetaRelationship`Enforces that any dependencies declared in `peerDependenciesMeta` are also defined in the package's `peerDependencies`.	PackageJSON	logical
`peerDependenciesMetaValidity`Enforces that the `peerDependenciesMeta` property is valid.	PackageJSON	logical
`peerDependenciesPresence`Enforces that the `peerDependencies` property is present.	PackageJSON	(none)
`peerDependenciesValidity`Enforces that the `peerDependencies` property is valid.	PackageJSON	logical
`plainScalars`Prefer plain style scalars over quoted scalars.	YAML	stylistic (strict)
`pluginRuleOrdering`Reports Flint plugin `rules` arrays that are not sorted alphabetically.	Flint	stylistic (strict)
`plusOperands`	TypeScript	logical
`polyfillDuplicates`	Next.js	logical
`precisionLoss`	Vue	logical
`preDirectiveValidity`	Vue	logical
`prerenderExportsOutsidePages`	Astro	logical
`privatePackageProperties`Reports package.json properties that do not apply to private packages.	PackageJSON	(none)
`privatePresence`Enforces that the `private` property is present.	PackageJSON	(none)
`privateValidity`Enforces that the `private` property is valid.	PackageJSON	logical
`processExits`Prevent direct use of `process.exit()` for better error handling and testing.	Node.js	logical
`promiseCallbackCreations`	TypeScript	(none)
`promiseCatchReturns`	TypeScript	(none)
`promiseFunctionAsync`	TypeScript	stylistic
`promiseMethodSingleArrayArguments`	TypeScript	logical
`promiseMultipleResolutions`	TypeScript	(none)
`promiseParameterValidity`	TypeScript	(none)
`promiseRejectErrors`	TypeScript	logical
`promiseReturns`	TypeScript	(none)
`promiseReturnWrappers`	TypeScript	(none)
`promiseSettleAssertions`	Vitest	stylistic
`promiseSpecMethods`	TypeScript	(none)
`promiseStaticConstructors`	TypeScript	(none)
`propComments`	Vue	stylistic
`propDestructures`	SolidJS	logical
`propDuplicates`Disallow duplicate props in JSX elements.	JSX	logical
`propertyAccessNotation`Reports bracket notation property access when dot notation can be used.	TypeScript	stylistic
`propertyOrder`	PackageJSON	sorting
`propertyValidity`	React	javascript
`propLimits`	Vue	stylistic
`propNameCasing`	Vue	stylistic
`propNameValidity`	Vue	logical
`propRequiredAndDefaults`	Vue	logical (strict)
`propsOrder`	JSX	sorting
`propTypeConstructors`	Vue	logical
`propTypes`	React	javascript
`propTypes`	Vue	logical
`publishConfigPresence`Enforces that the `publishConfig` property is present.	PackageJSON	(none)
`publishConfigRedundancy`Reports `publishConfig.access` fields that do not affect unscoped packages.	PackageJSON	logical
`publishConfigValidity`Enforces that the `publishConfig` property is valid.	PackageJSON	logical
`pureComponentShouldUpdateDefinitions`	JSX	logical (strict)
`purity`	React	logical
`quotes`	YAML	(none)
`reactiveReassignments`	Svelte	logical
`reactivity`	SolidJS	logical
`reactLikeDeps`	SolidJS	javascript
`reactLikeProps`	SolidJS	javascript
`recursionOnlyArguments`Reports function parameters that are only used in recursive calls.	TypeScript	logical
`redundantTypeConstituents`Reports union and intersection type constituents that are redundant or override other types.	TypeScript	logical
`referenceLikeUrls`Reports resource links/images with URLs that match definition identifiers.	Markdown	logical
`refObjectReactivityLoss`	Vue	logical
`refOperands`	Vue	logical
`refs`	React	logical
`refStrings`	React	logical
`regexAllGlobalFlags`Reports `matchAll()` and `replaceAll()` calls with regex arguments missing the global flag.	TypeScript	logical
`regexAmbiguousInvalidity`Reports regex patterns that use ambiguous or invalid syntax from Annex B.	TypeScript	logical
`regexCharacterClasses`Reports regex alternations that can be simplified to character classes.	TypeScript	stylistic (strict)
`regexCharacterClassRanges`Reports character class elements that can be simplified to ranges.	TypeScript	stylistic
`regexCharacterClassSetOperations`Reports lookarounds that can be replaced with character class set operations.	TypeScript	stylistic
`regexConciseCharacterClassNegations`Reports negated character classes that can use shorthand escapes.	TypeScript	stylistic
`regexContradictoryAssertions`Reports elements in regular expressions that contradict assertions.	TypeScript	logical
`regexControlCharacterEscapes`Reports control characters that are not escaped using standard escape sequences.	TypeScript	logical
`regexControlCharacters`Reports control characters in regular expressions.	TypeScript	logical
`regexDigitMatchers`Reports character classes with multiple adjacent characters that could use a range instead.	TypeScript	stylistic (strict)
`regexDollarEscapes`Reports replacement strings with unescaped `$` that should use `$$`.	TypeScript	stylistic
`regexDuplicateCharacterClassCharacters`Reports duplicate characters in regular expression character classes.	TypeScript	logical
`regexDuplicateDisjunctions`	TypeScript	logical
`regexEmptyAlternatives`Reports empty alternatives in regular expressions that may indicate a mistake.	TypeScript	logical
`regexEmptyCapturingGroups`Reports capturing groups that only capture empty strings.	TypeScript	logical
`regexEmptyCharacterClasses`Reports character classes that match no characters.	TypeScript	logical
`regexEmptyGroups`Reports empty groups in regular expressions.	TypeScript	logical
`regexEmptyLazyQuantifiers`Reports lazy quantifiers at the end of regular expressions.	TypeScript	logical
`regexEmptyLookaroundsAssertions`Reports empty lookahead and lookbehind assertions in regular expressions.	TypeScript	logical
`regexEmptyStringLiterals`Reports empty string literals in character classes.	TypeScript	logical
`regexEscapeBackspaces`Reports escape backspace (`[\b]`) in character classes.	TypeScript	stylistic
`regexExecutors`Reports String.prototype.match calls that can be replaced with RegExp.prototype.exec.	TypeScript	stylistic (strict)
`regexFlagsOrder`	TypeScript	sorting
`regexGraphemeStringLiterals`Reports string literals inside character classes with the `v` flag that contain multiple graphemes.	TypeScript	stylistic (strict)
`regexHexadecimalEscapes`Reports regex character escapes that can be expressed more consistently using hexadecimal escapes.	TypeScript	stylistic (strict)
`regexIgnoreCaseFlags`Reports regex patterns that can be simplified by using the i (ignore case) flag.	TypeScript	logical
`regexInvisibleCharacters`Reports invisible characters in regex patterns that should use escape sequences instead.	TypeScript	logical
`regexLetterCasing`Reports inconsistent letter casing in regex sequences.	TypeScript	stylistic (strict)
`regexListsOrder`	TypeScript	sorting
`regexLiterals`Use a regular expression literal when the pattern is static.	TypeScript	logical
`regexLiterals`	JSON	logical
`regexLookaroundAssertions`Reports capturing groups at pattern boundaries that can be replaced with lookaround assertions.	TypeScript	stylistic (strict)
`regexLookaroundQuantifierOptimizations`Reports non-constant quantifiers in lookaround assertions that could be simplified.	TypeScript	logical
`regexMatchNotation`Reports inconsistent notations for matching any character in regular expressions.	TypeScript	stylistic (strict)
`regexMisleadingCapturingGroups`Reports capturing groups that capture less text than their pattern suggests.	TypeScript	logical
`regexMisleadingQuantifiers`Reports quantifiers whose minimum implies they must match but whose element can match empty.	TypeScript	logical
`regexMisleadingUnicodeCharacters`Reports characters in regex character classes that appear as single visual characters but are made of multiple code points.	TypeScript	logical
`regexNamedBackreferences`Reports backreferences that do not use the name of their referenced capturing group.	TypeScript	stylistic (strict)
`regexNamedCaptureGroups`Reports capturing groups in regular expressions that do not have a name.	TypeScript	(none)
`regexNamedReplacements`Reports indexed references in replacement strings that should use named references.	TypeScript	stylistic (strict)
`regexNonStandardFlags`Reports non-standard regular expression flags.	TypeScript	logical
`regexObscureRanges`Reports obscure character ranges in regular expressions.	TypeScript	logical
`regexOctalEscapes`Reports octal escape sequences in regular expressions.	TypeScript	logical
`regexPlusQuantifiers`Reports quantifiers `{1,}` in regular expressions that should use `+` instead.	TypeScript	stylistic (strict)
`regexPredefinedAssertions`Reports regex lookarounds that can be replaced with predefined assertions.	TypeScript	stylistic
`regexQuantifierOptimizations`	TypeScript	logical
`regexQuestionQuantifiers`Reports quantifiers `{0,1}` in regular expressions that should use `?` instead.	TypeScript	stylistic (strict)
`regexRepeatQuantifiers`Reports consecutive identical elements in regular expressions that should use quantifiers.	TypeScript	stylistic
`regexResultArrayGroups`Reports indexed access on regex result arrays when named capturing groups should be used.	TypeScript	stylistic (strict)
`regexSetOperationOptimizations`Reports set operations in regular expressions that can be simplified.	TypeScript	logical
`regexStandaloneBackslashes`Reports standalone backslashes in regex patterns that look like incomplete escape sequences.	TypeScript	logical
`regexStarQuantifiers`Reports quantifiers `{0,}` in regular expressions that should use `*` instead.	TypeScript	stylistic (strict)
`regexSuperLinearBacktracking`Reports regular expressions with exponential or polynomial backtracking.	TypeScript	logical
`regexSuperLinearMoves`Reports quantifiers that can cause quadratic regex matching time.	TypeScript	logical
`regexTestMethods`Reports match() and exec() calls that should use RegExp.prototype.test() for boolean checks.	TypeScript	stylistic
`regexUnicodeCodepointEscapes`Reports surrogate pair escapes in regular expressions that can be replaced with Unicode codepoint escapes.	TypeScript	stylistic (strict)
`regexUnicodeEscapes`Enforces consistent Unicode escape style in regex patterns by preferring codepoint escapes.	TypeScript	(none)
`regexUnicodeFlag`Require regex patterns to have the unicode ('u') or unicodeSets ('v') flag for proper Unicode character handling.	TypeScript	(none)
`regexUnicodeProperties`Reports inconsistent Unicode property names in regular expressions.	TypeScript	stylistic
`regexUnnecessaryAssertions`Reports assertions in regular expressions that always reject.	TypeScript	logical
`regexUnnecessaryBackreferences`Reports backreferences in regular expressions that will always match empty or fail.	TypeScript	logical
`regexUnnecessaryCharacterClasses`Reports character classes that wrap a single element that does not require brackets.	TypeScript	logical
`regexUnnecessaryCharacterRanges`Reports character class ranges that span only one or two characters.	TypeScript	logical
`regexUnnecessaryDisjunctions`Reports single-character alternatives in string disjunctions.	TypeScript	logical
`regexUnnecessaryDollarReplacements`Reports replacement string references to capturing groups that do not exist in the pattern.	TypeScript	logical
`regexUnnecessaryEscapes`Reports unnecessary escape sequences in regular expressions.	TypeScript	stylistic
`regexUnnecessaryLookaroundAssertions`Reports unnecessary nested lookaround assertions in regular expressions.	TypeScript	logical
`regexUnnecessaryNestedAssertions`Reports trivially nested assertions in regular expressions that can be simplified.	TypeScript	logical
`regexUnnecessaryNestedQuantifiers`Reports trivially nested quantifiers in regular expressions that can be simplified.	TypeScript	logical
`regexUnnecessaryNonCapturingGroups`Reports non-capturing groups that can be removed without changing the meaning of the regex.	TypeScript	stylistic (strict)
`regexUnnecessaryNumericQuantifiers`Reports numeric quantifiers like '{n,n}' that can be simplified to '{n}'.	TypeScript	logical
`regexUnnecessaryOptionalAssertions`Reports assertions inside optional quantifiers that have no effect.	TypeScript	logical
`regexUnnecessaryReferentialBackreferences`Reports backreferences that may reference a capturing group that was not matched.	TypeScript	logical
`regexUnnecessarySetOperands`Reports unnecessary operands in regular expression character class set operations.	TypeScript	logical
`regexUnusedCapturingGroups`Reports capturing groups in regular expressions that are never referenced.	TypeScript	logical
`regexUnusedFlags`Reports regular expression flags that have no effect on the pattern.	TypeScript	logical
`regexUnusedLazyQuantifiers`Reports lazy quantifiers that have no effect because the quantifier is constant.	TypeScript	logical
`regexUnusedQuantifiers`Reports quantifiers that match exactly once, making them unnecessary.	TypeScript	logical
`regexValidity`Reports invalid regular expressions.	TypeScript	logical
`regexWordMatchers`Reports character classes that match word characters and could use \w or \W instead.	TypeScript	stylistic (strict)
`regexZeroQuantifiers`Reports quantifiers with a maximum of zero, which are useless.	TypeScript	logical
`relativePackageImports`	TypeScript	(none)
`removeEventListenerExpressions`Disallow inline function expressions in removeEventListener calls.	Browser	logical
`renderedLiteralLeaks`	JSX	logical (strict)
`renderReturns`	Vue	logical
`renderReturns`	JSX	logical
`renderSetStates`	React	logical
`repositoryDirectoryValidity`	PackageJSON	logical
`repositoryPresence`Enforces that the `repository` property is present.	PackageJSON	logical
`repositoryShorthand`Enforces using an object locator for `repository`.	PackageJSON	logical
`repositoryValidity`Enforces that the `repository` property is valid.	PackageJSON	logical
`requireImports`Reports CommonJS require() imports in favor of ES module imports.	TypeScript	logical
`responseJsonMethods`Prefer `Response.json()` over `new Response(JSON.stringify(...))` for JSON responses.	TypeScript	stylistic
`responseStaticJsonMethods`	TypeScript	stylistic
`restrictedBindDirectives`	Vue	logical
`restrictedBlocks`	Vue	logical
`restrictedCallsAfterAwaits`	Vue	logical
`restrictedClasses`	Vue	logical
`restrictedComponentNames`	Vue	logical
`restrictedComponentNamesLegacy`	Vue	logical
`restrictedComponentOptions`	Vue	logical
`restrictedComponentProps`	React	(none)
`restrictedCustomEvents`	Vue	logical
`restrictedDomProps`	React	(none)
`restrictedElements`	React	(none)
`restrictedGlobals`	TypeScript	(none)
`restrictedHtmlElements`	Vue	logical
`restrictedIdentifiers`Disallows specific identifier names in binding positions.	TypeScript	(none)
`restrictedImportPaths`	TypeScript	(none)
`restrictedImports`	TypeScript	(none)
`restrictedImports`	Node.js	(none)
`restrictedMatchers`	Vitest	(none)
`restrictedOnDirectives`	Vue	logical
`restrictedProperties`	TypeScript	(none)
`restrictedProps`	Vue	logical
`restrictedPropTypes`	React	(none)
`restrictedStaticAttributes`	Vue	logical
`restrictedSyntax`	TypeScript	(none)
`restrictedSyntaxes`	Vue	logical
`restrictedTypes`	TypeScript	(none)
`restrictedViMethods`	Vitest	(none)
`returnAssignments`Reports using assignment expressions in return statements.	TypeScript	stylistic
`returnAwaitPromises`	TypeScript	logical
`returnThisTypes`Enforce that `this` is used when only `this` type is returned.	TypeScript	logical (strict)
`returnVoidSafety`	TypeScript	logicalStrict
`roleRedundancies`Reports redundant ARIA roles on elements with implicit roles.	JSX	logical
`roleRedundancies`	Astro	logical
`roleRequiredAriaProps`Reports ARIA roles missing their required ARIA properties.	JSX	logical
`roleRequiredAriaProps`	Astro	logical
`roleSupportedAriaProps`Reports ARIA properties that are not supported by an element's role.	JSX	logical
`roleSupportedAriaProps`	Astro	logical
`roleTags`Reports ARIA roles that have semantic HTML element equivalents.	JSX	logical (strict)
`roleTags`	Astro	logical
`rootIfDirectives`	Vue	logical
`ruleCreationMethods`Reports plugin rules created directly with language instead of through RuleCreator.	Flint	logical
`ruleDescriptions`	Flint	logical
`rulePresets`	Flint	logical
`rulesOfHooks`	React	logical
`ruleURLs`	Flint	logical
`scopeProps`Reports scope props on non-th elements.	JSX	logical
`scopeProps`	Astro	logical
`scriptSetupExports`	Vue	logical
`scriptsNameCasing`Enforce that names for scripts properties are in kebab case.	PackageJSON	stylistic
`scriptsPresence`Enforces that the `scripts` property is present.	PackageJSON	(none)
`scriptsValidity`Enforces that the `scripts` property is valid.	PackageJSON	logical
`scriptSyncs`	Next.js	logical
`scriptUrls`Reports `javascript:` URLs that can act as a form of eval.	Browser	logical
`scriptUrls`	JSX	logical
`selectorConsistency`	Svelte	stylistic (strict)
`selfAssignments`Reports self-assignments which have no effect and are likely errors.	TypeScript	logical
`selfClosingHtmlElements`	Svelte	stylistic (strict)
`selfClosingTags`	JSX	stylistic
`separateStaticClasses`	Vue	stylistic
`sequences`Reports using the comma operator in expressions.	TypeScript	javascript
`setDirectiveChildContentConflicts`	Astro	logical
`setHasExistenceChecks`	TypeScript	stylistic (strict)
`setHtmlDirectives`Reports using Astro's `set:html` directive, which injects content without escaping.	Astro	security
`setSizeLengthChecks`Prefer `Set.size` over spreading into an array and accessing `.length`.	TypeScript	stylistic (strict)
`setsOrder`	TypeScript	sorting
`setterReturns`Reports return statements with values inside setters.	TypeScript	javascript
`setTextDirectives`	Astro	logical
`setupPropsReactivityLoss`	Vue	logical
`shadowedRestrictedNames`Reports variable declarations that shadow JavaScript's restricted names.	TypeScript	javascript
`shadows`	TypeScript	stylistic
`shebangs`	Node.js	(none)
`shorthandAttributes`	Svelte	stylistic (strict)
`shorthandDirectives`	Svelte	stylistic (strict)
`shorthandStylePropertyOverrides`	Svelte	logical
`showDirectiveValidity`	Vue	logical
`showWhens`	SolidJS	stylistic
`sideEffectsPresence`Enforces that the `sideEffects` property is present.	PackageJSON	logical
`sideEffectsValidity`Enforces that the `sideEffects` property is valid.	PackageJSON	logical
`simpleConditionOrder`	TypeScript	stylistic
`singleEventPayloads`	Vue	stylistic
`singleVariableDeclarations`Enforces one variable per declaration statement.	TypeScript	logical
`sizeComparisonOperators`Enforce consistent style for `.length` and `.size` checks.	TypeScript	stylistic (strict)
`sliceEndLengths`	TypeScript	stylistic
`slotArguments`	Vue	logical (strict)
`slotDirectiveValidity`	Vue	logical
`slotNameCasing`	Vue	stylistic
`slotsAsFunctions`	Vue	logical
`slotStyles`	Vue	stylistic
`snapshotLocalTextContexts`	Vitest	logical
`solidImports`	SolidJS	logical
`sparseArrays`Reports array literals with holes (sparse arrays).	TypeScript	logical
`sparseArrays`	JSON	logical
`sparseArrays`	Vue	logical
`specialElementPrefixes`	Svelte	logical
`spreadAccumulators`Reports spread operations that accumulate values in loops, causing quadratic time complexity.	Performance	logical
`spreadSyntaxes`	TypeScript	stylistic
`statelessComponents`	JSX	stylistic
`stateMutations`	React	logical
`staticClassNamesOrder`	Vue	sorting
`staticComponents`	React	logical
`staticElementInteractions`Reports static elements with event handlers that lack ARIA roles.	JSX	logical
`staticElementInteractions`	Astro	logical
`staticInlineStyles`	Vue	stylistic
`staticMemberOnlyClasses`Reports classes that only contain static members.	TypeScript	stylistic (strict)
`strictBooleanExpressions`	TypeScript	logical
`strictEqualityOperators`	Vue	logical
`stringCaseMismatches`Reports string case method calls compared against literals with mismatched casing.	TypeScript	logical
`stringCodePoints`Reports usage of charCodeAt and fromCharCode instead of their codePoint equivalents.	TypeScript	logical (strict)
`stringMappingKeys`Enforces mapping keys to be strings.	YAML	logical (strict)
`stringSliceMethods`Reports usage of `substring` instead of slice for string operations.	TypeScript	stylistic (strict)
`stringStartsEndsWith`Reports regex patterns that can be replaced with `endsWith` or `startsWith`.	TypeScript	stylistic
`structuredCloneMethods`Reports JSON.parse(JSON.stringify()) patterns that can use structuredClone.	TypeScript	stylistic (strict)
`styleAttributes`	Vue	logical
`styleDirectives`	Svelte	stylistic (strict)
`styledJsxInDocuments`	Next.js	logical
`stylePropObjects`	React	logical (strict)
`stylePropValidity`	SolidJS	javascript
`suggestionMessageIdMatches`	Flint	logical
`svelteInternalImports`	Svelte	logical
`svelteReactivityClasses`	Svelte	logical
`svgTitles`Reports <svg> elements without a <title> child element.	JSX	logical
`switchCaseBreakPositions`	TypeScript	stylistic
`switchCasesOrder`	TypeScript	sorting
`symbolDescriptions`Reports Symbol() calls without description arguments.	TypeScript	stylistic
`tabIndexPositiveValues`Reports positive tabIndex values.	JSX	logical
`tabIndexPositiveValues`	Astro	logical
`tableColumnCounts`Reports table rows with column counts that don't match the header.	Markdown	logical
`targetBlankLinks`	Svelte	security (strict)
`templateBareStrings`	Vue	logical
`templateDepthLimits`	Vue	stylistic
`templateExpressionValues`	TypeScript	logical
`templateForKeys`	Vue	logical
`templateKeys`	Vue	logical
`templateLiteralEscapesConsistency`	TypeScript	stylistic
`templateLiterals`	Vue	logical
`templateRefs`	Vue	logical
`templateRootMultiplicity`	Vue	logical
`templateRootValidity`	Vue	logical
`templateShadows`	Vue	logical (strict)
`templateStrings`	Vue	stylistic
`templateTargetBlanks`	Vue	security
`templateVForOnChildren`	Vue	logical
`testBodyExpectations`	Vitest	logical
`testCaseAssertions`	Vitest	stylistic
`testCaseDuplicates`Reports test cases that are identical to previous test cases.	Flint	logical
`testCaseNameDuplicates`Reports test cases that have the same name as a previous test case.	Flint	logical
`testCaseNonStaticCode`Test case code should be a static string literal.	Flint	logical
`testCaseOnlyFlags`Reports test cases that are marked `only: true`.	Flint	logical
`testCasePaddingLines`Enforces padding around `test` blocks.	Vitest	stylistic (strict)
`testCasesWithinDescribes`Reports importing from `node:test`.	Vitest	stylistic (strict)
`testConditionals`	Vitest	logical (strict)
`testDefinitionFunctions`	Vitest	(none)
`testPrefixes`	Vitest	stylistic
`testShorthands`Test cases with only a code property can use string shorthand syntax instead of object literal syntax.	Flint	stylistic
`textareaMustacheChildren`	Vue	logical
`textDirectives`	Vue	logical
`textDirectiveValidity`	Vue	logical
`thisAliases`Reports assigning `this` to a variable.	TypeScript	logical
`thisAssignments`	TypeScript	stylistic
`thisBeforeSuper`Reports using `this` or `super` before calling `super()` in derived class constructors.	TypeScript	javascript
`thisInTemplates`	Vue	logical (strict)
`throwErrors`Reports throwing values that are not `Error` objects.	TypeScript	logical
`titleInDocumentHeads`	Next.js	logical
`titleRepeats`	Vitest	logical
`titleValidity`	Vitest	logical
`toBeTypeOfs`	Vitest	stylistic
`toContainMatchers`	Vitest	stylistic
`toHaveBeenCalledTimesAssertions`	Vitest	(none)
`toHaveLengthMatchers`	Vitest	stylistic
`topLevelAwaits`Reports top-level await expressions in files that export values.	TypeScript	stylistic (strict)
`topLevelAwaits`	Node.js	(none)
`topLevelBrowserGlobals`	Svelte	logical (strict)
`topLevelPackageProperties`	PackageJSON	(none)
`transitionToggles`	Vue	logical
`tripleSlashReferences`Reports triple-slash reference directives.	TypeScript	logical
`tripleSlashReferenceValidity`Reports invalid triple-slash reference directives.	TypeScript	logical
`trueAttributeShorthands`	Vue	stylistic
`truthyMatchers`	Vitest	(none)
`tsComments`Reports problematic TypeScript comment directives or requires descriptions after directives.	TypeScript	logical
`tslintComments`Reports TSLint disable/enable comments.	TypeScript	stylistic
`typeAssertionStyles`Reports angle-bracket type assertions.	TypeScript	stylistic
`typeConstituentDuplicates`	TypeScript	logical
`typeConstituentsOrder`	TypeScript	sorting
`typedObjectProps`	Vue	logical
`typedRefs`	Vue	logical
`typeExports`	TypeScript	stylistic
`typeImports`Reports imports that do not match the configured type import style.	TypeScript	stylistic
`typeofComparisons`Reports typeof expressions that compare impossible string literals.	TypeScript	javascript
`typePresence`Enforces that the `type` property is present.	PackageJSON	logical
`typesPresence`Enforces that the `types` property is present.	PackageJSON	(none)
`typeValidity`Enforces that the `type` property is valid.	PackageJSON	logical
`typos`	Next.js	logical
`typos`	React	logical
`unassignedVariables`Reports variables that are declared but never assigned a value.	TypeScript	javascript
`unboundMethods`	TypeScript	logical
`undefinedComponents`	Vue	logical
`undefinedDirectives`	Vue	logical
`undefinedElements`	JSX	logical
`undefinedInitialValues`	TypeScript	stylistic
`undefinedProperties`	Vue	logical
`undefinedTypeofChecks`Reports typeof undefined checks.	TypeScript	stylistic (strict)
`undefinedVariables`Reports using variables that are not defined.	TypeScript	javascript
`unescapedEntities`Disallow unescaped HTML entities in JSX text that may cause rendering issues.	JSX	stylistic
`unicodeBOMs`Reports files with Unicode Byte Order Marks (BOMs).	TypeScript	stylistic
`unifiedSignatures`	TypeScript	logical (strict)
`unionTypesOrder`	TypeScript	sorting
`unknownStyleDirectiveProperties`	Svelte	logical
`unnecessaryAsyncExpectFunctions`	Vitest	(none)
`unnecessaryBindDirectives`	Vue	logical
`unnecessaryBinds`Reports unnecessary `.bind()` calls.	TypeScript	logical
`unnecessaryBlocks`Reports standalone block statements that don't create a meaningful scope.	TypeScript	stylistic
`unnecessaryBooleanCasts`Reports unnecessary boolean casts.	TypeScript	stylistic
`unnecessaryCatches`Reports catch clauses that only rethrow the caught error without modification.	TypeScript	logical
`unnecessaryCollectionArguments`	TypeScript	stylistic
`unnecessaryComparisons`Reports comparisons that are always true, always false, or can be simplified.	TypeScript	logical
`unnecessaryComputedKeys`	TypeScript	stylistic
`unnecessaryConcatenation`Reports string concatenation using the + operator when both operands are string literals.	TypeScript	stylistic
`unnecessaryConcatenations`	Vue	logical
`unnecessaryConditions`	TypeScript	logical
`unnecessaryConstructors`	TypeScript	stylistic
`unnecessaryContinues`	TypeScript	logical
`unnecessaryEscapes`Reports unnecessary escape sequences in string literals and template strings.	TypeScript	stylistic
`unnecessaryEscapes`	JSON	stylistic
`unnecessaryFragments`Disallow unnecessary JSX fragments that wrap a single child or have no children.	JSX	stylistic
`unnecessaryIteratorArrays`	TypeScript	stylistic
`unnecessaryLogicalComparisons`	TypeScript	logical
`unnecessaryMathClamps`Reports unnecessary Math.min and Math.max calls with constant arguments or incorrect clamping patterns.	TypeScript	logical
`unnecessaryMustaches`	Vue	logical
`unnecessaryNumericFractions`Reports numeric literals with unnecessary zero fractions or dangling dots.	TypeScript	stylistic
`unnecessaryParentheses`	Vue	stylistic
`unnecessaryQualifiers`	TypeScript	stylistic
`unnecessaryRenames`Renames that don't change the identifier name are unnecessary.	TypeScript	stylistic
`unnecessaryReturns`	TypeScript	stylistic
`unnecessarySpreads`	TypeScript	logical
`unnecessaryStateWraps`	Svelte	logical
`unnecessaryTemplateAttributes`	Vue	logical
`unnecessaryTemplateExpressions`	TypeScript	logical
`unnecessaryTernaries`Reports ternary expressions that can be simplified to boolean expressions or logical operators	TypeScript	stylistic (strict)
`unnecessaryTypeAnnotations`	TypeScript	stylistic
`unnecessaryTypeArguments`	TypeScript	logical
`unnecessaryTypeAssertions`	TypeScript	logical
`unnecessaryTypeConstraints`	TypeScript	logical
`unnecessaryTypeConversions`	TypeScript	logical
`unnecessaryTypeParameters`	TypeScript	logical
`unnecessaryUndefinedDefaults`	TypeScript	logical
`unnecessaryUseStricts`Reports unnecessary "use strict" directives in ES modules and classes.	TypeScript	logical
`unpublishedBins`	Node.js	logical
`unpublishedImports`	Node.js	logical
`unreachableStatements`	TypeScript	javascript
`unresolvedImports`	TypeScript	(none)
`unresolvedNavigations`	Svelte	logical
`unsafeDeclarationmerging`	TypeScript	logical
`unsafeEnumComparisons`	TypeScript	logical
`unsafeFunctionTypes`	TypeScript	logical
`unsafeInlineScripts`	Astro	security
`unsafeLifecycleMethods`	JSX	logical
`unsafeNegations`Reports negating the left operand of `in` or `instanceof` relations.	TypeScript	javascript
`unsafeOptionalChains`	TypeScript	javascript
`unsafeToString`	TypeScript	logical
`unsafeTypeAssertions`	TypeScript	logical
`unsafeUnaryNegations`	TypeScript	logical
`unsupportedFeatures`	Vue	logical
`unsupportedNodeAPIs`	Node.js	logical
`unsupportedSyntax`	React	logical
`unusedClassComponentMethods`	React	logical
`unusedClassNames`	Svelte	logical (strict)
`unusedComponents`	Vue	logical
`unusedCssSelectors`	Astro	logical
`unusedEmitDeclarations`	Vue	logical
`unusedExpressions`	TypeScript	logical
`unusedLabels`	TypeScript	stylistic
`unusedMessageIds`Reports message IDs defined in the messages object that are never used in recognized report calls.	Flint	logical
`unusedModules`	TypeScript	(none)
`unusedPlaceholders`	Flint	logical
`unusedPrivateClassMembers`	TypeScript	logical
`unusedProperties`	Vue	logical
`unusedProps`	Svelte	logical
`unusedPropTypes`	React	logical
`unusedRefs`	Vue	logical
`unusedState`	React	logical
`unusedStyleDefineVars`	Astro	logical
`unusedSvelteIgnores`	Svelte	logical
`unusedSwitchStatements`	TypeScript	logical
`unusedValues`	TypeScript	logical
`unusedVariables`	TypeScript	logical
`unusedVariables`	Vue	logical
`usageBeforeDefinition`	TypeScript	javascript
`uselessChildrenSnippets`	Svelte	logical
`uselessDefaultAssignments`	TypeScript	logical
`uselessMustaches`	Svelte	logical
`useMemoReturns`	React	logical
`useStateDestructures`	React	stylistic
`useStrictDirectives`	TypeScript	javascript
`validEachKeys`	Svelte	logical
`validStyleParsing`	Svelte	logical (strict)
`valueSafety`Reports JSON values that are unsafe for data interchange.	JSON	logical
`varDeclarations`	TypeScript	stylistic
`variableBlockScopeUsage`	TypeScript	javascript
`variableDeclarationsOrder`	TypeScript	sorting
`variableDeletions`Reports attempting to delete variables with the delete operator.	TypeScript	javascript
`variableRedeclarations`	TypeScript	javascript
`variableUses`	JSX	logical
`variableUses`	SolidJS	(none)
`versionPresence`Enforces that the `version` property is present.	PackageJSON	logical
`versionValidity`Enforces that the `version` property is valid.	PackageJSON	logical
`vHtmlDirectives`	Vue	logical (strict)
`vIfsWithVFors`	Vue	logical
`viNamespaceNames`	Vitest	(none)
`vitestGlobalImporting`	Vitest	(none)
`vitestGlobalImports`	Vitest	stylistic
`voidOperator`Reports using the void operator.	TypeScript	stylistic
`vueCustomBlockParsingErrors`	YAML	(none)
`vueCustomBlockParsingErrors`	JSON	logical
`vuePackageImports`	Vue	logical
`watchAfterAwaits`	Vue	logical
`watchArrowFunctions`	Vue	logical
`webpackLoaderSyntax`	TypeScript	(none)
`windowMessagingTargetOrigin`Requires specifying the targetOrigin argument when calling window.postMessage().	Browser	logical
`withStatements`Reports using with statements	TypeScript	javascript
`workspacesPresence`Enforces that the `workspaces` property is present.	PackageJSON	(none)
`workspacesValidity`Enforces that the `workspaces` property is valid.	PackageJSON	logical
`wrapperObjects`Flags using `new` with `Boolean`, `Number`, or `String`, which creates wrapper objects instead of primitives.	TypeScript	logical
`wrapperObjectTypes`	TypeScript	logical
`writableDerivedStores`	Svelte	logical
`yamlKeysOrder`	YAML	(none)
`yamlSequenceValuesOrder`	YAML	sorting

Made with ❤️‍🔥 around the world by the Flint team and contributors.