diff --git a/packages/eslint-plugin/src/rules/array-type.ts b/packages/eslint-plugin/src/rules/array-type.ts
index 39b3715c47c1..f6d9a5bf126e 100644
--- a/packages/eslint-plugin/src/rules/array-type.ts
+++ b/packages/eslint-plugin/src/rules/array-type.ts
@@ -147,7 +147,7 @@ export default util.createRule<Options, MessageIds>({
     }
 
     return {
-      TSArrayType(node: TSESTree.TSArrayType) {
+      TSArrayType(node) {
         if (
           option === 'array' ||
           (option === 'array-simple' && isSimpleType(node.elementType))
diff --git a/packages/eslint-plugin/src/rules/camelcase.ts b/packages/eslint-plugin/src/rules/camelcase.ts
index c155052ba11f..130181f7b5bf 100644
--- a/packages/eslint-plugin/src/rules/camelcase.ts
+++ b/packages/eslint-plugin/src/rules/camelcase.ts
@@ -89,7 +89,7 @@ export default util.createRule<Options, MessageIds>({
     }
 
     return {
-      Identifier(node: TSESTree.Identifier) {
+      Identifier(node) {
         /*
          * Leading and trailing underscores are commonly used to flag
          * private/protected identifiers, strip them
diff --git a/packages/eslint-plugin/src/rules/generic-type-naming.ts b/packages/eslint-plugin/src/rules/generic-type-naming.ts
index 473fa6bc812f..5789b290b2f0 100644
--- a/packages/eslint-plugin/src/rules/generic-type-naming.ts
+++ b/packages/eslint-plugin/src/rules/generic-type-naming.ts
@@ -2,7 +2,6 @@
  * @fileoverview Enforces naming of generic type variables.
  */
 
-import { TSESTree } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
 type Options = [string?];
@@ -34,7 +33,7 @@ export default util.createRule<Options, MessageIds>({
     const regex = new RegExp(rule!);
 
     return {
-      TSTypeParameter(node: TSESTree.TSTypeParameter) {
+      TSTypeParameter(node) {
         const name = node.name.name;
 
         if (name && !regex.test(name)) {
diff --git a/packages/eslint-plugin/src/rules/interface-name-prefix.ts b/packages/eslint-plugin/src/rules/interface-name-prefix.ts
index 0f895774ffbf..69f428c34e66 100644
--- a/packages/eslint-plugin/src/rules/interface-name-prefix.ts
+++ b/packages/eslint-plugin/src/rules/interface-name-prefix.ts
@@ -3,7 +3,6 @@
  * @author Danny Fritz
  */
 
-import { TSESTree } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
 type Options = ['never' | 'always'];
@@ -45,7 +44,7 @@ export default util.createRule<Options, MessageIds>({
     }
 
     return {
-      TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration): void {
+      TSInterfaceDeclaration(node): void {
         if (never) {
           if (isPrefixedWithI(node.id.name)) {
             context.report({
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
index b16c878bc718..2057c10e3618 100644
--- a/packages/eslint-plugin/src/rules/member-ordering.ts
+++ b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -353,28 +353,28 @@ export default util.createRule<Options, MessageIds>({
     }
 
     return {
-      ClassDeclaration(node: TSESTree.ClassDeclaration) {
+      ClassDeclaration(node) {
         validateMembers(
           node.body.body,
           options.classes || options.default!,
           true
         );
       },
-      ClassExpression(node: TSESTree.ClassExpression) {
+      ClassExpression(node) {
         validateMembers(
           node.body.body,
           options.classExpressions || options.default!,
           true
         );
       },
-      TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration) {
+      TSInterfaceDeclaration(node) {
         validateMembers(
           node.body.body,
           options.interfaces || options.default!,
           false
         );
       },
-      TSTypeLiteral(node: TSESTree.TSTypeLiteral) {
+      TSTypeLiteral(node) {
         validateMembers(
           node.members,
           options.typeLiterals || options.default!,
diff --git a/packages/eslint-plugin/src/rules/no-angle-bracket-type-assertion.ts b/packages/eslint-plugin/src/rules/no-angle-bracket-type-assertion.ts
index 65ae3cd0d837..7bdf2d8ad5a2 100644
--- a/packages/eslint-plugin/src/rules/no-angle-bracket-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-angle-bracket-type-assertion.ts
@@ -3,7 +3,6 @@
  * @author Patricio Trevino
  */
 
-import { TSESTree } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
 export default util.createRule({
@@ -27,7 +26,7 @@ export default util.createRule({
   create(context) {
     const sourceCode = context.getSourceCode();
     return {
-      TSTypeAssertion(node: TSESTree.TSTypeAssertion) {
+      TSTypeAssertion(node) {
         context.report({
           node,
           messageId: 'preferAs',
diff --git a/packages/eslint-plugin/src/rules/no-empty-interface.ts b/packages/eslint-plugin/src/rules/no-empty-interface.ts
index f4373a89375e..edb28c67bc06 100644
--- a/packages/eslint-plugin/src/rules/no-empty-interface.ts
+++ b/packages/eslint-plugin/src/rules/no-empty-interface.ts
@@ -3,7 +3,6 @@
  * @author Patricio Trevino
  */
 
-import { TSESTree } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
 type Options = [
@@ -47,7 +46,7 @@ export default util.createRule<Options, MessageIds>({
   ],
   create(context, [{ allowSingleExtends }]) {
     return {
-      TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration) {
+      TSInterfaceDeclaration(node) {
         if (node.body.body.length !== 0) {
           // interface contains members --> Nothing to report
           return;
diff --git a/packages/eslint-plugin/src/rules/no-extraneous-class.ts b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
index cb6c58de86c4..9dfc4fc290ae 100644
--- a/packages/eslint-plugin/src/rules/no-extraneous-class.ts
+++ b/packages/eslint-plugin/src/rules/no-extraneous-class.ts
@@ -57,7 +57,7 @@ export default util.createRule<Options, MessageIds>({
   ],
   create(context, [{ allowConstructorOnly, allowEmpty, allowStaticOnly }]) {
     return {
-      ClassBody(node: TSESTree.ClassBody) {
+      ClassBody(node) {
         const parent = node.parent as
           | TSESTree.ClassDeclaration
           | TSESTree.ClassExpression
diff --git a/packages/eslint-plugin/src/rules/no-for-in-array.ts b/packages/eslint-plugin/src/rules/no-for-in-array.ts
index c958d39670f9..620b05b6624b 100644
--- a/packages/eslint-plugin/src/rules/no-for-in-array.ts
+++ b/packages/eslint-plugin/src/rules/no-for-in-array.ts
@@ -3,7 +3,6 @@
  * @author Benjamin Lichtman
  */
 
-import { TSESTree } from '@typescript-eslint/typescript-estree';
 import ts from 'typescript';
 import * as util from '../util';
 
@@ -26,7 +25,7 @@ export default util.createRule({
   defaultOptions: [],
   create(context) {
     return {
-      ForInStatement(node: TSESTree.ForInStatement) {
+      ForInStatement(node) {
         const parserServices = util.getParserServices(context);
         const checker = parserServices.program.getTypeChecker();
         const originalNode = parserServices.esTreeNodeToTSNodeMap.get<
diff --git a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
index 3abe06f71a25..b7a26ad0d6f5 100644
--- a/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-non-null-assertion.ts
@@ -3,7 +3,6 @@
  * @author Macklin Underdown
  */
 
-import { TSESTree } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
 export default util.createRule({
@@ -25,7 +24,7 @@ export default util.createRule({
   defaultOptions: [],
   create(context) {
     return {
-      TSNonNullExpression(node: TSESTree.TSNonNullExpression) {
+      TSNonNullExpression(node) {
         context.report({
           node,
           messageId: 'noNonNull'
diff --git a/packages/eslint-plugin/src/rules/no-parameter-properties.ts b/packages/eslint-plugin/src/rules/no-parameter-properties.ts
index cce3af7b3620..d8e4fd128ea6 100644
--- a/packages/eslint-plugin/src/rules/no-parameter-properties.ts
+++ b/packages/eslint-plugin/src/rules/no-parameter-properties.ts
@@ -84,7 +84,7 @@ export default util.createRule<Options, MessageIds>({
     }
 
     return {
-      TSParameterProperty(node: TSESTree.TSParameterProperty) {
+      TSParameterProperty(node) {
         const modifiers = getModifiers(node);
 
         if (allows.indexOf(modifiers) === -1) {
diff --git a/packages/eslint-plugin/src/rules/no-require-imports.ts b/packages/eslint-plugin/src/rules/no-require-imports.ts
index 0985c6a91f45..2fae56737cbe 100644
--- a/packages/eslint-plugin/src/rules/no-require-imports.ts
+++ b/packages/eslint-plugin/src/rules/no-require-imports.ts
@@ -30,7 +30,7 @@ export default util.createRule({
           messageId: 'noRequireImports'
         });
       },
-      TSExternalModuleReference(node: TSESTree.TSExternalModuleReference) {
+      TSExternalModuleReference(node) {
         context.report({
           node,
           messageId: 'noRequireImports'
diff --git a/packages/eslint-plugin/src/rules/no-triple-slash-reference.ts b/packages/eslint-plugin/src/rules/no-triple-slash-reference.ts
index 9691edb201ed..9a16b8852e32 100644
--- a/packages/eslint-plugin/src/rules/no-triple-slash-reference.ts
+++ b/packages/eslint-plugin/src/rules/no-triple-slash-reference.ts
@@ -3,7 +3,6 @@
  * @author Danny Fritz
  */
 
-import { TSESTree } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
 export default util.createRule({
@@ -27,7 +26,7 @@ export default util.createRule({
     const sourceCode = context.getSourceCode();
 
     return {
-      Program(program: TSESTree.Program): void {
+      Program(program): void {
         const commentsBefore = sourceCode.getCommentsBefore(program);
 
         commentsBefore.forEach(comment => {
diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
index d73d436a0022..904e9f7c68f3 100644
--- a/packages/eslint-plugin/src/rules/no-type-alias.ts
+++ b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -290,7 +290,7 @@ export default util.createRule<Options, MessageIds>({
     }
 
     return {
-      TSTypeAliasDeclaration(node: TSESTree.TSTypeAliasDeclaration) {
+      TSTypeAliasDeclaration(node) {
         if (isComposition(node.typeAnnotation)) {
           validateCompositions(node.typeAnnotation);
         } else {
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
index 98dcf3f05979..39095113f0e7 100644
--- a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
+++ b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -158,13 +158,13 @@ export default util.createRule<Options, MessageIds>({
     const checker = parserServices.program.getTypeChecker();
 
     return {
-      TSNonNullExpression(node: TSESTree.TSNonNullExpression) {
+      TSNonNullExpression(node) {
         checkNonNullAssertion(node, checker);
       },
-      TSTypeAssertion(node: TSESTree.TSTypeAssertion) {
+      TSTypeAssertion(node) {
         verifyCast(node, checker);
       },
-      TSAsExpression(node: TSESTree.TSAsExpression) {
+      TSAsExpression(node) {
         verifyCast(node, checker);
       }
     };
diff --git a/packages/eslint-plugin/src/rules/no-useless-constructor.ts b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
index 944ad6ff0c68..f8398c69df43 100644
--- a/packages/eslint-plugin/src/rules/no-useless-constructor.ts
+++ b/packages/eslint-plugin/src/rules/no-useless-constructor.ts
@@ -61,7 +61,7 @@ export default util.createRule<Options, MessageIds>({
   create(context) {
     const rules = baseRule.create(context);
     return {
-      MethodDefinition(node: TSESTree.MethodDefinition) {
+      MethodDefinition(node) {
         if (
           node.value &&
           node.value.type === AST_NODE_TYPES.FunctionExpression &&
diff --git a/packages/eslint-plugin/src/rules/no-var-requires.ts b/packages/eslint-plugin/src/rules/no-var-requires.ts
index 243bfcd4640d..2d28bc12af64 100644
--- a/packages/eslint-plugin/src/rules/no-var-requires.ts
+++ b/packages/eslint-plugin/src/rules/no-var-requires.ts
@@ -3,7 +3,7 @@
  * @author Macklin Underdown
  */
 
-import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/typescript-estree';
+import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
 type Options = [];
@@ -28,7 +28,7 @@ export default util.createRule<Options, MessageIds>({
   defaultOptions: [],
   create(context) {
     return {
-      CallExpression(node: TSESTree.CallExpression) {
+      CallExpression(node) {
         if (
           node.callee.type === AST_NODE_TYPES.Identifier &&
           node.callee.name === 'require' &&
diff --git a/packages/eslint-plugin/src/rules/prefer-function-type.ts b/packages/eslint-plugin/src/rules/prefer-function-type.ts
index 71bd2a880977..61519e47cd85 100644
--- a/packages/eslint-plugin/src/rules/prefer-function-type.ts
+++ b/packages/eslint-plugin/src/rules/prefer-function-type.ts
@@ -147,7 +147,7 @@ export default util.createRule({
     }
 
     return {
-      TSInterfaceDeclaration(node: TSESTree.TSInterfaceDeclaration) {
+      TSInterfaceDeclaration(node) {
         if (!hasOneSupertype(node) && node.body.body.length === 1) {
           checkMember(node.body.body[0], node);
         }
diff --git a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
index 83b668a1b8da..3170b4840ebe 100644
--- a/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
+++ b/packages/eslint-plugin/src/rules/prefer-namespace-keyword.ts
@@ -6,8 +6,7 @@
 
 import {
   AST_NODE_TYPES,
-  AST_TOKEN_TYPES,
-  TSESTree
+  AST_TOKEN_TYPES
 } from '@typescript-eslint/typescript-estree';
 import * as util from '../util';
 
@@ -34,7 +33,7 @@ export default util.createRule({
     const sourceCode = context.getSourceCode();
 
     return {
-      TSModuleDeclaration(node: TSESTree.TSModuleDeclaration) {
+      TSModuleDeclaration(node) {
         // Do nothing if the name is a string.
         if (!node.id || node.id.type === AST_NODE_TYPES.Literal) {
           return;
diff --git a/packages/eslint-plugin/src/rules/type-annotation-spacing.ts b/packages/eslint-plugin/src/rules/type-annotation-spacing.ts
index 391f6523095f..2e237a6db625 100644
--- a/packages/eslint-plugin/src/rules/type-annotation-spacing.ts
+++ b/packages/eslint-plugin/src/rules/type-annotation-spacing.ts
@@ -192,12 +192,12 @@ export default util.createRule<Options, MessageIds>({
     }
 
     return {
-      TSMappedType(node: TSESTree.TSMappedType) {
+      TSMappedType(node) {
         if (node.typeAnnotation) {
           checkTypeAnnotationSpacing(node.typeAnnotation);
         }
       },
-      TSTypeAnnotation(node: TSESTree.TSTypeAnnotation) {
+      TSTypeAnnotation(node) {
         checkTypeAnnotationSpacing(node.typeAnnotation);
       }
     };
diff --git a/packages/eslint-plugin/typings/ts-eslint.d.ts b/packages/eslint-plugin/typings/ts-eslint.d.ts
index 9ab6ff35e213..0b10e4754db2 100644
--- a/packages/eslint-plugin/typings/ts-eslint.d.ts
+++ b/packages/eslint-plugin/typings/ts-eslint.d.ts
@@ -10,7 +10,7 @@ The def is wrapped up in a fake module so that it can be used in eslint-rules.d.
 declare module 'ts-eslint' {
   import { TSESTree } from '@typescript-eslint/typescript-estree';
   import { ParserServices } from '@typescript-eslint/parser';
-  import { AST, Linter } from 'eslint';
+  import { AST, Linter, Rule } from 'eslint';
   import { JSONSchema4 } from 'json-schema';
 
   //#region SourceCode
@@ -397,8 +397,160 @@ declare module 'ts-eslint' {
 
   // This isn't the correct signature, but it makes it easier to do custom unions within reusable listneers
   // never will break someone's code unless they specifically type the function argument
-  type RuleFunction = (node: never) => void;
-  type RuleListener = Record<string, RuleFunction>;
+  type RuleFunction<T extends TSESTree.BaseNode = never> = (node: T) => void;
+
+  interface RuleListener {
+    [nodeSelector: string]: RuleFunction | undefined;
+    ArrayExpression?: RuleFunction<TSESTree.ArrayExpression>;
+    ArrayPattern?: RuleFunction<TSESTree.ArrayPattern>;
+    ArrowFunctionExpression?: RuleFunction<TSESTree.ArrowFunctionExpression>;
+    AssignmentPattern?: RuleFunction<TSESTree.AssignmentPattern>;
+    AwaitExpression?: RuleFunction<TSESTree.AwaitExpression>;
+    BlockStatement?: RuleFunction<TSESTree.BlockStatement>;
+    BreakStatement?: RuleFunction<TSESTree.BreakStatement>;
+    CallExpression?: RuleFunction<TSESTree.CallExpression>;
+    CatchClause?: RuleFunction<TSESTree.CatchClause>;
+    ClassBody?: RuleFunction<TSESTree.ClassBody>;
+    ClassDeclaration?: RuleFunction<TSESTree.ClassDeclaration>;
+    ClassExpression?: RuleFunction<TSESTree.ClassExpression>;
+    Comment?: RuleFunction<TSESTree.Comment>;
+    ConditionalExpression?: RuleFunction<TSESTree.ConditionalExpression>;
+    ContinueStatement?: RuleFunction<TSESTree.ContinueStatement>;
+    DebuggerStatement?: RuleFunction<TSESTree.DebuggerStatement>;
+    Decorator?: RuleFunction<TSESTree.Decorator>;
+    DoWhileStatement?: RuleFunction<TSESTree.DoWhileStatement>;
+    EmptyStatement?: RuleFunction<TSESTree.EmptyStatement>;
+    ExportAllDeclaration?: RuleFunction<TSESTree.ExportAllDeclaration>;
+    ExportDefaultDeclaration?: RuleFunction<TSESTree.ExportDefaultDeclaration>;
+    ExportNamedDeclaration?: RuleFunction<TSESTree.ExportNamedDeclaration>;
+    ExportSpecifier?: RuleFunction<TSESTree.ExportSpecifier>;
+    ExpressionStatement?: RuleFunction<TSESTree.ExpressionStatement>;
+    ForInStatement?: RuleFunction<TSESTree.ForInStatement>;
+    ForOfStatement?: RuleFunction<TSESTree.ForOfStatement>;
+    ForStatement?: RuleFunction<TSESTree.ForStatement>;
+    Identifier?: RuleFunction<TSESTree.Identifier>;
+    IfStatement?: RuleFunction<TSESTree.IfStatement>;
+    Import?: RuleFunction<TSESTree.Import>;
+    ImportDeclaration?: RuleFunction<TSESTree.ImportDeclaration>;
+    ImportDefaultSpecifier?: RuleFunction<TSESTree.ImportDefaultSpecifier>;
+    ImportNamespaceSpecifier?: RuleFunction<TSESTree.ImportNamespaceSpecifier>;
+    ImportSpecifier?: RuleFunction<TSESTree.ImportSpecifier>;
+    JSXAttribute?: RuleFunction<TSESTree.JSXAttribute>;
+    JSXClosingElement?: RuleFunction<TSESTree.JSXClosingElement>;
+    JSXClosingFragment?: RuleFunction<TSESTree.JSXClosingFragment>;
+    JSXElement?: RuleFunction<TSESTree.JSXElement>;
+    JSXEmptyExpression?: RuleFunction<TSESTree.JSXEmptyExpression>;
+    JSXExpressionContainer?: RuleFunction<TSESTree.JSXExpressionContainer>;
+    JSXFragment?: RuleFunction<TSESTree.JSXFragment>;
+    JSXIdentifier?: RuleFunction<TSESTree.JSXIdentifier>;
+    JSXMemberExpression?: RuleFunction<TSESTree.JSXMemberExpression>;
+    JSXOpeningElement?: RuleFunction<TSESTree.JSXOpeningElement>;
+    JSXOpeningFragment?: RuleFunction<TSESTree.JSXOpeningFragment>;
+    JSXSpreadAttribute?: RuleFunction<TSESTree.JSXSpreadAttribute>;
+    JSXSpreadChild?: RuleFunction<TSESTree.JSXSpreadChild>;
+    JSXText?: RuleFunction<TSESTree.JSXText>;
+    LabeledStatement?: RuleFunction<TSESTree.LabeledStatement>;
+    MemberExpression?: RuleFunction<TSESTree.MemberExpression>;
+    MetaProperty?: RuleFunction<TSESTree.MetaProperty>;
+    MethodDefinition?: RuleFunction<TSESTree.MethodDefinition>;
+    NewExpression?: RuleFunction<TSESTree.NewExpression>;
+    ObjectExpression?: RuleFunction<TSESTree.ObjectExpression>;
+    ObjectPattern?: RuleFunction<TSESTree.ObjectPattern>;
+    Program?: RuleFunction<TSESTree.Program>;
+    Property?: RuleFunction<TSESTree.Property>;
+    RestElement?: RuleFunction<TSESTree.RestElement>;
+    ReturnStatement?: RuleFunction<TSESTree.ReturnStatement>;
+    SequenceExpression?: RuleFunction<TSESTree.SequenceExpression>;
+    SpreadElement?: RuleFunction<TSESTree.SpreadElement>;
+    Super?: RuleFunction<TSESTree.Super>;
+    SwitchCase?: RuleFunction<TSESTree.SwitchCase>;
+    SwitchStatement?: RuleFunction<TSESTree.SwitchStatement>;
+    TaggedTemplateExpression?: RuleFunction<TSESTree.TaggedTemplateExpression>;
+    TemplateElement?: RuleFunction<TSESTree.TemplateElement>;
+    TemplateLiteral?: RuleFunction<TSESTree.TemplateLiteral>;
+    ThisExpression?: RuleFunction<TSESTree.ThisExpression>;
+    ThrowStatement?: RuleFunction<TSESTree.ThrowStatement>;
+    Token?: RuleFunction<TSESTree.Token>;
+    TryStatement?: RuleFunction<TSESTree.TryStatement>;
+    TSAbstractKeyword?: RuleFunction<TSESTree.TSAbstractKeyword>;
+    TSAnyKeyword?: RuleFunction<TSESTree.TSAnyKeyword>;
+    TSArrayType?: RuleFunction<TSESTree.TSArrayType>;
+    TSAsExpression?: RuleFunction<TSESTree.TSAsExpression>;
+    TSAsyncKeyword?: RuleFunction<TSESTree.TSAsyncKeyword>;
+    TSBigIntKeyword?: RuleFunction<TSESTree.TSBigIntKeyword>;
+    TSBooleanKeyword?: RuleFunction<TSESTree.TSBooleanKeyword>;
+    TSConditionalType?: RuleFunction<TSESTree.TSConditionalType>;
+    TSDeclareKeyword?: RuleFunction<TSESTree.TSDeclareKeyword>;
+    TSEnumDeclaration?: RuleFunction<TSESTree.TSEnumDeclaration>;
+    TSEnumMember?: RuleFunction<TSESTree.TSEnumMember>;
+    TSExportAssignment?: RuleFunction<TSESTree.TSExportAssignment>;
+    TSExportKeyword?: RuleFunction<TSESTree.TSExportKeyword>;
+    TSExternalModuleReference?: RuleFunction<
+      TSESTree.TSExternalModuleReference
+    >;
+    TSImportEqualsDeclaration?: RuleFunction<
+      TSESTree.TSImportEqualsDeclaration
+    >;
+    TSImportType?: RuleFunction<TSESTree.TSImportType>;
+    TSIndexedAccessType?: RuleFunction<TSESTree.TSIndexedAccessType>;
+    TSIndexSignature?: RuleFunction<TSESTree.TSIndexSignature>;
+    TSInferType?: RuleFunction<TSESTree.TSInferType>;
+    TSInterfaceBody?: RuleFunction<TSESTree.TSInterfaceBody>;
+    TSInterfaceDeclaration?: RuleFunction<TSESTree.TSInterfaceDeclaration>;
+    TSIntersectionType?: RuleFunction<TSESTree.TSIntersectionType>;
+    TSLiteralType?: RuleFunction<TSESTree.TSLiteralType>;
+    TSMappedType?: RuleFunction<TSESTree.TSMappedType>;
+    TSMethodSignature?: RuleFunction<TSESTree.TSMethodSignature>;
+    TSModuleBlock?: RuleFunction<TSESTree.TSModuleBlock>;
+    TSModuleDeclaration?: RuleFunction<TSESTree.TSModuleDeclaration>;
+    TSNamespaceExportDeclaration?: RuleFunction<
+      TSESTree.TSNamespaceExportDeclaration
+    >;
+    TSNeverKeyword?: RuleFunction<TSESTree.TSNeverKeyword>;
+    TSNonNullExpression?: RuleFunction<TSESTree.TSNonNullExpression>;
+    TSNullKeyword?: RuleFunction<TSESTree.TSNullKeyword>;
+    TSNumberKeyword?: RuleFunction<TSESTree.TSNumberKeyword>;
+    TSObjectKeyword?: RuleFunction<TSESTree.TSObjectKeyword>;
+    TSOptionalType?: RuleFunction<TSESTree.TSOptionalType>;
+    TSParameterProperty?: RuleFunction<TSESTree.TSParameterProperty>;
+    TSParenthesizedType?: RuleFunction<TSESTree.TSParenthesizedType>;
+    TSPrivateKeyword?: RuleFunction<TSESTree.TSPrivateKeyword>;
+    TSPropertySignature?: RuleFunction<TSESTree.TSPropertySignature>;
+    TSProtectedKeyword?: RuleFunction<TSESTree.TSProtectedKeyword>;
+    TSPublicKeyword?: RuleFunction<TSESTree.TSPublicKeyword>;
+    TSQualifiedName?: RuleFunction<TSESTree.TSQualifiedName>;
+    TSReadonlyKeyword?: RuleFunction<TSESTree.TSReadonlyKeyword>;
+    TSRestType?: RuleFunction<TSESTree.TSRestType>;
+    TSStaticKeyword?: RuleFunction<TSESTree.TSStaticKeyword>;
+    TSStringKeyword?: RuleFunction<TSESTree.TSStringKeyword>;
+    TSSymbolKeyword?: RuleFunction<TSESTree.TSSymbolKeyword>;
+    TSThisType?: RuleFunction<TSESTree.TSThisType>;
+    TSTupleType?: RuleFunction<TSESTree.TSTupleType>;
+    TSTypeAliasDeclaration?: RuleFunction<TSESTree.TSTypeAliasDeclaration>;
+    TSTypeAnnotation?: RuleFunction<TSESTree.TSTypeAnnotation>;
+    TSTypeAssertion?: RuleFunction<TSESTree.TSTypeAssertion>;
+    TSTypeLiteral?: RuleFunction<TSESTree.TSTypeLiteral>;
+    TSTypeOperator?: RuleFunction<TSESTree.TSTypeOperator>;
+    TSTypeParameter?: RuleFunction<TSESTree.TSTypeParameter>;
+    TSTypeParameterDeclaration?: RuleFunction<
+      TSESTree.TSTypeParameterDeclaration
+    >;
+    TSTypeParameterInstantiation?: RuleFunction<
+      TSESTree.TSTypeParameterInstantiation
+    >;
+    TSTypePredicate?: RuleFunction<TSESTree.TSTypePredicate>;
+    TSTypeQuery?: RuleFunction<TSESTree.TSTypeQuery>;
+    TSTypeReference?: RuleFunction<TSESTree.TSTypeReference>;
+    TSUndefinedKeyword?: RuleFunction<TSESTree.TSUndefinedKeyword>;
+    TSUnionType?: RuleFunction<TSESTree.TSUnionType>;
+    TSUnknownKeyword?: RuleFunction<TSESTree.TSUnknownKeyword>;
+    TSVoidKeyword?: RuleFunction<TSESTree.TSVoidKeyword>;
+    VariableDeclaration?: RuleFunction<TSESTree.VariableDeclaration>;
+    VariableDeclarator?: RuleFunction<TSESTree.VariableDeclarator>;
+    WhileStatement?: RuleFunction<TSESTree.WhileStatement>;
+    WithStatement?: RuleFunction<TSESTree.WithStatement>;
+    YieldExpression?: RuleFunction<TSESTree.YieldExpression>;
+  }
 
   interface RuleModule<
     TMessageIds extends string,