About

Flint’s TypeScript plugin supports linting JavaScript and TypeScript source code. It comes provided with the flint npm package.

Presets

Flint’s TypeScript plugin provides the following presets:

Preset	Recommended	Description
`logical`	✅ Always	Common rules for finding bugs and enforcing good logical practices.
`logicalStrict`	☑️ When Ready	Additional rules for finding bugs and enforcing good logical practices.
`stylistic`	✅ Always	Common rules for consistent styling and best stylistic practices.
`stylisticStrict`	☑️ When Ready	Additional rules for consistent styling and best stylistic practices.
`untyped`		Extra rules for files that aren’t type-checked by TypeScript.

If you are just getting started with linting, Flint recommends using the logical and stylistic presets:

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: [ts.presets.logical, ts.presets.stylistic],
    },
  ],
});

If you are experienced with both JavaScript/TypeScript and linting, Flint recommends using the logicalStrict and stylisticStrict presets:

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: [ts.presets.logicalStrict, ts.presets.stylisticStrict],
    },
  ],
});

`logical`

Rules that find bugs and enforce good logical practices for most-to-all JavaScript and TypeScript files.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.logical,
    },
  ],
});

`logicalStrict`

Additional logical rules that enforce best practices which are not always straightforward to implement. These rules are recommended for projects where a majority of developers are experienced with both JavaScript/TypeScript and using a linter.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.logicalStrict,
    },
  ],
});

This preset’s rules are a superset of those in logical.

`stylistic`

Rules that enforce consistent styling and best stylistic practices for most-to-all JavaScript and TypeScript files.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.stylistic,
    },
  ],
});

`stylisticStrict`

Additional stylistic rules that enforce best practices which are not always straightforward to implement. These rules are recommended for projects where a majority of developers are experienced with both JavaScript/TypeScript and using a linter.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.stylisticStrict,
    },
  ],
});

This preset’s rules are a superset of those in stylistic.

`untyped`

Rules that fill in rudimentary safety practices that would normally be caught by TypeScript.

import { defineConfig, ts } from "flint";

export default defineConfig({
  use: [
    {
      files: ts.files.all,
      rules: ts.presets.untyped,
    },
  ],
});

The untyped preset is broadly applicable for JavaScript files that aren’t type-checked by TypeScript. For long-lived projects, Flint recommends using this only as a stopgap measure pending converting files fully to TypeScript.

Rules

Implemented: 44 of 393 (11.1%)

