@eslint-react/jsx 0.8.6-beta.0 → 0.8.6-beta.3

package/node_modules/@eslint-react/ast/dist/index.d.ts

@@ -0,0 +1,1185 @@
+import { Data, O, Narrow } from '@eslint-react/tools';
+import { RuleContext } from '@eslint-react/types';
+import TSESLintScopeManager, { Scope, Variable, Definition } from '@typescript-eslint/scope-manager';
+import { TSESTree, AST_NODE_TYPES } from '@typescript-eslint/types';
+import { TSESLint, TSESTree as TSESTree$1 } from '@typescript-eslint/utils';
+
+type Construction = Data.TaggedEnum<{
+    None: {};
+    Array: {
+        node: TSESTree.ArrayExpression;
+        usage: O.Option<TSESTree.Node>;
+    };
+    AssignmentExpression: {
+        node: TSESTree.Node;
+        usage: O.Option<TSESTree.Node>;
+    };
+    ClassExpression: {
+        node: TSESTree.ClassExpression;
+        usage: O.Option<TSESTree.Node>;
+    };
+    FunctionDeclaration: {
+        node: TSESTree.FunctionDeclaration;
+        usage: O.Option<TSESTree.Expression | TSESTree.Identifier>;
+    };
+    FunctionExpression: {
+        node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
+        usage: O.Option<TSESTree.Node>;
+    };
+    JSXElement: {
+        node: TSESTree.JSXElement;
+        usage: O.Option<TSESTree.Node>;
+    };
+    JSXFragment: {
+        node: TSESTree.JSXFragment;
+        usage: O.Option<TSESTree.Node>;
+    };
+    NewExpression: {
+        node: TSESTree.NewExpression;
+        usage: O.Option<TSESTree.Node>;
+    };
+    ObjectExpression: {
+        node: TSESTree.ObjectExpression;
+        usage: O.Option<TSESTree.Node>;
+    };
+    RegExpLiteral: {
+        node: TSESTree.Literal;
+        usage: O.Option<TSESTree.Node>;
+    };
+}>;
+declare const Construction: {
+    readonly None: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "None";
+    }>, "_tag">;
+    readonly Array: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "Array";
+        readonly node: TSESTree.ArrayExpression;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+    readonly AssignmentExpression: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "AssignmentExpression";
+        readonly node: TSESTree.Node;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+    readonly ClassExpression: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "ClassExpression";
+        readonly node: TSESTree.ClassExpression;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+    readonly FunctionDeclaration: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "FunctionDeclaration";
+        readonly node: TSESTree.FunctionDeclaration;
+        readonly usage: O.Option<TSESTree.Expression | TSESTree.Identifier>;
+    }>, "_tag">;
+    readonly FunctionExpression: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "FunctionExpression";
+        readonly node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+    readonly JSXElement: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "JSXElement";
+        readonly node: TSESTree.JSXElement;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+    readonly JSXFragment: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "JSXFragment";
+        readonly node: TSESTree.JSXFragment;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+    readonly NewExpression: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "NewExpression";
+        readonly node: TSESTree.NewExpression;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+    readonly ObjectExpression: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "ObjectExpression";
+        readonly node: TSESTree.ObjectExpression;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+    readonly RegExpLiteral: Data.Case.Constructor<Data.Data<{
+        readonly _tag: "RegExpLiteral";
+        readonly node: TSESTree.Literal;
+        readonly usage: O.Option<TSESTree.Node>;
+    }>, "_tag">;
+};
+/**
+ * Get a function that detects the construction of a given node.
+ * @param context The rule context
+ * @returns A function that detects the construction of a given node
+ */
+declare function constructionDetector<T extends RuleContext>(context: T): (node: TSESTree.Node, scope: Scope) => Construction;
+
+declare const unstableAssignmentPatternTypes: readonly [TSESTree.AST_NODE_TYPES.JSXElement, TSESTree.AST_NODE_TYPES.ArrayExpression, TSESTree.AST_NODE_TYPES.ObjectExpression, TSESTree.AST_NODE_TYPES.FunctionExpression, TSESTree.AST_NODE_TYPES.ArrowFunctionExpression, TSESTree.AST_NODE_TYPES.ClassExpression, TSESTree.AST_NODE_TYPES.NewExpression, TSESTree.AST_NODE_TYPES.CallExpression];
+/**
+ * Check if the given node is an unstable assignment pattern (will change between assignments)
+ * @param node The AST node to check
+ * @param node.right The right side of the assignment
+ */
+declare function isUnstableAssignmentPattern(node: TSESTree.AssignmentPattern): node is TSESTree.AssignmentPattern & Narrow<{
+    right: TSESTree.RegExpLiteral | typeof unstableAssignmentPatternTypes[number];
+}>;
+
+/**
+ * Get the proper location of a given function node to report.
+ * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionheadlocation}
+ */
+declare const getFunctionHeadLocation: (node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression, sourceCode: TSESLint.SourceCode) => TSESTree.SourceLocation;
+/**
+ * Get the name and kind of a given function node.
+ * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getfunctionnamewithkind}
+ */
+declare const getFunctionNameWithKind: (node: TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration | TSESTree.FunctionExpression, sourceCode?: TSESLint.SourceCode) => string;
+/**
+ * Get the property name of a given property node.
+ * If the node is a computed property, this tries to compute the property name by the getStringIfConstant function.
+ * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getpropertyname}
+ * @returns The property name of the node. If the property name is not constant then it returns `null`.
+ */
+declare const getPropertyName: (node: TSESTree.MemberExpression | TSESTree.MethodDefinition | TSESTree.Property | TSESTree.PropertyDefinition, initialScope?: TSESLint.Scope.Scope) => null | string;
+/**
+ * Get the value of a given node if it can decide the value statically.
+ * If the 2nd parameter `initialScope` was given, this function tries to resolve identifier references which are in the
+ * given node as much as possible. In the resolving way, it does on the assumption that built-in global objects have
+ * not been modified.
+ * For example, it considers `Symbol.iterator`, ` String.raw``hello`` `, and `Object.freeze({a: 1}).a` as static.
+ * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstaticvalue}
+ * @returns The `{ value: any }` shaped object. The `value` property is the static value. If it couldn't compute the
+ * static value of the node, it returns `null`.
+ */
+declare const getStaticValue: (node: TSESTree.Node, initialScope?: TSESLint.Scope.Scope) => {
+    value: unknown;
+} | null;
+/**
+ * Get the string value of a given node.
+ * This function is a tiny wrapper of the getStaticValue function.
+ * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#getstringifconstant}
+ */
+declare const getStringIfConstant: (node: TSESTree.Node, initialScope?: TSESLint.Scope.Scope) => null | string;
+/**
+ * Check whether a given node has any side effect or not.
+ * The side effect means that it may modify a certain variable or object member. This function considers the node which
+ * contains the following types as the node which has side effects:
+ * - `AssignmentExpression`
+ * - `AwaitExpression`
+ * - `CallExpression`
+ * - `ImportExpression`
+ * - `NewExpression`
+ * - `UnaryExpression([operator = "delete"])`
+ * - `UpdateExpression`
+ * - `YieldExpression`
+ * - When `options.considerGetters` is `true`:
+ * - `MemberExpression`
+ * - When `options.considerImplicitTypeConversion` is `true`:
+ * - `BinaryExpression([operator = "==" | "!=" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "in"])`
+ * - `MemberExpression([computed = true])`
+ * - `MethodDefinition([computed = true])`
+ * - `Property([computed = true])`
+ * - `UnaryExpression([operator = "-" | "+" | "!" | "~"])`
+ * @see {@link https://eslint-community.github.io/eslint-utils/api/ast-utils.html#hassideeffect}
+ */
+declare const hasSideEffect: (node: TSESTree.Node, sourceCode: TSESLint.SourceCode, options?: {
+    considerGetters?: boolean;
+    considerImplicitTypeConversion?: boolean;
+}) => boolean;
+declare const isParenthesized: {
+    (node: TSESTree.Node, sourceCode: TSESLint.SourceCode): boolean;
+    (times: number, node: TSESTree.Node, sourceCode: TSESLint.SourceCode): boolean;
+};
+
+/**
+ * Gets nested identifiers in a node
+ * @param node The AST node
+ * @returns The nested identifiers
+ */
+declare function getNestedIdentifiers(node: TSESTree.Node): TSESTree.Identifier[];
+
+/**
+ * Gets nested return statements in a node
+ * @param node The AST node
+ * @returns The nested return statements
+ */
+declare function getNestedReturnStatements(node: TSESTree.Node): TSESTree.ReturnStatement[];
+
+/**
+ * Checks if the given node is a function expression or arrow function expression of a object method.
+ * @param node The node to check.
+ * @returns `true` if the node is a function expression or arrow function expression of a object method, `false` otherwise.
+ */
+declare const isFunctionOfObjectMethod: (node: TSESTree.Node) => boolean;
+/**
+ * Checks if the given node is a function expression or arrow function expression of a class method.
+ * @param node The node to check.
+ * @returns `true` if the node is a function expression or arrow function expression of a class method, `false` otherwise.
+ */
+declare const isFunctionOfClassMethod: (node: TSESTree.Node) => boolean;
+/**
+ * Checks if the given node is a function expression or arrow function expression of a class property.
+ * @param node The node to check.
+ * @returns `true` if the node is a function expression or arrow function expression of a class property, `false` otherwise.
+ */
+declare const isFunctionOfClassProperty: (node: TSESTree.Node) => boolean;
+
+declare const NodeType: typeof AST_NODE_TYPES;
+
+type TSESTreeFunction = TSESTree$1.ArrowFunctionExpression | TSESTree$1.FunctionDeclaration | TSESTree$1.FunctionExpression;
+type TSESTreeFunctionType = TSESTree$1.TSCallSignatureDeclaration | TSESTree$1.TSConstructSignatureDeclaration | TSESTree$1.TSDeclareFunction | TSESTree$1.TSEmptyBodyFunctionExpression | TSESTree$1.TSFunctionType | TSESTree$1.TSMethodSignature | TSESTreeFunction;
+type TSESTreeClass = TSESTree$1.ClassDeclaration | TSESTree$1.ClassExpression;
+type TSESTreeLoop = TSESTree$1.DoWhileStatement | TSESTree$1.ForInStatement | TSESTree$1.ForOfStatement | TSESTree$1.ForStatement | TSESTree$1.WhileStatement;
+type TSESTreeArrayTupleType = TSESTree$1.TSArrayType | TSESTree$1.TSTupleType;
+type TSESTreeProperty = TSESTree$1.PropertyDefinition | TSESTree$1.TSIndexSignature | TSESTree$1.TSParameterProperty | TSESTree$1.TSPropertySignature;
+type TSESTreeJSX = TSESTree$1.JSXAttribute | TSESTree$1.JSXChild | TSESTree$1.JSXClosingElement | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXElement | TSESTree$1.JSXEmptyExpression | TSESTree$1.JSXExpression | TSESTree$1.JSXExpressionContainer | TSESTree$1.JSXFragment | TSESTree$1.JSXIdentifier | TSESTree$1.JSXIdentifierToken | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXNamespacedName | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXSpreadAttribute | TSESTree$1.JSXSpreadChild | TSESTree$1.JSXTagNameExpression | TSESTree$1.JSXText | TSESTree$1.JSXTextToken;
+type TSESTreeDestructuringPattern = TSESTree$1.ArrayPattern | TSESTree$1.AssignmentPattern | TSESTree$1.ObjectPattern | TSESTree$1.RestElement;
+type TSESTreeTypeDeclaration = TSESTree$1.TSInterfaceDeclaration | TSESTree$1.TSTypeAliasDeclaration;
+declare const is: <NodeType extends AST_NODE_TYPES>(nodeType: NodeType) => (node: TSESTree$1.Node | null | undefined) => node is Extract<TSESTree$1.AccessorPropertyComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.AccessorPropertyNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ArrayExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ArrayPattern, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ArrowFunctionExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.AssignmentExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.AssignmentPattern, {
+    type: NodeType;
+}> | Extract<TSESTree$1.AwaitExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.BinaryExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.BlockStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.BreakStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.CallExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.CatchClause, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ChainExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ClassBody, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ClassDeclarationWithName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ClassDeclarationWithOptionalName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ClassExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ConditionalExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ContinueStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.DebuggerStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.Decorator, {
+    type: NodeType;
+}> | Extract<TSESTree$1.DoWhileStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.EmptyStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ExportAllDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ExportDefaultDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ExportNamedDeclarationWithoutSourceWithMultiple, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ExportNamedDeclarationWithoutSourceWithSingle, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ExportNamedDeclarationWithSource, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ExportSpecifier, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ExpressionStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ForInStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ForOfStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ForStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.FunctionDeclarationWithName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.FunctionDeclarationWithOptionalName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.FunctionExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.Identifier, {
+    type: NodeType;
+}> | Extract<TSESTree$1.IfStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ImportAttribute, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ImportDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ImportDefaultSpecifier, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ImportExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ImportNamespaceSpecifier, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ImportSpecifier, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXAttribute, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXClosingElement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXClosingFragment, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXElement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXEmptyExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXExpressionContainer, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXFragment, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXIdentifier, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXMemberExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXNamespacedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXOpeningElement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXOpeningFragment, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXSpreadAttribute, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXSpreadChild, {
+    type: NodeType;
+}> | Extract<TSESTree$1.JSXText, {
+    type: NodeType;
+}> | Extract<TSESTree$1.LabeledStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.BigIntLiteral, {
+    type: NodeType;
+}> | Extract<TSESTree$1.BooleanLiteral, {
+    type: NodeType;
+}> | Extract<TSESTree$1.NullLiteral, {
+    type: NodeType;
+}> | Extract<TSESTree$1.NumberLiteral, {
+    type: NodeType;
+}> | Extract<TSESTree$1.RegExpLiteral, {
+    type: NodeType;
+}> | Extract<TSESTree$1.StringLiteral, {
+    type: NodeType;
+}> | Extract<TSESTree$1.LogicalExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.MemberExpressionComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.MemberExpressionNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.MetaProperty, {
+    type: NodeType;
+}> | Extract<TSESTree$1.MethodDefinitionComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.MethodDefinitionNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.NewExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ObjectExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ObjectPattern, {
+    type: NodeType;
+}> | Extract<TSESTree$1.PrivateIdentifier, {
+    type: NodeType;
+}> | Extract<TSESTree$1.Program, {
+    type: NodeType;
+}> | Extract<TSESTree$1.PropertyComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.PropertyNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.PropertyDefinitionComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.PropertyDefinitionNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.RestElement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ReturnStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.SequenceExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.SpreadElement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.StaticBlock, {
+    type: NodeType;
+}> | Extract<TSESTree$1.Super, {
+    type: NodeType;
+}> | Extract<TSESTree$1.SwitchCase, {
+    type: NodeType;
+}> | Extract<TSESTree$1.SwitchStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TaggedTemplateExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TemplateElement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TemplateLiteral, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ThisExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.ThrowStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TryStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAbstractAccessorPropertyComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAbstractAccessorPropertyNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAbstractKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAbstractMethodDefinitionComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAbstractMethodDefinitionNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAbstractPropertyDefinitionComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAbstractPropertyDefinitionNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAnyKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSArrayType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAsExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSAsyncKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSBigIntKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSBooleanKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSCallSignatureDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSClassImplements, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSConditionalType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSConstructorType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSConstructSignatureDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSDeclareFunction, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSDeclareKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSEmptyBodyFunctionExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSEnumDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSEnumMemberComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSEnumMemberNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSExportAssignment, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSExportKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSExternalModuleReference, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSFunctionType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSImportEqualsDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSImportType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSIndexedAccessType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSIndexSignature, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSInferType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSInstantiationExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSInterfaceBody, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSInterfaceDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSInterfaceHeritage, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSIntersectionType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSIntrinsicKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSLiteralType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSMappedType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSMethodSignatureComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSMethodSignatureNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSModuleBlock, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSModuleDeclarationGlobal, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSModuleDeclarationModuleWithIdentifierId, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSModuleDeclarationModuleWithStringIdDeclared, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSModuleDeclarationModuleWithStringIdNotDeclared, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSModuleDeclarationNamespace, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSNamedTupleMember, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSNamespaceExportDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSNeverKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSNonNullExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSNullKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSNumberKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSObjectKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSOptionalType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSParameterProperty, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSPrivateKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSPropertySignatureComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSPropertySignatureNonComputedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSProtectedKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSPublicKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSQualifiedName, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSReadonlyKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSRestType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSSatisfiesExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSStaticKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSStringKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSSymbolKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTemplateLiteralType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSThisType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTupleType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeAliasDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeAnnotation, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeAssertion, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeLiteral, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeOperator, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeParameter, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeParameterDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeParameterInstantiation, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypePredicate, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeQuery, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSTypeReference, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSUndefinedKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSUnionType, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSUnknownKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.TSVoidKeyword, {
+    type: NodeType;
+}> | Extract<TSESTree$1.UnaryExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.UpdateExpression, {
+    type: NodeType;
+}> | Extract<TSESTree$1.LetOrConstOrVarDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.UsingInForOfDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.UsingInNomalConextDeclaration, {
+    type: NodeType;
+}> | Extract<TSESTree$1.LetOrConstOrVarDeclarator, {
+    type: NodeType;
+}> | Extract<TSESTree$1.UsingInForOfDeclarator, {
+    type: NodeType;
+}> | Extract<TSESTree$1.UsingInNomalConextDeclarator, {
+    type: NodeType;
+}> | Extract<TSESTree$1.WhileStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.WithStatement, {
+    type: NodeType;
+}> | Extract<TSESTree$1.YieldExpression, {
+    type: NodeType;
+}>;
+declare const isOneOf: <NodeTypes extends readonly AST_NODE_TYPES[]>(nodeTypes: NodeTypes) => (node: TSESTree$1.Node | null | undefined) => node is Extract<TSESTree$1.AccessorPropertyComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.AccessorPropertyNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ArrayExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ArrayPattern, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ArrowFunctionExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.AssignmentExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.AssignmentPattern, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.AwaitExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.BinaryExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.BlockStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.BreakStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.CallExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.CatchClause, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ChainExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ClassBody, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ClassDeclarationWithName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ClassDeclarationWithOptionalName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ClassExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ConditionalExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ContinueStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.DebuggerStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.Decorator, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.DoWhileStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.EmptyStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ExportAllDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ExportDefaultDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ExportNamedDeclarationWithoutSourceWithMultiple, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ExportNamedDeclarationWithoutSourceWithSingle, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ExportNamedDeclarationWithSource, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ExportSpecifier, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ExpressionStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ForInStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ForOfStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ForStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.FunctionDeclarationWithName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.FunctionDeclarationWithOptionalName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.FunctionExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.Identifier, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.IfStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ImportAttribute, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ImportDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ImportDefaultSpecifier, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ImportExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ImportNamespaceSpecifier, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ImportSpecifier, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXAttribute, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXClosingElement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXClosingFragment, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXElement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXEmptyExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXExpressionContainer, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXFragment, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXIdentifier, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXMemberExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXNamespacedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXOpeningElement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXOpeningFragment, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXSpreadAttribute, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXSpreadChild, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.JSXText, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.LabeledStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.BigIntLiteral, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.BooleanLiteral, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.NullLiteral, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.NumberLiteral, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.RegExpLiteral, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.StringLiteral, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.LogicalExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.MemberExpressionComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.MemberExpressionNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.MetaProperty, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.MethodDefinitionComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.MethodDefinitionNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.NewExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ObjectExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ObjectPattern, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.PrivateIdentifier, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.Program, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.PropertyComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.PropertyNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.PropertyDefinitionComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.PropertyDefinitionNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.RestElement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ReturnStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.SequenceExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.SpreadElement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.StaticBlock, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.Super, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.SwitchCase, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.SwitchStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TaggedTemplateExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TemplateElement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TemplateLiteral, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ThisExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.ThrowStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TryStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAbstractAccessorPropertyComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAbstractAccessorPropertyNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAbstractKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAbstractMethodDefinitionComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAbstractMethodDefinitionNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAbstractPropertyDefinitionComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAbstractPropertyDefinitionNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAnyKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSArrayType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAsExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSAsyncKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSBigIntKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSBooleanKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSCallSignatureDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSClassImplements, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSConditionalType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSConstructorType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSConstructSignatureDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSDeclareFunction, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSDeclareKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSEmptyBodyFunctionExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSEnumDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSEnumMemberComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSEnumMemberNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSExportAssignment, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSExportKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSExternalModuleReference, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSFunctionType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSImportEqualsDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSImportType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSIndexedAccessType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSIndexSignature, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSInferType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSInstantiationExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSInterfaceBody, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSInterfaceDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSInterfaceHeritage, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSIntersectionType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSIntrinsicKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSLiteralType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSMappedType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSMethodSignatureComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSMethodSignatureNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSModuleBlock, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSModuleDeclarationGlobal, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSModuleDeclarationModuleWithIdentifierId, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSModuleDeclarationModuleWithStringIdDeclared, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSModuleDeclarationModuleWithStringIdNotDeclared, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSModuleDeclarationNamespace, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSNamedTupleMember, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSNamespaceExportDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSNeverKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSNonNullExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSNullKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSNumberKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSObjectKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSOptionalType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSParameterProperty, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSPrivateKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSPropertySignatureComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSPropertySignatureNonComputedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSProtectedKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSPublicKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSQualifiedName, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSReadonlyKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSRestType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSSatisfiesExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSStaticKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSStringKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSSymbolKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTemplateLiteralType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSThisType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTupleType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeAliasDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeAnnotation, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeAssertion, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeLiteral, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeOperator, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeParameter, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeParameterDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeParameterInstantiation, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypePredicate, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeQuery, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSTypeReference, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSUndefinedKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSUnionType, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSUnknownKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.TSVoidKeyword, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.UnaryExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.UpdateExpression, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.LetOrConstOrVarDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.UsingInForOfDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.UsingInNomalConextDeclaration, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.LetOrConstOrVarDeclarator, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.UsingInForOfDeclarator, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.UsingInNomalConextDeclarator, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.WhileStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.WithStatement, {
+    type: NodeTypes[number];
+}> | Extract<TSESTree$1.YieldExpression, {
+    type: NodeTypes[number];
+}>;
+declare const isFunction: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.ArrowFunctionExpression | TSESTree$1.FunctionDeclarationWithName | TSESTree$1.FunctionDeclarationWithOptionalName | TSESTree$1.FunctionExpression;
+declare const isFunctionType: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.ArrowFunctionExpression | TSESTree$1.FunctionDeclarationWithName | TSESTree$1.FunctionDeclarationWithOptionalName | TSESTree$1.FunctionExpression | TSESTree$1.TSCallSignatureDeclaration | TSESTree$1.TSConstructSignatureDeclaration | TSESTree$1.TSDeclareFunction | TSESTree$1.TSEmptyBodyFunctionExpression | TSESTree$1.TSFunctionType | TSESTree$1.TSMethodSignatureComputedName | TSESTree$1.TSMethodSignatureNonComputedName;
+declare const isClass: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.ClassDeclarationWithName | TSESTree$1.ClassDeclarationWithOptionalName | TSESTree$1.ClassExpression;
+declare const isLoop: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.DoWhileStatement | TSESTree$1.ForInStatement | TSESTree$1.ForOfStatement | TSESTree$1.ForStatement | TSESTree$1.WhileStatement;
+declare const isArrayTupleType: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.TSArrayType | TSESTree$1.TSTupleType;
+declare const isProperty: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.PropertyDefinitionComputedName | TSESTree$1.PropertyDefinitionNonComputedName | TSESTree$1.TSIndexSignature | TSESTree$1.TSParameterProperty | TSESTree$1.TSPropertySignatureComputedName | TSESTree$1.TSPropertySignatureNonComputedName;
+declare const isJSXElement: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.JSXElement;
+declare const isJSXFragment: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.JSXFragment;
+declare const isJSX: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.JSXAttribute | TSESTree$1.JSXElement | TSESTree$1.JSXExpressionContainer | TSESTree$1.JSXSpreadChild | TSESTree$1.JSXFragment | TSESTree$1.JSXText | TSESTree$1.JSXClosingElement | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXEmptyExpression | TSESTree$1.JSXIdentifier | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXNamespacedName | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXSpreadAttribute;
+declare const isJSXTagNameExpression: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.JSXIdentifier | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXNamespacedName;
+declare const isDestructuringPattern: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.ArrayPattern | TSESTree$1.AssignmentPattern | TSESTree$1.ObjectPattern | TSESTree$1.RestElement;
+declare const isTypeDeclaration: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.TSInterfaceDeclaration | TSESTree$1.TSTypeAliasDeclaration;
+declare const isLeftHandSideExpression: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.ArrowFunctionExpression | TSESTree$1.FunctionExpression | TSESTree$1.ClassExpression | TSESTree$1.JSXElement | TSESTree$1.JSXFragment | TSESTree$1.ArrayPattern | TSESTree$1.ObjectPattern | TSESTree$1.ArrayExpression | TSESTree$1.CallExpression | TSESTree$1.Identifier | TSESTree$1.BigIntLiteral | TSESTree$1.BooleanLiteral | TSESTree$1.NullLiteral | TSESTree$1.NumberLiteral | TSESTree$1.RegExpLiteral | TSESTree$1.StringLiteral | TSESTree$1.MemberExpressionComputedName | TSESTree$1.MemberExpressionNonComputedName | TSESTree$1.MetaProperty | TSESTree$1.ObjectExpression | TSESTree$1.SequenceExpression | TSESTree$1.Super | TSESTree$1.TaggedTemplateExpression | TSESTree$1.TemplateLiteral | TSESTree$1.ThisExpression;
+declare const isLeftHandSideExpressionType: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.ArrowFunctionExpression | TSESTree$1.FunctionExpression | TSESTree$1.ClassExpression | TSESTree$1.JSXElement | TSESTree$1.JSXFragment | TSESTree$1.ArrayPattern | TSESTree$1.ObjectPattern | TSESTree$1.ArrayExpression | TSESTree$1.CallExpression | TSESTree$1.Identifier | TSESTree$1.BigIntLiteral | TSESTree$1.BooleanLiteral | TSESTree$1.NullLiteral | TSESTree$1.NumberLiteral | TSESTree$1.RegExpLiteral | TSESTree$1.StringLiteral | TSESTree$1.MemberExpressionComputedName | TSESTree$1.MemberExpressionNonComputedName | TSESTree$1.MetaProperty | TSESTree$1.ObjectExpression | TSESTree$1.SequenceExpression | TSESTree$1.Super | TSESTree$1.TaggedTemplateExpression | TSESTree$1.TemplateLiteral | TSESTree$1.ThisExpression | TSESTree$1.TSAsExpression | TSESTree$1.TSNonNullExpression | TSESTree$1.TSTypeAssertion;
+
+/**
+ * Checks if a node is an identifier with a given name
+ * @param node The AST node
+ * @param name The name
+ * @returns `true if the node is an identifier with the given name
+ */
+declare function isIdentifierWithName<const T extends string>(node: TSESTree.Node, name: T): node is TSESTree.Identifier & {
+    name: T;
+};
+/**
+ * Checks if a node is an identifier with one of names
+ * @param node The AST node
+ * @param name The name
+ * @returns `true` if the node is an identifier with one of names
+ */
+declare function isIdentifierWithOneOfNames<T extends string[]>(node: TSESTree.Node, name: T): node is TSESTree.Identifier & {
+    name: T[number];
+};
+/**
+ * Gets FunctionDeclaration's identifier or FunctionExpression's parent identifier if it exists
+ * @param node The AST node to check
+ * @returns function identifier or null
+ */
+declare function getFunctionIdentifier(node: TSESTreeFunction): TSESTree.Identifier | null;
+/**
+ * Gets class identifier from ClassDeclaration or ClassExpression
+ * @param node The AST node to check
+ * @returns class identifier or null
+ */
+declare function getClassIdentifier(node: TSESTreeClass): TSESTree.Identifier | null;
+
+/**
+ * Determines whether node equals to another node
+ * @param a node to compare
+ * @param b node to compare
+ * @returns `true` if node equal
+ * @see https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/util/isNodeEqual.ts
+ */
+declare function isNodeEqual(a: TSESTree.Node, b: TSESTree.Node): boolean;
+
+declare function isRegExpLiteral(node: TSESTree.Node): node is TSESTree.RegExpLiteral;
+declare function isStringLiteral(node: TSESTree.Node | null | undefined): node is TSESTree.StringLiteral;
+
+/**
+ * Check if a node is multiline
+ * @param node The AST node to check
+ * @returns  `true` if the node is multiline
+ */
+declare function isMultiLine(node: TSESTree.Node): boolean;
+declare function unsafeIsToStringCall(node: TSESTree.Node): node is TSESTree.CallExpression & {
+    callee: TSESTree.MemberExpression & {
+        property: TSESTree.Identifier & {
+            name: "toString";
+        };
+    };
+};
+declare function unsafeIsStringCall(node: TSESTree.Node): node is TSESTree.CallExpression & {
+    callee: TSESTree.Identifier & {
+        name: "String";
+    };
+};
+/**
+ * Unsafe check whether given node or its parent is directly inside `Array.from` call
+ * @param node The AST node to check
+ * @returns `true` if node is directly inside `Array.from` call, `false` if not
+ */
+declare function unsafeIsArrayFromCall(node: TSESTree.Node | null): node is TSESTree.CallExpression;
+/**
+ * Unsafe check whether given node or its parent is directly inside `map` call
+ * ```jsx
+ * _ = <div>{items.map(item => <li />)}</div>
+ * `                   ^^^^^^^^^^^^^^       `
+ * ```
+ * @param node The AST node to check
+ * @returns `true` if node is directly inside `map` call, `false` if not
+ */
+declare function unsafeIsMapCall(node: TSESTree.Node | null): node is TSESTree.CallExpression;
+
+declare function isPropertyOfObjectExpression(node: TSESTree.Node): node is TSESTree.Node & {
+    parent: TSESTree.Property;
+};
+declare function isPropertyWithIdentifierKey<const T extends string>(node: TSESTree.Node, key: T): node is TSESTree.Property & {
+    key: TSESTree.Identifier & {
+        name: T;
+    };
+};
+declare function findPropertyWithIdentifierKey(properties: TSESTree.ObjectLiteralElement[], key: string): TSESTree.ObjectLiteralElement | undefined;
+
+/**
+ * Returns human readable node type for given AST node
+ * @param node AST node
+ * @returns Human readable node type
+ */
+declare function readableNodeType(node: TSESTree.Node): "property" | "RegExp literal" | "Array literal" | "String literal" | "Object literal" | "Number literal" | "Boolean literal" | "Null literal" | "NaN literal" | "Function literal" | "Undefined literal" | "Async literal" | "Promise literal" | "Symbol literal" | "Set literal" | "Error literal" | "Map literal" | "WeakMap literal" | "Generator literal" | "GeneratorFunction literal" | "BigInt literal" | "ArrayBuffer literal" | "Date literal" | "identifier" | "member expression" | "JSX identifier" | "JSX attribute" | "JSX element" | "JSX fragment" | "JSX text" | "JSX member expression" | "JSX closing element" | "JSX closing fragment" | "JSX empty expression" | "JSX expression container" | "JSX namespaced name" | "JSX opening element" | "JSX opening fragment" | "JSX spread attribute" | "JSX spread child" | "decorator" | "program" | "super" | "accessor property" | "array expression" | "array pattern" | "function expression" | "arrow function expression" | "assignment expression" | "assignment pattern" | "await expression" | "binary expression" | "block statement" | "break statement" | "call expression" | "catch clause" | "chain expression" | "class body" | "class declaration" | "class expression" | "conditional expression" | "continue statement" | "debugger statement" | "while statement" | "do while statement" | "empty statement" | "export all declaration" | "export default declaration" | "export named declaration" | "export specifier" | "expression statement" | "for in statement" | "for of statement" | "for statement" | "function declaration" | "if statement" | "import attribute" | "import declaration" | "import default specifier" | "import expression" | "import namespace specifier" | "import specifier" | "labeled statement" | "logical expression" | "meta property" | "method definition" | "new expression" | "object expression" | "object pattern" | "private identifier" | "property definition" | "rest element" | "return statement" | "sequence expression" | "spread element" | "static block" | "switch case" | "switch statement" | "tagged template expression" | "template element" | "template literal" | "this expression" | "throw statement" | "try statement" | "unary expression" | "update expression" | "variable declaration" | "variable declarator" | "with statement" | "yield expression" | "ts abstract accessor property" | "ts abstract keyword" | "ts abstract method definition" | "ts abstract property definition" | "ts any keyword" | "ts array type" | "ts as expression" | "ts async keyword" | "ts big int keyword" | "ts boolean keyword" | "ts call signature declaration" | "ts class implements" | "ts conditional type" | "ts constructor type" | "ts construct signature declaration" | "ts declare function" | "ts declare keyword" | "ts empty body function expression" | "ts enum declaration" | "ts enum member" | "ts export assignment" | "ts export keyword" | "ts external module reference" | "ts function type" | "ts instantiation expression" | "ts import equals declaration" | "ts import type" | "ts indexed access type" | "ts index signature" | "ts infer type" | "ts interface body" | "ts interface declaration" | "ts interface heritage" | "ts intersection type" | "ts intrinsic keyword" | "ts literal type" | "ts mapped type" | "ts method signature" | "ts module block" | "ts module declaration" | "ts named tuple member" | "ts namespace export declaration" | "ts never keyword" | "ts non null expression" | "ts null keyword" | "ts number keyword" | "ts object keyword" | "ts optional type" | "ts parameter property" | "ts private keyword" | "ts property signature" | "ts protected keyword" | "ts public keyword" | "ts qualified name" | "ts readonly keyword" | "ts rest type" | "ts satisfies expression" | "ts static keyword" | "ts string keyword" | "ts symbol keyword" | "ts template literal type" | "ts this type" | "ts tuple type" | "ts type alias declaration" | "ts type annotation" | "ts type assertion" | "ts type literal" | "ts type operator" | "ts type parameter" | "ts type parameter declaration" | "ts type parameter instantiation" | "ts type predicate" | "ts type query" | "ts type reference" | "ts undefined keyword" | "ts union type" | "ts unknown keyword" | "ts void keyword";
+type ReadableNodeType = ReturnType<typeof readableNodeType>;
+
+declare function isDeclaredInNode({ functionNode, reference, scopeManager, }: {
+    functionNode: TSESTree.Node;
+    reference: TSESLintScopeManager.Reference;
+    scopeManager: TSESLint.Scope.ScopeManager;
+}): boolean;
+declare function getExternalRefs(params: {
+    node: TSESTree.Node;
+    scopeManager: TSESLint.Scope.ScopeManager;
+    sourceCode: Readonly<TSESLint.SourceCode>;
+}): TSESLint.Scope.Reference[];
+
+/**
+ * Traverses up the AST tree until the predicate returns `true` or the root node is reached
+ * @param node The AST node to start traversing from
+ * @param predicate The predicate to check each node
+ * @returns The first node that matches the predicate or `null` if no node matches
+ */
+declare function traverseUp(node: TSESTree.Node, predicate: (node: TSESTree.Node) => boolean): TSESTree.Node | null;
+/**
+ * Traverses up the AST tree until the predicate returns `true` or the root node is reached
+ * @template T
+ * @param node The AST node to start traversing from
+ * @param predicate The predicate to check each node. **must be a type guard**
+ * @returns The first node that matches the predicate or `null` if no node matches
+ */
+declare function traverseUpGuard<T extends TSESTree.Node>(node: TSESTree.Node, predicate: (node: TSESTree.Node) => node is T): T | null;
+
+/**
+ * Get all unary operators in a nested unary expression.
+ * @param node The node to get the operators from.
+ * @returns All unary operators in a nested unary expression.
+ */
+declare function getNestedUnaryOperators(node: TSESTree.UnaryExpression): TSESTree.UnaryExpression["operator"][];
+
+/**
+ * Find a variable through a list of variables by name
+ * @param name The name of the variable to find
+ */
+declare function findVariableByName(name: string): (variables: Variable[]) => O.Option<NonNullable<Variable>>;
+/**
+ * Get all variables from the given scope up to the global scope
+ * @param startScope The scope to start from
+ */
+declare function getVariablesUpToGlobal(startScope: Scope): Variable[];
+/**
+ * Find a variable through a list of variables by name, starting from the given scope and going up to the global scope
+ * @param name The name of the variable to find
+ * @param startScope The scope to start from
+ */
+declare function findVariableByNameUpToGlobal(name: string, startScope: Scope): O.Option<NonNullable<Variable>>;
+declare function resolveDefinitionInit(def: Definition): O.Option<TSESTree.Expression | TSESTree.LetOrConstOrVarDeclaration>;
+/**
+ * Get the init node of the nth definition of a variable
+ * @param at The index number of def in defs
+ * @returns A function that takes a variable and returns the init node of the nth definition of that variable
+ */
+declare function getVariableInit(at: number): (variable: Variable) => O.Option<TSESTree.Expression | TSESTree.LetOrConstOrVarDeclaration>;
+declare function getVariableInitExpression(at: number): (variable: Variable) => O.Option<TSESTree.Expression>;
+
+export { Construction, NodeType, type ReadableNodeType, type TSESTreeArrayTupleType, type TSESTreeClass, type TSESTreeDestructuringPattern, type TSESTreeFunction, type TSESTreeFunctionType, type TSESTreeJSX, type TSESTreeLoop, type TSESTreeProperty, type TSESTreeTypeDeclaration, constructionDetector, findPropertyWithIdentifierKey, findVariableByName, findVariableByNameUpToGlobal, getClassIdentifier, getExternalRefs, getFunctionHeadLocation, getFunctionIdentifier, getFunctionNameWithKind, getNestedIdentifiers, getNestedReturnStatements, getNestedUnaryOperators, getPropertyName, getStaticValue, getStringIfConstant, getVariableInit, getVariableInitExpression, getVariablesUpToGlobal, hasSideEffect, is, isArrayTupleType, isClass, isDeclaredInNode, isDestructuringPattern, isFunction, isFunctionOfClassMethod, isFunctionOfClassProperty, isFunctionOfObjectMethod, isFunctionType, isIdentifierWithName, isIdentifierWithOneOfNames, isJSX, isJSXElement, isJSXFragment, isJSXTagNameExpression, isLeftHandSideExpression, isLeftHandSideExpressionType, isLoop, isMultiLine, isNodeEqual, isOneOf, isParenthesized, isProperty, isPropertyOfObjectExpression, isPropertyWithIdentifierKey, isRegExpLiteral, isStringLiteral, isTypeDeclaration, isUnstableAssignmentPattern, readableNodeType, resolveDefinitionInit, traverseUp, traverseUpGuard, unsafeIsArrayFromCall, unsafeIsMapCall, unsafeIsStringCall, unsafeIsToStringCall, unstableAssignmentPatternTypes };