Flint Name	Preset	Biome Rule(s)	Deno Lint Rule(s)	ESLint Rule(s)	Oxlint Rule(s)
`anyArguments`	Logical			`@typescript-eslint/no-unsafe-argument`	`typescript/no-unsafe-argument`
`anyAssignments`	Logical			`@typescript-eslint/no-unsafe-assignment`	`typescript/no-unsafe-assignment`
`anyCalls`	Logical			`@typescript-eslint/no-unsafe-call`	`typescript/no-unsafe-call`
`anyMemberAccess`	Logical			`@typescript-eslint/no-unsafe-member-access`	`typescript/no-unsafe-member-access`
`anyReturns`	Logical			`@typescript-eslint/no-unsafe-return`	`typescript/no-unsafe-return`
`arguments`	Logical	`noArguments`		`prefer-rest-params`	`eslint/prefer-rest-params`
`arrayConstructors`	Logical	`useArrayLiterals`	`no-array-constructor`	`no-array-constructor@typescript-eslint/no-array-constructorunicorn/no-new-array`	`eslint/no-array-constructorunicorn/no-new-array`
`arrayElementDeletions`	Logical			`@typescript-eslint/no-array-delete`	`typescript/no-array-delete`
`arrayEmptyCallbackSlots`	Logical				`oxc/uninvoked-array-callback`
`arrayMapIdentities`	Logical	`noFlatMapIdentity`
`arrayUnnecessaryLengthChecks`	Logical			`unicorn/no-useless-length-check`	`unicorn/no-useless-length-check`
`asyncFunctionAwaits`	Logical	`useAwait`	`require-await`	`require-await@typescript-eslint/require-await`	`eslint/require-awaittypescript/require-await`
`asyncPromiseExecutors`	Logical	`noAsyncPromiseExecutor`	`no-async-promise-executor`	`no-async-promise-executor`	`eslint/no-async-promise-executor`
`asyncUnnecessaryPromiseWrappers`	Logical			`unicorn/no-useless-promise-resolve-reject`	`unicorn/no-useless-promise-resolve-reject`
`awaitThenable`	Logical			`@typescript-eslint/await-thenableunicorn/no-unnecessary-await`	`typescript/await-thenableunicorn/no-unnecessary-await`
`caseDuplicates`	Logical	`noDuplicateCase`	`no-duplicate-case`	`no-duplicate-case`	`eslint/no-duplicate-case`
`caseFallthroughs`	Logical	`noFallthroughSwitchClause`	`no-fallthrough`	`no-fallthrough`	`eslint/no-fallthrough`
`catchCallbackTypes`	Logical			`@typescript-eslint/use-unknown-in-catch-callback-variable`	`typescript/use-unknown-in-catch-callback-variable`
`charAtComparisons`	Logical				`oxc/bad-char-at-comparison`
`constVariables`	Logical	`useConst`	`prefer-const`	`prefer-const`
`dateConstructorClones`	Logical			`unicorn/consistent-date-clone`
`debuggerStatements`	Logical	`noDebugger`	`no-debugger`	`no-debugger`	`eslint/no-debugger`
`defaultCaseLast`	Logical	`useDefaultSwitchClauseLast`		`default-case-last`	`eslint/default-case-last`
`deprecated`	Logical			`@typescript-eslint/no-deprecated`
`dynamicDeletes`	Logical			`@typescript-eslint/no-dynamic-delete`	`typescript/no-dynamic-delete`
`elseIfDuplicates`	Logical	`noDuplicateElseIf`		`no-dupe-else-if`	`eslint/no-dupe-else-if`
`emptyDestructures`	Logical	`noEmptyPattern`	`no-empty-pattern`	`no-empty-pattern`	`eslint/no-empty-pattern`
`emptyEnums`	Logical		`no-empty-enum`
`emptyExports`	Logical	`noUselessEmptyExport`		`@typescript-eslint/no-useless-empty-export`	`typescript/no-useless-empty-export`
`emptyObjectTypes`	Logical	`noBannedTypes`	`ban-typesno-empty-interface`	`@typescript-eslint/no-empty-object-type`	`typescript/ban-typestypescript/no-empty-object-typetypescript/no-empty-interface`
`enumMemberLiterals`	Logical	`useLiteralEnumMembers`		`@typescript-eslint/prefer-literal-enum-member`	`typescript/prefer-literal-enum-member`
`enumMixedValues`	Logical			`@typescript-eslint/no-misused-spread`	`typescript/no-misused-spread`
`enumValueConsistency`	Logical			`@typescript-eslint/no-mixed-enums`	`typescript/no-mixed-enums`
`enumValueDuplicates`	Logical			`@typescript-eslint/no-duplicate-enum-values`	`typescript/no-duplicate-enum-values`
`equalityOperators`	Logical	`noDoubleEquals`	`eqeqeq`	`eqeqeq`	`eslint/eqeqeq`
`errorUnnecessaryCaptureStackTraces`	Logical			`unicorn/no-useless-error-capture-stack-trace`
`evals`	Logical	`noGlobalEval`	`no-eval`	`no-eval`	`eslint/no-eval`
`exceptionAssignments`	Logical	`noCatchAssign`	`no-ex-assign`	`no-ex-assign`	`eslint/no-ex-assign`
`explicitAnys`	Logical	`noExplicitAny`	`no-explicit-any`	`@typescript-eslint/no-explicit-any`	`typescript/no-explicit-any`
`exportMutables`	Logical			`import/no-mutable-exports`	`import/no-mutable-exports`
`fetchMethodBodies`	Logical			`unicorn/no-invalid-fetch-options`	`unicorn/no-invalid-fetch-options`
`floatingPromises`	Logical	`noFloatingPromises`		`@typescript-eslint/no-floating-promises`	`typescript/no-floating-promises`
`forInArrays`	Logical			`@typescript-eslint/no-for-in-array`	`typescript/no-for-in-array`
`functionNewCalls`	Logical			`no-new-func`	`eslint/no-new-func`
`generatorFunctionYields`	Logical	`useYield`	`require-yield`	`require-yield`	`eslint/require-yield`
`getterSetterPairedTypes`	Logical			`@typescript-eslint/related-getter-setter-pairs`	`typescript/related-getter-setter-pairs`
`impliedEvals`	Logical			`no-implied-eval@typescript-eslint/no-implied-eval`	`typescript/no-implied-eval`
`importEmptyBlocks`	Logical			`import/no-empty-named-blocks`	`import/no-empty-named-blocks`
`instanceOfArrays`	Logical	`useIsArray`		`unicorn/no-instanceof-builtins`	`unicorn/no-instanceof-arrayunicorn/no-instanceof-builtins`
`isNaNComparisons`	Logical	`useIsNan`	`use-isnan`	`use-isnan`	`eslint/use-isnan`
`meaninglessVoidOperators`	Logical			`@typescript-eslint/no-meaningless-void-operator`	`typescript/no-meaningless-void-operator`
`misleadingVoidExpressions`	Logical	`noVoidTypeReturn`		`@typescript-eslint/no-confusing-void-expression`	`typescript/no-confusing-void-expression`
`misusedPromises`	Logical	`noMisusedPromises`		`@typescript-eslint/no-misused-promises`	`typescript/no-misused-promises`
`moduleSpecifierLists`	Logical			`unicorn/require-module-specifiers`
`namespaceDeclarations`	Logical	`noNamespace`	`no-namespace`	`@typescript-eslint/no-namespace`	`typescript/no-namespace`
`negativeZeroComparisons`	Logical	`noCompareNegZero`	`no-compare-neg-zero`	`no-compare-neg-zero`	`eslint/no-compare-neg-zero`
`newDefinitions`	Logical	`noMisleadingInstantiator`	`no-misused-new`	`@typescript-eslint/no-misused-new`	`typescript/no-misused-new`
`newExpressions`	Logical			`no-new`	`eslint/no-newoxc/missing-throw`
`nonNullAssertedOptionalChains`	Logical	`noNonNullAssertedOptionalChain`	`no-non-null-asserted-optional-chain`	`@typescript-eslint/no-non-null-asserted-optional-chain`	`typescript/no-non-null-asserted-optional-chain`
`nonOctalDecimalEscapes`	Logical	`noNonoctalDecimalEscape`		`no-nonoctal-decimal-escape`	`eslint/no-nonoctal-decimal-escape`
`numberMethodRanges`	Logical				`oxc/number-arg-out-of-range`
`numericErasingOperations`	Logical				`oxc/erasing-op`
`numericPrecision`	Logical	`noPrecisionLoss`		`no-loss-of-precision@typescript-eslint/no-loss-of-precision`	`eslint/no-loss-of-precision`
`objectCalls`	Logical			`no-object-constructor`	`eslint/no-object-constructor`
`objectKeyDuplicates`	Logical	`noDuplicateObjectKeys`		`no-dupe-keys`
`objectPrototypeBuiltIns`	Logical	`noPrototypeBuiltins`	`no-prototype-builtins`	`no-prototype-builtins`	`eslint/no-prototype-builtins`
`objectSpreadUnnecessaryFallbacks`	Logical			`unicorn/no-useless-fallback-in-spread`	`unicorn/no-useless-fallback-in-spread`
`parameterPropertyAssignment`	Logical			`@typescript-eslint/no-unnecessary-parameter-property-assignment`	`typescript/no-unnecessary-parameter-property-assignment`
`parseIntRadixes`	Logical	`useParseIntRadix`		`radix`	`eslint/radix`
`plusOperands`	Logical			`@typescript-eslint/restrict-plus-operands`	`typescript/restrict-plus-operands`
`promiseExecutorReturns`	Logical			`no-promise-executor-return`
`promiseFinallyReturns`	Logical			`promise/no-return-in-finally`	`promise/no-return-in-finally`
`promiseMethodSingleArrayArguments`	Logical			`unicorn/no-single-promise-in-promise-methods`	`unicorn/no-single-promise-in-promise-methods`
`promiseRejectErrors`	Logical			`prefer-promise-reject-errors@typescript-eslint/prefer-promise-reject-errors`	`eslint/prefer-promise-reject-errorstypescript/prefer-promise-reject-errors`
`recursionOnlyArguments`	Logical				`oxc/only-used-in-recursion`
`redundantTypeConstituents`	Logical			`@typescript-eslint/no-redundant-type-constituents`	`typescript/no-redundant-type-constituents`
`regexAllGlobalFlags`	Logical			`regexp/no-missing-g-flag`	`oxc/bad-replace-all-arg`
`regexAmbiguousInvalidity`	Logical			`regexp/strict`
`regexContradictoryAssertions`	Logical			`regexp/no-contradiction-with-assertion`
`regexControlCharacterEscapes`	Logical			`regexp/control-character-escape`
`regexControlCharacters`	Logical	`noControlCharactersInRegex`	`no-control-regex`	`no-control-regexregexp/no-control-character`	`eslint/no-control-regex`
`regexDuplicateCharacterClassCharacters`	Logical			`regexp/no-dupe-characters-character-class`
`regexDuplicateDisjunctions`	Logical			`regexp/no-dupe-disjunctions`
`regexEmptyAlternatives`	Logical			`regexp/no-empty-alternative`
`regexEmptyCapturingGroups`	Logical			`regexp/no-empty-capturing-group`
`regexEmptyCharacterClasses`	Logical			`regexp/no-empty-character-class`
`regexEmptyGroups`	Logical			`regexp/no-empty-group`
`regexEmptyLazyQuantifiers`	Logical			`regexp/no-lazy-ends`
`regexEmptyLookaroundsAssertions`	Logical			`regexp/no-empty-lookarounds-assertion`
`regexEmptyStringLiterals`	Logical			`regexp/no-empty-string-literal`
`regexEscapeBackspaces`	Logical			`regexp/no-escape-backspace`
`regexIgnoreCaseFlags`	Logical			`regexp/use-ignore-case`
`regexInvisibleCharacters`	Logical			`regexp/no-invisible-character`
`regexLegacyFeatures`	Logical			`regexp/no-legacy-features`
`regexLiterals`	Logical	`useRegexLiterals`		`prefer-regex-literals`
`regexLookaroundQuantifierOptimizations`	Logical			`regexp/optimal-lookaround-quantifier`
`regexMisleadingCapturingGroups`	Logical			`regexp/no-misleading-capturing-group`
`regexMisleadingQuantifiers`	Logical			`regexp/confusing-quantifier`
`regexMisleadingUnicodeCharacters`	Logical	`noMisleadingCharacterClass`		`no-misleading-character-classregexp/no-misleading-unicode-character`
`regexNamedCaptureGroups`	Logical			`prefer-named-capture-groupregexp/prefer-named-capture-group`
`regexNonStandardFlags`	Logical			`regexp/no-non-standard-flag`
`regexObscureRanges`	Logical			`regexp/no-obscure-range`
`regexOctalEscapes`	Logical			`regexp/no-octal`
`regexQuantifierOptimizations`	Logical			`regexp/optimal-quantifier-concatenation`
`regexSetOperationOptimizations`	Logical			`regexp/simplify-set-operations`
`regexStandaloneBackslashes`	Logical			`regexp/no-standalone-backslash`
`regexSuperLinearBacktracking`	Logical			`regexp/no-super-linear-backtracking`
`regexSuperLinearMoves`	Logical			`regexp/no-super-linear-move`
`regexUnnecessaryAssertions`	Logical			`regexp/no-useless-assertions`
`regexUnnecessaryBackreferences`	Logical	`noUselessRegexBackrefs`		`no-useless-backreferenceregexp/no-useless-backreference`	`eslint/no-useless-backreference`
`regexUnnecessaryCharacterClasses`	Logical			`regexp/no-useless-character-class`
`regexUnnecessaryCharacterRanges`	Logical			`regexp/no-useless-range`
`regexUnnecessaryDisjunctions`	Logical			`regexp/no-useless-string-literal`
`regexUnnecessaryDollarReplacements`	Logical			`regexp/no-useless-dollar-replacements`
`regexUnnecessaryLookaroundAssertions`	Logical			`regexp/no-extra-lookaround-assertions`
`regexUnnecessaryNestedAssertions`	Logical			`regexp/no-trivially-nested-assertion`
`regexUnnecessaryNestedQuantifiers`	Logical			`regexp/no-trivially-nested-quantifier`
`regexUnnecessaryNumericQuantifiers`	Logical			`regexp/no-useless-two-nums-quantifier`
`regexUnnecessaryOptionalAssertions`	Logical			`regexp/no-optional-assertion`
`regexUnnecessaryReferentialBackreferences`	Logical			`regexp/no-potentially-useless-backreference`
`regexUnnecessarySetOperands`	Logical			`regexp/no-useless-set-operand`
`regexUnusedCapturingGroups`	Logical			`regexp/no-unused-capturing-group`
`regexUnusedFlags`	Logical			`regexp/no-useless-flag`
`regexUnusedLazyQuantifiers`	Logical			`regexp/no-useless-lazy`
`regexUnusedQuantifiers`	Logical			`regexp/no-useless-quantifier`
`regexValidity`	Logical		`no-invalid-regexp`	`no-invalid-regexpregexp/no-invalid-regexp`	`eslint/no-invalid-regexp`
`regexZeroQuantifiers`	Logical			`regexp/no-zero-quantifier`
`requireImports`	Logical	`noCommonJs`		`@typescript-eslint/no-require-imports`	`typescript/no-require-imports`
`returnAwaitPromises`	Logical			`@typescript-eslint/return-await`	`typescript/return-await`
`selfAssignments`	Logical	`noSelfAssign`	`no-self-assign`	`no-self-assign`	`eslint/no-self-assign`
`singleVariableDeclarations`	Logical	`useSingleVarDeclarator`	`single-var-declarator`	`one-var`
`sparseArrays`	Logical	`noSparseArray`	`no-sparse-arrays`	`no-sparse-arrays`	`eslint/no-sparse-arrays`
`stringCaseMismatches`	Logical	`noStringCaseMismatch`
`templateExpressionValues`	Logical			`@typescript-eslint/restrict-template-expressions`	`typescript/restrict-template-expressions`
`throwErrors`	Logical	`useThrowOnlyError`	`no-throw-literal`	`no-throw-literal@typescript-eslint/only-throw-errorsunicorn/throw-new-error`	`eslint/no-throw-literaltypescript/only-throw-errorunicorn/throw-new-error`
`tripleSlashReferences`	Logical		`triple-slash-reference`	`@typescript-eslint/triple-slash-reference`	`typescript/triple-slash-reference`
`tripleSlashReferenceValidity`	Logical		`no-invalid-triple-slash-references`
`tsComments`	Logical	`noTsIgnore`	`ban-ts-comment`	`@typescript-eslint/ban-ts-comment`	`typescript/ban-ts-commenttypescript/prefer-ts-expect-error`
`typeConstituentDuplicates`	Logical			`@typescript-eslint/no-duplicate-type-constituents`	`typescript/no-duplicate-type-constituents`
`unboundMethods`	Logical			`@typescript-eslint/unbound-method`	`typescript/unbound-method`
`unnecessaryBind`	Logical			`no-extra-bind`	`eslint/no-extra-bind`
`unnecessaryCatches`	Logical	`noUselessCatch`		`no-useless-catch`	`eslint/no-useless-catch`
`unnecessaryComparisons`	Logical				`oxc/const-comparisonsoxc/double-comparisons`
`unnecessaryConditions`	Logical	`noUnnecessaryConditions`		`@typescript-eslint/no-unnecessary-condition`
`unnecessaryContinues`	Logical	`noUselessContinue`
`unnecessaryFunctionCurries`	Logical			`no-useless-call`	`eslint/no-useless-call`
`unnecessaryLogicalComparisons`	Logical	`useSimplifiedLogicExpression`		`@typescript-eslint/no-unnecessary-boolean-literal-compare`	`typescript/no-unnecessary-boolean-literal-compare`
`unnecessaryMathClamps`	Logical	`noConstantMathMinMaxClamp`			`oxc/bad-min-max-func`
`unnecessaryNumericFractions`	Logical			`unicorn/no-zero-fractions`	`unicorn/no-zero-fractions`
`unnecessarySpreads`	Logical			`unicorn/no-useless-spread`
`unnecessaryTemplateExpressions`	Logical	`noUnusedTemplateLiteral`		`@typescript-eslint/no-unnecessary-template-expression`	`typescript/no-unnecessary-template-expression`
`unnecessaryTypeArguments`	Logical			`@typescript-eslint/no-unnecessary-type-arguments`	`typescript/no-unnecessary-type-arguments`
`unnecessaryTypeAssertions`	Logical			`@typescript-eslint/no-unnecessary-type-assertion`	`typescript/no-unnecessary-type-assertion`
`unnecessaryTypeConstraints`	Logical	`noUselessTypeConstraint`		`@typescript-eslint/no-unnecessary-type-constraint`	`typescript/no-unnecessary-type-constraint`
`unnecessaryTypeConversions`	Logical			`@typescript-eslint/no-unnecessary-type-conversion`
`unnecessaryTypeParameters`	Logical			`@typescript-eslint/no-unnecessary-type-parameters`
`unnecessaryUndefinedDefaults`	Logical	`noUselessUndefined`		`unicorn/no-useless-undefined`	`unicorn/no-useless-undefined`
`unnecessaryUseStricts`	Logical	`noRedundantUseStrict`
`unsafeDeclarationmerging`	Logical	`noUnsafeDeclarationMerging`		`@typescript-eslint/no-unsafe-declaration-merging`	`typescript/no-unsafe-declaration-merging`
`unsafeEnumComparisons`	Logical			`@typescript-eslint/no-unsafe-enum-comparison`	`typescript/no-unsafe-enum-comparison`
`unsafeFinallyStatements`	Logical	`noUnsafeFinally`	`no-unsafe-finally`	`no-unsafe-finally`	`eslint/no-unsafe-finally`
`unsafeFunctionTypes`	Logical			`@typescript-eslint/no-unsafe-function-type`	`typescript/no-unsafe-function-type`
`unsafeToString`	Logical			`@typescript-eslint/no-base-to-string`	`typescript/no-base-to-string`
`unsafeUnaryNegations`	Logical			`@typescript-eslint/no-unsafe-unary-minus`	`typescript/no-unsafe-unary-minus`
`unusedExpressions`	Logical			`no-unused-expressions@typescript-eslint/no-unused-expressions`	`eslint/no-unused-expressions`
`unusedPrivateClassMembers`	Logical	`noUnusedPrivateClassMembers`		`no-unused-private-class-members`	`eslint/no-unused-private-class-members`
`unusedSwitchStatements`	Logical	`noUselessSwitchCase`		`unicorn/no-useless-switch-case`	`unicorn/no-useless-switch-case`
`unusedValues`	Logical			`no-useless-assignment`
`unusedVariables`	Logical	`noUnusedFunctionParametersnoUnusedVariables`	`no-unused-vars`	`no-unused-vars@typescript-eslint/no-unused-vars`	`eslint/no-unused-vars`
`withStatements`	Logical	`noWith`	`no-with`	`no-with`	`eslint/no-with`
`wrapperObjectTypes`	Logical			`@typescript-eslint/no-wrapper-object-types`
`accessorThisRecursion`	Logical (Strict)			`unicorn/no-accessor-recursion`	`unicorn/no-accessor-recursion`
`awaitInsidePromiseMethods`	Logical (Strict)			`unicorn/no-await-in-promise-methods`	`unicorn/no-await-in-promise-methods`
`caughtErrorCauses`	Logical (Strict)			`preserve-caught-error`
`dateNowTimestamps`	Logical (Strict)	`useDateNow`		`unicorn/prefer-date-now`	`unicorn/prefer-date-now`
`directivePairs`	Logical (Strict)			`@eslint-community/eslint-comments/disable-enable-pair`
`errorMessages`	Logical (Strict)	`useErrorMessage`		`unicorn/error-message`	`unicorn/error-message`
`errorSubclassProperties`	Logical (Strict)			`unicorn/custom-error-definition`
`extraneousClasses`	Logical (Strict)			`@typescript-eslint/no-extraneous-class`	`typescript/no-extraneous-class`
`importExtraneousDependencies`	Logical (Strict)			`import/no-extraneous-dependencies`
`invalidVoidTypes`	Logical (Strict)	`noConfusingVoidType`		`@typescript-eslint/no-invalid-void-type`
`nonNullAssertedNullishCoalesces`	Logical (Strict)			`@typescript-eslint/no-non-null-asserted-nullish-coalescing`	`typescript/no-non-null-asserted-nullish-coalescing`
`nonNullAssertions`	Logical (Strict)	`noNonNullAssertion`	`no-non-null-assertion`	`@typescript-eslint/no-non-null-assertion`	`typescript/no-non-null-assertion`
`reduceTypeParameters`	Logical (Strict)			`@typescript-eslint/prefer-reduce-type-parameter`	`typescript/prefer-reduce-type-parameter`
`regexGraphemeStringLiterals`	Logical (Strict)			`regexp/grapheme-string-literal`
`returnThisTypes`	Logical (Strict)			`@typescript-eslint/prefer-return-this-type`	`typescript/prefer-return-this-type`
`selfComparisons`	Logical (Strict)	`noSelfCompare`	`no-self-compare`	`no-self-compare`	`eslint/no-self-compare`
`stringCodePoints`	Logical (Strict)			`unicorn/prefer-code-point`	`unicorn/prefer-code-point`
`unifiedSignatures`	Logical (Strict)	`useUnifiedTypeSignatures`		`@typescript-eslint/unified-signatures`
`consoleCalls`	None	`noConsole`	`no-console`	`no-console`	`eslint/no-console`
`importTypeSideEffects`	None			`@typescript-eslint/no-import-type-side-effects`	`typescript/no-import-type-side-effects`
`loopAwaits`	None	`noAwaitInLoops`	`no-await-in-loop`	`no-await-in-loop`	`eslint/no-await-in-loop`
`loopFunctions`	None			`no-loop-func@typescript-eslint/no-loop-func`
`regexUnicodeFlag`	None			`require-unicode-regexpregexp/require-unicode-regexp`
`restrictedGlobals`	None	`noRestrictedGlobals`		`no-restricted-globals`	`eslint/no-restricted-globals`
`restrictedIdentifiers`	None			`id-denylist`
`restrictedImports`	None	`noRestrictedImports`		`no-restricted-imports@typescript-eslint/no-restricted-imports`	`eslint/no-restricted-imports`
`restrictedProperties`	None			`no-restricted-properties`
`restrictedSyntax`	None			`no-restricted-syntax`
`restrictedTypes`	None	`noBannedTypes`		`@typescript-eslint/no-restricted-types`
`arrayDeleteUnnecessaryCounts`	Stylistic			`unicorn/no-unnecessary-array-splice-count`
`arrayExistenceChecksConsistency`	Stylistic			`unicorn/consistent-existence-index-check`	`unicorn/consistent-existence-index-check`
`arrayFinds`	Stylistic			`@typescript-eslint/prefer-find`
`arrayFlatUnnecessaryDepths`	Stylistic			`unicorn/no-unnecessary-array-flat-depth`	`unicorn/no-unnecessary-array-flat-depth`
`arrayIncludes`	Stylistic			`@typescript-eslint/prefer-includes`	`@typescript-eslint/prefer-includes`
`arrayLoops`	Stylistic	`noForEachuseForOf`		`@typescript-eslint/prefer-for-ofunicorn/no-array-for-eachunicorn/no-for-loop`	`typescript/prefer-for-ofunicorn/no-array-for-each`
`arrayMutableReverses`	Stylistic			`unicorn/no-array-reverse`
`arrayMutableSorts`	Stylistic			`unicorn/no-array-sort`
`arraySliceUnnecessaryEnd`	Stylistic			`unicorn/no-unnecessary-slice-end`	`unicorn/no-length-as-slice-endunicorn/no-unnecessary-slice-end`
`arrayTernarySpreadingConsistency`	Stylistic			`unicorn/consistent-empty-array-spread`	`unicorn/consistent-empty-array-spread`
`arrayTypes`	Stylistic	`useConsistentArrayType`		`@typescript-eslint/array-type`	`typescript/array-type`
`asConstAssertions`	Stylistic	`useAsConstAssertion`	`prefer-as-const`	`@typescript-eslint/prefer-as-const`	`typescript/prefer-as-const`
`assignmentOperatorShorthands`	Stylistic			`logical-assignment-operators`
`builtinConstructorNews`	Stylistic	`noInvalidBuiltinInstantiation`		`unicorn/new-for-builtins`	`unicorn/new-for-builtins`
`chainedAssignments`	Stylistic			`no-multi-assign`	`eslint/no-multi-assign`
`classLiteralProperties`	Stylistic			`@typescript-eslint/class-literal-property-style`
`consecutiveNonNullAssertions`	Stylistic	`noExtraNonNullAssertion`	`no-extra-non-null-assertion`	`@typescript-eslint/no-extra-non-null-assertion`	`typescript/no-extra-non-null-assertion`
`emptyBlocks`	Stylistic	`noEmptyBlockStatements`	`no-empty`	`no-empty`	`eslint/no-empty`
`emptyModuleAttributes`	Stylistic			`unicorn/require-module-attributes`
`emptyStaticBlocks`	Stylistic	`noEmptyBlockStatements`		`no-empty-static-block`	`eslint/no-empty-static-block`
`emptyTypeParameterLists`	Stylistic	`noEmptyTypeParameters`
`exponentiationOperators`	Stylistic	`useExponentiationOperator`		`prefer-exponentiation-operator`	`eslint/prefer-exponentiation-operator`
`exportFromImports`	Stylistic	`noExportedImports`		`unicorn/prefer-export-from`
`forDirections`	Stylistic	`useValidForDirection`	`for-direction`	`for-direction`	`eslint/for-direction`
`functionCallSpreads`	Stylistic			`prefer-spreadunicorn/prefer-spread`	`eslint/prefer-spreadunicorn/prefer-spread`
`functionTypeDeclarations`	Stylistic	`useShorthandFunctionType`		`@typescript-eslint/prefer-function-type`	`typescript/prefer-function-type`
`genericConstructorCalls`	Stylistic			`@typescript-eslint/consistent-generic-constructors`	`typescript/consistent-generic-constructors`
`groupedAccessorPairs`	Stylistic	`useGroupedAccessorPairs`		`grouped-accessor-pairs`	`eslint/grouped-accessor-pairs`
`importCycles`	Stylistic	`noImportCycles`		`import/no-cycle`	`import/no-cycle`
`importSelf`	Stylistic			`import/no-self-import`	`import/no-self-import`
`importUnnecessaryPathSegments`	Stylistic			`import/no-useless-path-segments`	`import/no-useless-path-segments`
`indexedObjectTypes`	Stylistic			`@typescript-eslint/consistent-indexed-object-style`	`typescript/consistent-indexed-object-style`
`jsdocAccessTags`	Stylistic			`jsdoc/check-access`	`jsdoc/check-ass`
`jsdocEmptyBlocks`	Stylistic			`jsdoc/no-blank-blocks`
`jsdocEmptyTags`	Stylistic			`jsdoc/empty-tags`	`jsdoc/empty-tags`
`jsdocImplementsTags`	Stylistic			`jsdoc/implements-on-classes`	`jsdoc/implements-on-classes`
`jsdocParameterNames`	Stylistic			`jsdoc/check-param-names`
`jsdocPropertyNames`	Stylistic			`jsdoc/check-property-names`	`jsdoc/check-property-names`
`jsdocRedundantTypes`	Stylistic			`jsdoc/no-types`
`jsdocTemplateNames`	Stylistic			`jsdoc/check-template-names`
`jsdocTypesSyntax`	Stylistic			`jsdoc/check-syntax, jsdoc/check-types`
`jsdocUnnecessaryReturns`	Stylistic			`jsdoc/require-returns-check`
`jsdocUnnecessaryYields`	Stylistic			`jsdoc/require-yields-check`
`jsdocValidTypes`	Stylistic			`jsdoc/valid-types`
`jsdocValues`	Stylistic			`jsdoc/check-values`
`jsdocYields`	Stylistic			`jsdoc/require-yields`	`jsdoc/require-yields`
`literalConstructorWrappers`	Stylistic			`unicorn/prefer-bigint-literals`
`multilineAmbiguities`	Stylistic			`no-unexpected-multiline`	`eslint/no-unexpected-multiline`
`namespaceKeywords`	Stylistic	`useNamespaceKeyword`	`prefer-namespace-keyword`	`@typescript-eslint/prefer-namespace-keyword`	`typescript/prefer-namespace-keyword`
`nestedStandaloneIfs`	Stylistic	`useCollapsedElseIfuseCollapsedIf`		`no-lonely-ifunicorn/no-lonely-if`	`eslint/no-lonely-ifunicorn/no-lonely-if`
`nonNullableTypeAssertions`	Stylistic			`@typescript-eslint/non-nullable-type-assertion-style`	`typescript/non-nullable-type-assertion-style`
`nullishCoalescingOperators`	Stylistic			`@typescript-eslint/prefer-nullish-coalescing`
`numericLiteralParsing`	Stylistic	`useNumericLiterals`		`prefer-numeric-literals`	`eslint/prefer-numeric-literals`
`objectAssignSpreads`	Stylistic	`useObjectSpread`		`prefer-object-spread`	`eslint/prefer-object-spread`
`objectHasOwns`	Stylistic	`noPrototypeBuiltins`		`prefer-object-has-own`	`eslint/prefer-object-has-own`
`objectShorthand`	Stylistic	`useConsistentObjectDefinitions`		`object-shorthand`
`objectTypeDefinitions`	Stylistic	`useConsistentTypeDefinitions`		`@typescript-eslint/consistent-type-definitions`	`typescript/consistent-type-definitions`
`operatorAssignmentShorthand`	Stylistic	`useShorthandAssign`		`operator-assignment`	`eslint/operator-assignment`
`optionalChainOperators`	Stylistic	`useOptionalChain`		`@typescript-eslint/prefer-optional-chain`
`overloadSignaturesAdjacent`	Stylistic	`useAdjacentOverloadSignatures`	`adjacent-overload-signatures`	`@typescript-eslint/adjacent-overload-signatures`	`typescript/adjacent-overload-signatures`
`promiseFunctionAsync`	Stylistic			`@typescript-eslint/promise-function-async`	`typescript/promise-function-async`
`propertyAccessNotation`	Stylistic	`useLiteralKeys`		`dot-notation@typescript-eslint/dot-notation`
`regexCharacterClassRanges`	Stylistic			`regexp/prefer-range`
`regexCharacterClassSetOperations`	Stylistic			`regexp/prefer-set-operation`
`regexConciseCharacterClassNegations`	Stylistic			`regexp/negation`
`regexDollarEscapes`	Stylistic			`regexp/prefer-escape-replacement-dollar-char`
`regexPredefinedAssertions`	Stylistic			`regexp/prefer-predefined-assertion`
`regexRepeatQuantifiers`	Stylistic			`regexp/prefer-quantifier`
`regexTestMethods`	Stylistic			`regexp/prefer-regexp-testunicorn/prefer-regexp-test`	`unicorn/prefer-regexp-test`
`regexUnicodeEscapes`	Stylistic			`regexp/unicode-escape`
`regexUnicodeProperties`	Stylistic			`regexp/unicode-property`
`regexUnnecessaryEscapes`	Stylistic			`regexp/no-useless-escape`	`eslint/no-useless-escape`
`responseMethods`	Stylistic	`useStaticResponseMethods`
`returnAssignments`	Stylistic			`no-return-assign`	`eslint/no-return-assign`
`shadows`	Stylistic	`noShadow`		`no-shadow@typescript-eslint/no-shadow`
`stringStartsEndsWith`	Stylistic			`@typescript-eslint/prefer-string-starts-ends-with`	`unicorn/prefer-string-starts-ends-with`
`symbolDescriptions`	Stylistic	`useSymbolDescription`		`symbol-description`	`eslint/symbol-description`
`tslintComments`	Stylistic			`@typescript-eslint/ban-tslint-comment`	`typescript/ban-tslint-comment`
`typeAssertions`	Stylistic			`@typescript-eslint/consistent-type-assertions`
`typeExports`	Stylistic	`consistentTypeExports`		`@typescript-eslint/consistent-type-exports`
`typeImports`	Stylistic	`consistentTypeImports`		`@typescript-eslint/consistent-type-importsimport/consistent-type-specifier-style`	`import/consistent-type-specifier-styletypescript/consistent-type-imports`
`undefinedInitialValues`	Stylistic	`noUselessUndefinedInitialization`	`no-undef`	`no-undef-init`
`unicodeBOMs`	Stylistic			`unicode-bom`	`eslint/unicode-bom`
`unnecessaryBlocks`	Stylistic	`noUselessLoneBlockStatements`		`no-lone-blocks`	`eslint/no-lone-blocks`
`unnecessaryBooleanCasts`	Stylistic	`noExtraBooleanCast`	`no-extra-boolean-cast`	`no-extra-boolean-cast`	`eslint/no-extra-boolean-cast`
`unnecessaryComputedKeys`	Stylistic	`useLiteralKeys`		`no-useless-computed-key`
`unnecessaryConcatentation`	Stylistic	`noUselessStringConcat`		`no-useless-concat`	`eslint/no-useless-concat`
`unnecessaryConstructors`	Stylistic	`noUselessConstructor`		`no-useless-constructor@typescript-eslint/no-useless-constructor`	`eslint/no-useless-constructor`
`unnecessaryEscapes`	Stylistic	`noUselessEscapeInRegexnoUselessEscapeInString`		`no-useless-escape`
`unnecessaryRenames`	Stylistic	`noUselessRename`	`no-useless-rename`	`no-useless-rename`	`eslint/no-useless-rename`
`unnecessaryReturns`	Stylistic			`no-useless-return`
`unnecessaryTypeAnnotations`	Stylistic	`noInferrableTypes`	`no-inferrable-types`	`@typescript-eslint/no-inferrable-types`	`typescript/no-inferrable-types`
`unusedLabels`	Stylistic	`noUnusedLabels`	`no-unused-labels`	`no-unused-labels`	`eslint/no-unused-labels`
`varDeclarations`	Stylistic	`noVar`	`no-var`	`no-var`
`voidOperator`	Stylistic	`noVoid`		`no-void`	`eslint/no-void`
`arrayFilteredFinds`	Stylistic (Strict)			`unicorn/prefer-array-find`	`unicorn/prefer-array-find`
`arrayFlatMapMethods`	Stylistic (Strict)	`useFlatMap`		`unicorn/prefer-array-flat-map`	`unicorn/prefer-array-flat-map`
`arrayFlatMethods`	Stylistic (Strict)			`unicorn/prefer-array-flat`	`unicorn/prefer-array-flat`
`arrayIncludesMethods`	Stylistic (Strict)			`unicorn/prefer-includes`
`arrayIndexOfMethods`	Stylistic (Strict)	`useIndexOf`		`unicorn/prefer-array-index-of`	`unicorn/prefer-array-index-of`
`arraySomeMethods`	Stylistic (Strict)			`unicorn/prefer-array-some`	`unicorn/prefer-array-some`
`atAccesses`	Stylistic (Strict)	`useAtIndex`		`unicorn/prefer-at`
`builtinCoercions`	Stylistic (Strict)			`unicorn/prefer-native-coercion-functions`	`unicorn/prefer-native-coercion-functions`
`caughtVariableNames`	Stylistic (Strict)			`unicorn/catch-error-name`	`unicorn/catch-error-name`
`classMethodsThis`	Stylistic (Strict)			`class-methods-use-this@typescript-eslint/class-methods-use-this`
`combinedPushes`	Stylistic (Strict)			`unicorn/prefer-single-call`
`destructuringConsistency`	Stylistic (Strict)			`unicorn/consistent-destructuring`
`directiveRequireDescriptions`	Stylistic (Strict)			`@eslint-community/eslint-comments/require-description`
`elseReturns`	Stylistic (Strict)	`noUselessElse`		`no-else-return`	`eslint/no-else-return`
`emptyFiles`	Stylistic (Strict)			`unicorn/no-empty-file`	`unicorn/no-empty-file`
`emptyFunctions`	Stylistic (Strict)	`noEmptyBlockStatements`		`no-empty-function@typescript-eslint/no-empty-function`	`eslint/no-empty-function`
`escapeSequenceCasing`	Stylistic (Strict)			`unicorn/escape-case`	`unicorn/escape-case`
`functionDefinitionScopeConsistency`	Stylistic (Strict)			`unicorn/consistent-function-scoping`	`unicorn/consistent-function-scoping`
`globalThisAliases`	Stylistic (Strict)		`no-windowno-window-prefix`	`unicorn/prefer-global-this`	`unicorn/prefer-global-this`
`jsdocAsterisks`	Stylistic (Strict)			`jsdoc/no-multi-asterisksjsdoc/require-asterisk-prefix`
`jsdocInformativeDocs`	Stylistic (Strict)			`jsdoc/informative-docs`
`jsdocMisleadingBlocks`	Stylistic (Strict)			`jsdoc/no-bad-blocks`
`jsdocMultilineBlocks`	Stylistic (Strict)			`jsdoc/multiline-blocks`
`jsdocParameterDescriptionHyphens`	Stylistic (Strict)			`jsdoc/require-hyphen-before-param-description`
`jsdocTagNames`	Stylistic (Strict)			`jsdoc/check-tag-names`	`jsdoc/check-tag-names`
`mathMethods`	Stylistic (Strict)			`unicorn/prefer-modern-math-apis`	`unicorn/prefer-modern-math-apis`
`namedDefaultExports`	Stylistic (Strict)			`unicorn/no-anonymous-default-export`	`import/no-anonymous-default-exportunicorn/no-anonymous-default-export`
`namespaceImplicitAmbientImports`	Stylistic (Strict)		`no-implicit-declare-namespace-export`
`negativeIndexLengthMethods`	Stylistic (Strict)			`unicorn/prefer-negative-index`
`nonNullAssertionPlacement`	Stylistic (Strict)			`@typescript-eslint/no-confusing-non-null-assertion`	`typescript/no-confusing-non-null-assertion`
`numberStaticMethods`	Stylistic (Strict)	`noGlobalIsFinitenoGlobalIsNan`		`unicorn/prefer-number-properties`	`unicorn/prefer-number-properties`
`numericLiteralCasing`	Stylistic (Strict)			`unicorn/number-literal-case`	`unicorn/number-literal-case`
`numericSeparatorGroups`	Stylistic (Strict)	`useNumericSeparators`		`unicorn/numeric-separators-style`	`unicorn/numeric-separators-style`
`objectEntriesMethods`	Stylistic (Strict)			`unicorn/prefer-object-from-entries`	`unicorn/prefer-object-from-entries`
`parameterReassignments`	Stylistic (Strict)	`noParameterAssign`		`no-param-reassign`
`regexCharacterClasses`	Stylistic (Strict)			`regexp/prefer-character-class`
`regexDigitMatchers`	Stylistic (Strict)			`regexp/prefer-d`
`regexExecutors`	Stylistic (strict)			`@typescript-eslint/prefer-regexp-execregexp/prefer-regexp-exec`
`regexHexadecimalEscapes`	Stylistic (Strict)			`regexp/hexadecimal-escape`
`regexLetterCasing`	Stylistic (Strict)			`regexp/letter-case`
`regexLookaroundAssertions`	Stylistic (Strict)			`regexp/prefer-lookaround`
`regexMatchNotation`	Stylistic (Strict)			`regexp/match-any`
`regexNamedBackreferences`	Stylistic (Strict)			`regexp/prefer-named-backreference`
`regexNamedReplacements`	Stylistic (Strict)			`regexp/prefer-named-replacement`
`regexPlusQuantifiers`	Stylistic (Strict)			`regexp/prefer-plus-quantifier`
`regexQuestionQuantifiers`	Stylistic (Strict)			`regexp/prefer-question-quantifier`
`regexResultArrayGroups`	Stylistic (Strict)			`regexp/prefer-result-array-groups`
`regexStarQuantifiers`	Stylistic (Strict)			`regexp/prefer-star-quantifier`
`regexUnicodeCodepointEscapes`	Stylistic (Strict)			`regexp/prefer-unicode-codepoint-escapes`
`regexUnnecessaryNonCapturingGroups`	Stylistic (Strict)			`regexp/no-useless-non-capturing-group`
`regexWordMatchers`	Stylistic (Strict)			`regexp/prefer-w`
`setHasExistenceChecks`	Stylistic (Strict)			`unicorn/prefer-set-has`	`unicorn/prefer-set-has`
`setSizeLengthChecks`	Stylistic (Strict)			`unicorn/prefer-set-size`	`unicorn/prefer-set-size`
`sizeComparisonOperators`	Stylistic (Strict)	`useExplicitLengthCheck`		`unicorn/explicit-length-check`	`unicorn/explicit-length-check`
`staticMemberOnlyClasses`	Stylistic (Strict)	`noStaticOnlyClass`		`unicorn/no-static-only-class`	`unicorn/no-static-only-class`
`stringSliceMethods`	Stylistic (Strict)	`noSubstr`		`unicorn/prefer-string-slice`	`unicorn/prefer-string-slice`
`stringTrimMethods`	Stylistic (Strict)	`useTrimStartEnd`		`unicorn/prefer-string-trim-start-end`	`unicorn/prefer-string-trim-start-end`
`structuredCloneMethods`	Stylistic (Strict)			`unicorn/prefer-structured-clone`	`unicorn/prefer-structured-clone`
`topLevelAwaits`	Stylistic (Strict)			`unicorn/prefer-top-level-await`
`undefinedTypeofChecks`	Stylistic (Strict)			`unicorn/no-typeof-undefined`	`unicorn/no-typeof-undefined`
`unnecessaryTernaries`	Stylistic (Strict)			`unicorn/prefer-logical-operator-over-ternary`	`unicorn/prefer-logical-operator-over-ternary`
`arrayCallbackReturns`	Untyped	`useIterableCallbackReturn`		`array-callback-return`	`eslint/array-callback-return`
`caseDeclarations`	Untyped	`noSwitchDeclarations`	`no-case-declarations`	`no-case-declarations`	`eslint/no-case-declarations`
`classAssignments`	Untyped	`noClassAssign`	`no-case-assign`	`no-class-assign`	`eslint/no-class-assign`
`classFieldDeclarations`	Untyped			`unicorn/prefer-class-fields`
`classMemberDuplicates`	Untyped	`noDuplicateClassMembers`	`no-dupe-class-members`	`no-dupe-class-members@typescript-eslint/no-dupe-class-members`	`eslint/no-dupe-class-members`
`constantAssignments`	Untyped	`noConstAssign`	`no-const-assign`	`no-const-assign`	`eslint/no-const-assign`
`constructorReturns`	Untyped	`noConstructorReturn`		`no-constructor-return`	`eslint/no-constructor-return`
`constructorSupers`	Untyped	`noInvalidConstructorSuper`	`constructor-super`	`constructor-super`
`defaultParameterLast`	Untyped	`useDefaultParameterLast`	`default-param-last`	`default-param-last@typescript-eslint/default-param-last`	`eslint/default-param-last`
`duplicateArguments`	Untyped	`noDuplicateParameters`	`no-dupe-args`	`no-dupe-args`
`functionAssignments`	Untyped	`noFunctionAssign`	`no-func-assign`	`no-func-assign`	`eslint/no-func-assign`
`getterReturns`	Untyped	`useGetterReturn`	`getter-return`	`getter-return`	`eslint/getter-return`
`globalAssignments`	Untyped	`noGlobalAssign`	`no-global-assign`	`no-global-assign`	`eslint/no-global-assign`
`globalObjectCalls`	Untyped	`noGlobalObjectCalls`	`no-obj-calls`	`no-obj-calls`	`eslint/no-obj-calls`
`guardedForIns`	Untyped	`useGuardForIn`	`guard-for-in`	`guard-for-in`	`eslint/guard-for-in`
`importAssignments`	Untyped	`noImportAssign`	`no-import-assign`	`no-import-assign`
`invalidThis`	Untyped			`no-invalid-this@typescript-eslint/no-invalid-this`
`nativeObjectExtensions`	Untyped			`no-extend-native`	`eslint/no-extend-native`
`newNativeNonConstructors`	Untyped	`noInvalidBuiltinInstantiation`	`no-new-symbol`	`no-new-native-nonconstructor`	`eslint/no-new-native-nonconstructor`
`objectProto`	Untyped			`no-proto`	`eslint/no-proto`
`octalEscapes`	Untyped	`noOctalEscape`		`no-octal-escape`
`octalNumbers`	Untyped			`no-octal`
`sequences`	Untyped	`noCommaOperator`		`no-sequences`
`setterReturns`	Untyped	`noSetterReturn`	`no-setter-return`	`no-setter-return`	`eslint/no-setter-return`
`shadowedRestrictedNames`	Untyped	`noShadowRestrictedNames`	`no-shadow-restricted-names`	`no-shadow-restricted-names`	`eslint/no-shadow-restricted-names`
`thisBeforeSuper`	Untyped	`noUnreachableSuper`	`no-this-before-super`	`no-this-before-super`	`eslint/no-this-before-super`
`typeofComparisons`	Untyped	`useValidTypeof`	`valid-typeof`	`valid-typeof`	`eslint/valid-typeof`
`unassignedVariables`	Untyped	`noUnassignedVariables`		`no-unassigned-vars`	`eslint/no-unassigned-vars`
`undefinedVariables`	Untyped	`noUndeclaredVariables`		`no-undef`	`eslint/no-undef`
`unreachableStatements`	Untyped	`noUnreachable`	`no-unreachable`	`no-unreachable`	`eslint/no-unreachable`
`unsafeNegations`	Untyped	`noUnsafeNegation`	`no-unsafe-negation`	`no-unsafe-negation`	`eslint/no-unsafe-negation`
`unsafeOptionalChains`	Untyped	`noUnsafeOptionalChaining`		`no-unsafe-optional-chaining`	`eslint/no-unsafe-optional-chaining`
`usageBeforeDefinition`	Untyped	`noInvalidUseBeforeDeclaration`		`no-use-before-define@typescript-eslint/no-use-before-define`
`useStrictDirectives`	Untyped			`strict`
`variableBlockScopeUsage`	Untyped			`block-scoped-var`	`eslint/block-scoped-var`
`variableDeletions`	Untyped		`no-delete-var`	`no-delete-var`	`eslint/no-delete-var`
`variableRedeclarations`	Untyped	`noRedeclare`	`no-redeclare`	`no-redeclare@typescript-eslint/no-redeclare`	`eslint/no-redeclare`

Selectors

Flint’s TypeScript plugin provides the following file selector:

all: **/*.{cjs,js,jsx,mjs,ts,tsx}

Made with ❤️‍🔥 in Boston by Josh Goldberg and contributors.