@eslint-react/ast 1.47.4-beta.0 → 1.47.4-beta.2

package/dist/index.d.mts

@@ -1,7 +1,8 @@
 import { _ } from '@eslint-react/eff';
-import { TSESTree } from '@typescript-eslint/types';
+import { TSESTree, AST_NODE_TYPES as AST_NODE_TYPES$2 } from '@typescript-eslint/types';
 import { TSESTree as TSESTree$1 } from '@typescript-eslint/utils';
-import { AST_NODE_TYPES } from '@typescript-eslint/typescript-estree';
+import { AST_NODE_TYPES as AST_NODE_TYPES$1 } from '@typescript-eslint/typescript-estree';
+import { SyntaxKind } from 'typescript';
 
 /**
  * Find the parent node that satisfies the test function
@@ -166,7 +167,7 @@ declare function getLiteralValueType(input: bigint | boolean | null | number | s
  * @returns A partially applied function bound to a predicate of type T. The returned function can be called passing a
  * node, and it will return an array of all nested expressions of type T.
  */
-declare function getNestedExpressionsOfType<TNodeType extends AST_NODE_TYPES>(type: TNodeType): (node: TSESTree.Node) => Extract<TSESTree.Node, {
+declare function getNestedExpressionsOfType<TNodeType extends AST_NODE_TYPES$1>(type: TNodeType): (node: TSESTree.Node) => Extract<TSESTree.Node, {
     type: TNodeType;
 }>[];
 /**
@@ -198,31 +199,2178 @@ declare function getNestedReturnStatements(node: TSESTree.Node): readonly TSESTr
 
 declare function getPropertyName(node: TSESTree.Node): string | _;
 
-declare const is: <NodeType extends TSESTree$1.AST_NODE_TYPES>(nodeType: NodeType) => (node: TSESTree$1.Node | null | undefined) => node is Extract<TSESTree$1.Node, {
+/**********************************************
+ *      DO NOT MODIFY THIS FILE MANUALLY      *
+ *                                            *
+ *  THIS FILE HAS BEEN COPIED FROM ast-spec.  *
+ * ANY CHANGES WILL BE LOST ON THE NEXT BUILD *
+ *                                            *
+ *   MAKE CHANGES TO ast-spec AND THEN RUN    *
+ *                 yarn build                 *
+ **********************************************/
+
+declare type Accessibility = 'private' | 'protected' | 'public';
+declare type AccessorProperty = AccessorPropertyComputedName | AccessorPropertyNonComputedName;
+declare interface AccessorPropertyComputedName extends PropertyDefinitionComputedNameBase {
+    type: AST_NODE_TYPES.AccessorProperty;
+}
+declare interface AccessorPropertyNonComputedName extends PropertyDefinitionNonComputedNameBase {
+    type: AST_NODE_TYPES.AccessorProperty;
+}
+declare interface ArrayExpression extends BaseNode {
+    type: AST_NODE_TYPES.ArrayExpression;
+    /**
+     * an element will be `null` in the case of a sparse array: `[1, ,3]`
+     */
+    elements: (Expression | SpreadElement | null)[];
+}
+declare interface ArrayPattern extends BaseNode {
+    type: AST_NODE_TYPES.ArrayPattern;
+    decorators: Decorator[];
+    elements: (DestructuringPattern | null)[];
+    optional: boolean;
+    typeAnnotation: TSTypeAnnotation | undefined;
+}
+declare interface ArrowFunctionExpression extends BaseNode {
+    type: AST_NODE_TYPES.ArrowFunctionExpression;
+    async: boolean;
+    body: BlockStatement | Expression;
+    expression: boolean;
+    generator: boolean;
+    id: null;
+    params: Parameter[];
+    returnType: TSTypeAnnotation | undefined;
+    typeParameters: TSTypeParameterDeclaration | undefined;
+}
+declare interface AssignmentExpression extends BaseNode {
+    type: AST_NODE_TYPES.AssignmentExpression;
+    left: Expression;
+    operator: ValueOf<AssignmentOperatorToText>;
+    right: Expression;
+}
+declare interface AssignmentOperatorToText {
+    [SyntaxKind.AmpersandAmpersandEqualsToken]: '&&=';
+    [SyntaxKind.AmpersandEqualsToken]: '&=';
+    [SyntaxKind.AsteriskAsteriskEqualsToken]: '**=';
+    [SyntaxKind.AsteriskEqualsToken]: '*=';
+    [SyntaxKind.BarBarEqualsToken]: '||=';
+    [SyntaxKind.BarEqualsToken]: '|=';
+    [SyntaxKind.CaretEqualsToken]: '^=';
+    [SyntaxKind.EqualsToken]: '=';
+    [SyntaxKind.GreaterThanGreaterThanEqualsToken]: '>>=';
+    [SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken]: '>>>=';
+    [SyntaxKind.LessThanLessThanEqualsToken]: '<<=';
+    [SyntaxKind.MinusEqualsToken]: '-=';
+    [SyntaxKind.PercentEqualsToken]: '%=';
+    [SyntaxKind.PlusEqualsToken]: '+=';
+    [SyntaxKind.QuestionQuestionEqualsToken]: '??=';
+    [SyntaxKind.SlashEqualsToken]: '/=';
+}
+declare interface AssignmentPattern extends BaseNode {
+    type: AST_NODE_TYPES.AssignmentPattern;
+    decorators: Decorator[];
+    left: BindingName;
+    optional: boolean;
+    right: Expression;
+    typeAnnotation: TSTypeAnnotation | undefined;
+}
+declare enum AST_NODE_TYPES {
+    AccessorProperty = "AccessorProperty",
+    ArrayExpression = "ArrayExpression",
+    ArrayPattern = "ArrayPattern",
+    ArrowFunctionExpression = "ArrowFunctionExpression",
+    AssignmentExpression = "AssignmentExpression",
+    AssignmentPattern = "AssignmentPattern",
+    AwaitExpression = "AwaitExpression",
+    BinaryExpression = "BinaryExpression",
+    BlockStatement = "BlockStatement",
+    BreakStatement = "BreakStatement",
+    CallExpression = "CallExpression",
+    CatchClause = "CatchClause",
+    ChainExpression = "ChainExpression",
+    ClassBody = "ClassBody",
+    ClassDeclaration = "ClassDeclaration",
+    ClassExpression = "ClassExpression",
+    ConditionalExpression = "ConditionalExpression",
+    ContinueStatement = "ContinueStatement",
+    DebuggerStatement = "DebuggerStatement",
+    Decorator = "Decorator",
+    DoWhileStatement = "DoWhileStatement",
+    EmptyStatement = "EmptyStatement",
+    ExportAllDeclaration = "ExportAllDeclaration",
+    ExportDefaultDeclaration = "ExportDefaultDeclaration",
+    ExportNamedDeclaration = "ExportNamedDeclaration",
+    ExportSpecifier = "ExportSpecifier",
+    ExpressionStatement = "ExpressionStatement",
+    ForInStatement = "ForInStatement",
+    ForOfStatement = "ForOfStatement",
+    ForStatement = "ForStatement",
+    FunctionDeclaration = "FunctionDeclaration",
+    FunctionExpression = "FunctionExpression",
+    Identifier = "Identifier",
+    IfStatement = "IfStatement",
+    ImportAttribute = "ImportAttribute",
+    ImportDeclaration = "ImportDeclaration",
+    ImportDefaultSpecifier = "ImportDefaultSpecifier",
+    ImportExpression = "ImportExpression",
+    ImportNamespaceSpecifier = "ImportNamespaceSpecifier",
+    ImportSpecifier = "ImportSpecifier",
+    JSXAttribute = "JSXAttribute",
+    JSXClosingElement = "JSXClosingElement",
+    JSXClosingFragment = "JSXClosingFragment",
+    JSXElement = "JSXElement",
+    JSXEmptyExpression = "JSXEmptyExpression",
+    JSXExpressionContainer = "JSXExpressionContainer",
+    JSXFragment = "JSXFragment",
+    JSXIdentifier = "JSXIdentifier",
+    JSXMemberExpression = "JSXMemberExpression",
+    JSXNamespacedName = "JSXNamespacedName",
+    JSXOpeningElement = "JSXOpeningElement",
+    JSXOpeningFragment = "JSXOpeningFragment",
+    JSXSpreadAttribute = "JSXSpreadAttribute",
+    JSXSpreadChild = "JSXSpreadChild",
+    JSXText = "JSXText",
+    LabeledStatement = "LabeledStatement",
+    Literal = "Literal",
+    LogicalExpression = "LogicalExpression",
+    MemberExpression = "MemberExpression",
+    MetaProperty = "MetaProperty",
+    MethodDefinition = "MethodDefinition",
+    NewExpression = "NewExpression",
+    ObjectExpression = "ObjectExpression",
+    ObjectPattern = "ObjectPattern",
+    PrivateIdentifier = "PrivateIdentifier",
+    Program = "Program",
+    Property = "Property",
+    PropertyDefinition = "PropertyDefinition",
+    RestElement = "RestElement",
+    ReturnStatement = "ReturnStatement",
+    SequenceExpression = "SequenceExpression",
+    SpreadElement = "SpreadElement",
+    StaticBlock = "StaticBlock",
+    Super = "Super",
+    SwitchCase = "SwitchCase",
+    SwitchStatement = "SwitchStatement",
+    TaggedTemplateExpression = "TaggedTemplateExpression",
+    TemplateElement = "TemplateElement",
+    TemplateLiteral = "TemplateLiteral",
+    ThisExpression = "ThisExpression",
+    ThrowStatement = "ThrowStatement",
+    TryStatement = "TryStatement",
+    UnaryExpression = "UnaryExpression",
+    UpdateExpression = "UpdateExpression",
+    VariableDeclaration = "VariableDeclaration",
+    VariableDeclarator = "VariableDeclarator",
+    WhileStatement = "WhileStatement",
+    WithStatement = "WithStatement",
+    YieldExpression = "YieldExpression",
+    TSAbstractAccessorProperty = "TSAbstractAccessorProperty",
+    TSAbstractKeyword = "TSAbstractKeyword",
+    TSAbstractMethodDefinition = "TSAbstractMethodDefinition",
+    TSAbstractPropertyDefinition = "TSAbstractPropertyDefinition",
+    TSAnyKeyword = "TSAnyKeyword",
+    TSArrayType = "TSArrayType",
+    TSAsExpression = "TSAsExpression",
+    TSAsyncKeyword = "TSAsyncKeyword",
+    TSBigIntKeyword = "TSBigIntKeyword",
+    TSBooleanKeyword = "TSBooleanKeyword",
+    TSCallSignatureDeclaration = "TSCallSignatureDeclaration",
+    TSClassImplements = "TSClassImplements",
+    TSConditionalType = "TSConditionalType",
+    TSConstructorType = "TSConstructorType",
+    TSConstructSignatureDeclaration = "TSConstructSignatureDeclaration",
+    TSDeclareFunction = "TSDeclareFunction",
+    TSDeclareKeyword = "TSDeclareKeyword",
+    TSEmptyBodyFunctionExpression = "TSEmptyBodyFunctionExpression",
+    TSEnumBody = "TSEnumBody",
+    TSEnumDeclaration = "TSEnumDeclaration",
+    TSEnumMember = "TSEnumMember",
+    TSExportAssignment = "TSExportAssignment",
+    TSExportKeyword = "TSExportKeyword",
+    TSExternalModuleReference = "TSExternalModuleReference",
+    TSFunctionType = "TSFunctionType",
+    TSImportEqualsDeclaration = "TSImportEqualsDeclaration",
+    TSImportType = "TSImportType",
+    TSIndexedAccessType = "TSIndexedAccessType",
+    TSIndexSignature = "TSIndexSignature",
+    TSInferType = "TSInferType",
+    TSInstantiationExpression = "TSInstantiationExpression",
+    TSInterfaceBody = "TSInterfaceBody",
+    TSInterfaceDeclaration = "TSInterfaceDeclaration",
+    TSInterfaceHeritage = "TSInterfaceHeritage",
+    TSIntersectionType = "TSIntersectionType",
+    TSIntrinsicKeyword = "TSIntrinsicKeyword",
+    TSLiteralType = "TSLiteralType",
+    TSMappedType = "TSMappedType",
+    TSMethodSignature = "TSMethodSignature",
+    TSModuleBlock = "TSModuleBlock",
+    TSModuleDeclaration = "TSModuleDeclaration",
+    TSNamedTupleMember = "TSNamedTupleMember",
+    TSNamespaceExportDeclaration = "TSNamespaceExportDeclaration",
+    TSNeverKeyword = "TSNeverKeyword",
+    TSNonNullExpression = "TSNonNullExpression",
+    TSNullKeyword = "TSNullKeyword",
+    TSNumberKeyword = "TSNumberKeyword",
+    TSObjectKeyword = "TSObjectKeyword",
+    TSOptionalType = "TSOptionalType",
+    TSParameterProperty = "TSParameterProperty",
+    TSPrivateKeyword = "TSPrivateKeyword",
+    TSPropertySignature = "TSPropertySignature",
+    TSProtectedKeyword = "TSProtectedKeyword",
+    TSPublicKeyword = "TSPublicKeyword",
+    TSQualifiedName = "TSQualifiedName",
+    TSReadonlyKeyword = "TSReadonlyKeyword",
+    TSRestType = "TSRestType",
+    TSSatisfiesExpression = "TSSatisfiesExpression",
+    TSStaticKeyword = "TSStaticKeyword",
+    TSStringKeyword = "TSStringKeyword",
+    TSSymbolKeyword = "TSSymbolKeyword",
+    TSTemplateLiteralType = "TSTemplateLiteralType",
+    TSThisType = "TSThisType",
+    TSTupleType = "TSTupleType",
+    TSTypeAliasDeclaration = "TSTypeAliasDeclaration",
+    TSTypeAnnotation = "TSTypeAnnotation",
+    TSTypeAssertion = "TSTypeAssertion",
+    TSTypeLiteral = "TSTypeLiteral",
+    TSTypeOperator = "TSTypeOperator",
+    TSTypeParameter = "TSTypeParameter",
+    TSTypeParameterDeclaration = "TSTypeParameterDeclaration",
+    TSTypeParameterInstantiation = "TSTypeParameterInstantiation",
+    TSTypePredicate = "TSTypePredicate",
+    TSTypeQuery = "TSTypeQuery",
+    TSTypeReference = "TSTypeReference",
+    TSUndefinedKeyword = "TSUndefinedKeyword",
+    TSUnionType = "TSUnionType",
+    TSUnknownKeyword = "TSUnknownKeyword",
+    TSVoidKeyword = "TSVoidKeyword"
+}
+declare enum AST_TOKEN_TYPES {
+    Boolean = "Boolean",
+    Identifier = "Identifier",
+    JSXIdentifier = "JSXIdentifier",
+    PrivateIdentifier = "PrivateIdentifier",
+    JSXText = "JSXText",
+    Keyword = "Keyword",
+    Null = "Null",
+    Numeric = "Numeric",
+    Punctuator = "Punctuator",
+    RegularExpression = "RegularExpression",
+    String = "String",
+    Template = "Template",
+    Block = "Block",
+    Line = "Line"
+}
+declare interface AwaitExpression extends BaseNode {
+    type: AST_NODE_TYPES.AwaitExpression;
+    argument: Expression;
+}
+declare interface BaseNode extends NodeOrTokenData {
+    type: AST_NODE_TYPES;
+}
+declare interface BaseToken extends NodeOrTokenData {
+    type: AST_TOKEN_TYPES;
+    value: string;
+}
+declare interface BigIntLiteral extends LiteralBase {
+    bigint: string;
+    value: bigint | null;
+}
+declare interface BinaryExpression extends BaseNode {
+    type: AST_NODE_TYPES.BinaryExpression;
+    left: Expression | PrivateIdentifier;
+    operator: ValueOf<BinaryOperatorToText>;
+    right: Expression;
+}
+declare interface BinaryOperatorToText {
+    [SyntaxKind.AmpersandAmpersandToken]: '&&';
+    [SyntaxKind.AmpersandToken]: '&';
+    [SyntaxKind.AsteriskAsteriskToken]: '**';
+    [SyntaxKind.AsteriskToken]: '*';
+    [SyntaxKind.BarBarToken]: '||';
+    [SyntaxKind.BarToken]: '|';
+    [SyntaxKind.CaretToken]: '^';
+    [SyntaxKind.EqualsEqualsEqualsToken]: '===';
+    [SyntaxKind.EqualsEqualsToken]: '==';
+    [SyntaxKind.ExclamationEqualsEqualsToken]: '!==';
+    [SyntaxKind.ExclamationEqualsToken]: '!=';
+    [SyntaxKind.GreaterThanEqualsToken]: '>=';
+    [SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: '>>>';
+    [SyntaxKind.GreaterThanGreaterThanToken]: '>>';
+    [SyntaxKind.GreaterThanToken]: '>';
+    [SyntaxKind.InKeyword]: 'in';
+    [SyntaxKind.InstanceOfKeyword]: 'instanceof';
+    [SyntaxKind.LessThanEqualsToken]: '<=';
+    [SyntaxKind.LessThanLessThanToken]: '<<';
+    [SyntaxKind.LessThanToken]: '<';
+    [SyntaxKind.MinusToken]: '-';
+    [SyntaxKind.PercentToken]: '%';
+    [SyntaxKind.PlusToken]: '+';
+    [SyntaxKind.SlashToken]: '/';
+}
+declare type BindingName = BindingPattern | Identifier;
+declare type BindingPattern = ArrayPattern | ObjectPattern;
+declare interface BlockComment extends BaseToken {
+    type: AST_TOKEN_TYPES.Block;
+}
+declare interface BlockStatement extends BaseNode {
+    type: AST_NODE_TYPES.BlockStatement;
+    body: Statement[];
+}
+declare interface BooleanLiteral extends LiteralBase {
+    raw: 'false' | 'true';
+    value: boolean;
+}
+declare interface BooleanToken extends BaseToken {
+    type: AST_TOKEN_TYPES.Boolean;
+}
+declare interface BreakStatement extends BaseNode {
+    type: AST_NODE_TYPES.BreakStatement;
+    label: Identifier | null;
+}
+declare interface CallExpression extends BaseNode {
+    type: AST_NODE_TYPES.CallExpression;
+    arguments: CallExpressionArgument[];
+    callee: Expression;
+    optional: boolean;
+    typeArguments: TSTypeParameterInstantiation | undefined;
+}
+declare type CallExpressionArgument = Expression | SpreadElement;
+declare interface CatchClause extends BaseNode {
+    type: AST_NODE_TYPES.CatchClause;
+    body: BlockStatement;
+    param: BindingName | null;
+}
+declare type ChainElement = CallExpression | MemberExpression | TSNonNullExpression;
+declare interface ChainExpression extends BaseNode {
+    type: AST_NODE_TYPES.ChainExpression;
+    expression: ChainElement;
+}
+declare interface ClassBase extends BaseNode {
+    /**
+     * Whether the class is an abstract class.
+     * @example
+     * ```ts
+     * abstract class Foo {}
+     * ```
+     */
+    abstract: boolean;
+    /**
+     * The class body.
+     */
+    body: ClassBody;
+    /**
+     * Whether the class has been `declare`d:
+     * @example
+     * ```ts
+     * declare class Foo {}
+     * ```
+     */
+    declare: boolean;
+    /**
+     * The decorators declared for the class.
+     * @example
+     * ```ts
+     * @deco
+     * class Foo {}
+     * ```
+     */
+    decorators: Decorator[];
+    /**
+     * The class's name.
+     * - For a `ClassExpression` this may be `null` if the name is omitted.
+     * - For a `ClassDeclaration` this may be `null` if and only if the parent is
+     *   an `ExportDefaultDeclaration`.
+     */
+    id: Identifier | null;
+    /**
+     * The implemented interfaces for the class.
+     */
+    implements: TSClassImplements[];
+    /**
+     * The super class this class extends.
+     */
+    superClass: LeftHandSideExpression | null;
+    /**
+     * The generic type parameters passed to the superClass.
+     */
+    superTypeArguments: TSTypeParameterInstantiation | undefined;
+    /**
+     * The generic type parameters declared for the class.
+     */
+    typeParameters: TSTypeParameterDeclaration | undefined;
+}
+declare interface ClassBody extends BaseNode {
+    type: AST_NODE_TYPES.ClassBody;
+    body: ClassElement[];
+}
+declare type ClassDeclaration = ClassDeclarationWithName | ClassDeclarationWithOptionalName;
+declare interface ClassDeclarationBase extends ClassBase {
+    type: AST_NODE_TYPES.ClassDeclaration;
+}
+/**
+ * A normal class declaration:
+ * ```
+ * class A {}
+ * ```
+ */
+declare interface ClassDeclarationWithName extends ClassDeclarationBase {
+    id: Identifier;
+}
+/**
+ * Default-exported class declarations have optional names:
+ * ```
+ * export default class {}
+ * ```
+ */
+declare interface ClassDeclarationWithOptionalName extends ClassDeclarationBase {
+    id: Identifier | null;
+}
+declare type ClassElement = AccessorProperty | MethodDefinition | PropertyDefinition | StaticBlock | TSAbstractAccessorProperty | TSAbstractMethodDefinition | TSAbstractPropertyDefinition | TSIndexSignature;
+declare interface ClassExpression extends ClassBase {
+    type: AST_NODE_TYPES.ClassExpression;
+    abstract: false;
+    declare: false;
+}
+declare interface ClassMethodDefinitionNonComputedNameBase extends MethodDefinitionBase {
+    computed: false;
+    key: ClassPropertyNameNonComputed;
+}
+declare interface ClassPropertyDefinitionNonComputedNameBase extends PropertyDefinitionBase {
+    computed: false;
+    key: ClassPropertyNameNonComputed;
+}
+declare type ClassPropertyNameNonComputed = PrivateIdentifier | PropertyNameNonComputed;
+declare type Comment = BlockComment | LineComment;
+declare interface ConditionalExpression extends BaseNode {
+    type: AST_NODE_TYPES.ConditionalExpression;
+    alternate: Expression;
+    consequent: Expression;
+    test: Expression;
+}
+declare interface ConstDeclaration extends LetOrConstOrVarDeclarationBase {
+    /**
+     * In a `declare const` declaration, the declarators may have initializers, but
+     * not definite assignment assertions. Each declarator cannot have both an
+     * initializer and a type annotation.
+     *
+     * Even if the declaration has no `declare`, it may still be ambient and have
+     * no initializer.
+     */
+    declarations: VariableDeclaratorMaybeInit[];
+    kind: 'const';
+}
+declare interface ContinueStatement extends BaseNode {
+    type: AST_NODE_TYPES.ContinueStatement;
+    label: Identifier | null;
+}
+declare interface DebuggerStatement extends BaseNode {
+    type: AST_NODE_TYPES.DebuggerStatement;
+}
+declare interface Decorator extends BaseNode {
+    type: AST_NODE_TYPES.Decorator;
+    expression: LeftHandSideExpression;
+}
+declare type DefaultExportDeclarations = ClassDeclarationWithOptionalName | Expression | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration;
+declare type DestructuringPattern = ArrayPattern | AssignmentPattern | Identifier | MemberExpression | ObjectPattern | RestElement;
+declare interface DoWhileStatement extends BaseNode {
+    type: AST_NODE_TYPES.DoWhileStatement;
+    body: Statement;
+    test: Expression;
+}
+declare interface EmptyStatement extends BaseNode {
+    type: AST_NODE_TYPES.EmptyStatement;
+}
+declare type EntityName = Identifier | ThisExpression | TSQualifiedName;
+declare interface ExportAllDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.ExportAllDeclaration;
+    /**
+     * The assertions declared for the export.
+     * @example
+     * ```ts
+     * export * from 'mod' assert \{ type: 'json' \};
+     * ```
+     * @deprecated Replaced with {@link `attributes`}.
+     */
+    assertions: ImportAttribute[];
+    /**
+     * The attributes declared for the export.
+     * @example
+     * ```ts
+     * export * from 'mod' with \{ type: 'json' \};
+     * ```
+     */
+    attributes: ImportAttribute[];
+    /**
+     * The name for the exported items (`as X`). `null` if no name is assigned.
+     */
+    exported: Identifier | null;
+    /**
+     * The kind of the export.
+     */
+    exportKind: ExportKind;
+    /**
+     * The source module being exported from.
+     */
+    source: StringLiteral;
+}
+declare type ExportAndImportKind = 'type' | 'value';
+declare interface ExportDefaultDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.ExportDefaultDeclaration;
+    /**
+     * The declaration being exported.
+     */
+    declaration: DefaultExportDeclarations;
+    /**
+     * The kind of the export. Always `value` for default exports.
+     */
+    exportKind: 'value';
+}
+declare type ExportKind = ExportAndImportKind;
+declare type ExportNamedDeclaration = ExportNamedDeclarationWithoutSourceWithMultiple | ExportNamedDeclarationWithoutSourceWithSingle | ExportNamedDeclarationWithSource;
+declare interface ExportNamedDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.ExportNamedDeclaration;
+    /**
+     * The assertions declared for the export.
+     * @example
+     * ```ts
+     * export { foo } from 'mod' assert \{ type: 'json' \};
+     * ```
+     * This will be an empty array if `source` is `null`
+     * @deprecated Replaced with {@link `attributes`}.
+     */
+    assertions: ImportAttribute[];
+    /**
+     * The attributes declared for the export.
+     * @example
+     * ```ts
+     * export { foo } from 'mod' with \{ type: 'json' \};
+     * ```
+     * This will be an empty array if `source` is `null`
+     */
+    attributes: ImportAttribute[];
+    /**
+     * The exported declaration.
+     * @example
+     * ```ts
+     * export const x = 1;
+     * ```
+     * This will be `null` if `source` is not `null`, or if there are `specifiers`
+     */
+    declaration: NamedExportDeclarations | null;
+    /**
+     * The kind of the export.
+     */
+    exportKind: ExportKind;
+    /**
+     * The source module being exported from.
+     */
+    source: StringLiteral | null;
+    /**
+     * The specifiers being exported.
+     * @example
+     * ```ts
+     * export { a, b };
+     * ```
+     * This will be an empty array if `declaration` is not `null`
+     */
+    specifiers: ExportSpecifier[];
+}
+/**
+ * Exporting names from the current module.
+ * ```
+ * export {};
+ * export { a, b };
+ * ```
+ */
+declare interface ExportNamedDeclarationWithoutSourceWithMultiple extends ExportNamedDeclarationBase {
+    /**
+     * This will always be an empty array.
+     * @deprecated Replaced with {@link `attributes`}.
+     */
+    assertions: ImportAttribute[];
+    /**
+     * This will always be an empty array.
+     */
+    attributes: ImportAttribute[];
+    declaration: null;
+    source: null;
+    specifiers: ExportSpecifierWithIdentifierLocal[];
+}
+/**
+ * Exporting a single named declaration.
+ * ```
+ * export const x = 1;
+ * ```
+ */
+declare interface ExportNamedDeclarationWithoutSourceWithSingle extends ExportNamedDeclarationBase {
+    /**
+     * This will always be an empty array.
+     * @deprecated Replaced with {@link `attributes`}.
+     */
+    assertions: ImportAttribute[];
+    /**
+     * This will always be an empty array.
+     */
+    attributes: ImportAttribute[];
+    declaration: NamedExportDeclarations;
+    source: null;
+    /**
+     * This will always be an empty array.
+     */
+    specifiers: ExportSpecifierWithIdentifierLocal[];
+}
+/**
+ * Export names from another module.
+ * ```
+ * export { a, b } from 'mod';
+ * ```
+ */
+declare interface ExportNamedDeclarationWithSource extends ExportNamedDeclarationBase {
+    declaration: null;
+    source: StringLiteral;
+}
+declare type ExportSpecifier = ExportSpecifierWithIdentifierLocal | ExportSpecifierWithStringOrLiteralLocal;
+declare interface ExportSpecifierBase extends BaseNode {
+    type: AST_NODE_TYPES.ExportSpecifier;
+    exported: Identifier | StringLiteral;
+    exportKind: ExportKind;
+    local: Identifier | StringLiteral;
+}
+declare interface ExportSpecifierWithIdentifierLocal extends ExportSpecifierBase {
+    local: Identifier;
+}
+declare interface ExportSpecifierWithStringOrLiteralLocal extends ExportSpecifierBase {
+    local: Identifier | StringLiteral;
+}
+declare type Expression = ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AwaitExpression | BinaryExpression | CallExpression | ChainExpression | ClassExpression | ConditionalExpression | FunctionExpression | Identifier | ImportExpression | JSXElement | JSXFragment | LiteralExpression | LogicalExpression | MemberExpression | MetaProperty | NewExpression | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | TemplateLiteral | ThisExpression | TSAsExpression | TSInstantiationExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion | UnaryExpression | UpdateExpression | YieldExpression;
+declare interface ExpressionStatement extends BaseNode {
+    type: AST_NODE_TYPES.ExpressionStatement;
+    directive: string | undefined;
+    expression: Expression;
+}
+declare type ForInitialiser = Expression | LetOrConstOrVarDeclaration;
+declare interface ForInStatement extends BaseNode {
+    type: AST_NODE_TYPES.ForInStatement;
+    body: Statement;
+    left: ForInitialiser;
+    right: Expression;
+}
+declare type ForOfInitialiser = Expression | LetOrConstOrVarDeclaration | UsingInForOfDeclaration;
+declare interface ForOfStatement extends BaseNode {
+    type: AST_NODE_TYPES.ForOfStatement;
+    await: boolean;
+    body: Statement;
+    left: ForOfInitialiser;
+    right: Expression;
+}
+declare interface ForStatement extends BaseNode {
+    type: AST_NODE_TYPES.ForStatement;
+    body: Statement;
+    init: Expression | ForInitialiser | null;
+    test: Expression | null;
+    update: Expression | null;
+}
+declare interface FunctionBase extends BaseNode {
+    /**
+     * Whether the function is async:
+     * ```
+     * async function foo() {}
+     * const x = async function () {}
+     * const x = async () => {}
+     * ```
+     */
+    async: boolean;
+    /**
+     * The body of the function.
+     * - For an `ArrowFunctionExpression` this may be an `Expression` or `BlockStatement`.
+     * - For a `FunctionDeclaration` or `FunctionExpression` this is always a `BlockStatement`.
+     * - For a `TSDeclareFunction` this is always `undefined`.
+     * - For a `TSEmptyBodyFunctionExpression` this is always `null`.
+     */
+    body: BlockStatement | Expression | null | undefined;
+    /**
+     * This is only `true` if and only if the node is a `TSDeclareFunction` and it has `declare`:
+     * ```
+     * declare function foo() {}
+     * ```
+     */
+    declare: boolean;
+    /**
+     * This is only ever `true` if and only the node is an `ArrowFunctionExpression` and the body
+     * is an expression:
+     * ```
+     * (() => 1)
+     * ```
+     */
+    expression: boolean;
+    /**
+     * Whether the function is a generator function:
+     * ```
+     * function *foo() {}
+     * const x = function *() {}
+     * ```
+     * This is always `false` for arrow functions as they cannot be generators.
+     */
+    generator: boolean;
+    /**
+     * The function's name.
+     * - For an `ArrowFunctionExpression` this is always `null`.
+     * - For a `FunctionExpression` this may be `null` if the name is omitted.
+     * - For a `FunctionDeclaration` or `TSDeclareFunction` this may be `null` if
+     *   and only if the parent is an `ExportDefaultDeclaration`.
+     */
+    id: Identifier | null;
+    /**
+     * The list of parameters declared for the function.
+     */
+    params: Parameter[];
+    /**
+     * The return type annotation for the function.
+     */
+    returnType: TSTypeAnnotation | undefined;
+    /**
+     * The generic type parameter declaration for the function.
+     */
+    typeParameters: TSTypeParameterDeclaration | undefined;
+}
+declare type FunctionDeclaration = FunctionDeclarationWithName | FunctionDeclarationWithOptionalName;
+declare interface FunctionDeclarationBase extends FunctionBase {
+    type: AST_NODE_TYPES.FunctionDeclaration;
+    body: BlockStatement;
+    declare: false;
+    expression: false;
+}
+/**
+ * A normal function declaration:
+ * ```
+ * function f() {}
+ * ```
+ */
+declare interface FunctionDeclarationWithName extends FunctionDeclarationBase {
+    id: Identifier;
+}
+/**
+ * Default-exported function declarations have optional names:
+ * ```
+ * export default function () {}
+ * ```
+ */
+declare interface FunctionDeclarationWithOptionalName extends FunctionDeclarationBase {
+    id: Identifier | null;
+}
+declare interface FunctionExpression extends FunctionBase {
+    type: AST_NODE_TYPES.FunctionExpression;
+    body: BlockStatement;
+    expression: false;
+}
+declare interface Identifier extends BaseNode {
+    type: AST_NODE_TYPES.Identifier;
+    decorators: Decorator[];
+    name: string;
+    optional: boolean;
+    typeAnnotation: TSTypeAnnotation | undefined;
+}
+declare interface IdentifierToken extends BaseToken {
+    type: AST_TOKEN_TYPES.Identifier;
+}
+declare interface IfStatement extends BaseNode {
+    type: AST_NODE_TYPES.IfStatement;
+    alternate: Statement | null;
+    consequent: Statement;
+    test: Expression;
+}
+declare interface ImportAttribute extends BaseNode {
+    type: AST_NODE_TYPES.ImportAttribute;
+    key: Identifier | Literal;
+    value: Literal;
+}
+declare type ImportClause = ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier;
+declare interface ImportDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.ImportDeclaration;
+    /**
+     * The assertions declared for the export.
+     * @example
+     * ```ts
+     * import * from 'mod' assert \{ type: 'json' \};
+     * ```
+     * @deprecated Replaced with {@link `attributes`}.
+     */
+    assertions: ImportAttribute[];
+    /**
+     * The attributes declared for the export.
+     * @example
+     * ```ts
+     * import * from 'mod' with \{ type: 'json' \};
+     * ```
+     */
+    attributes: ImportAttribute[];
+    /**
+     * The kind of the import.
+     */
+    importKind: ImportKind;
+    /**
+     * The source module being imported from.
+     */
+    source: StringLiteral;
+    /**
+     * The specifiers being imported.
+     * If this is an empty array then either there are no specifiers:
+     * ```
+     * import {} from 'mod';
+     * ```
+     * Or it is a side-effect import:
+     * ```
+     * import 'mod';
+     * ```
+     */
+    specifiers: ImportClause[];
+}
+declare interface ImportDefaultSpecifier extends BaseNode {
+    type: AST_NODE_TYPES.ImportDefaultSpecifier;
+    local: Identifier;
+}
+declare interface ImportExpression extends BaseNode {
+    type: AST_NODE_TYPES.ImportExpression;
+    /**
+     * The attributes declared for the dynamic import.
+     * @example
+     * ```ts
+     * import('mod', \{ assert: \{ type: 'json' \} \});
+     * ```
+     * @deprecated Replaced with {@link `options`}.
+     */
+    attributes: Expression | null;
+    /**
+     * The options bag declared for the dynamic import.
+     * @example
+     * ```ts
+     * import('mod', \{ assert: \{ type: 'json' \} \});
+     * ```
+     */
+    options: Expression | null;
+    source: Expression;
+}
+declare type ImportKind = ExportAndImportKind;
+declare interface ImportNamespaceSpecifier extends BaseNode {
+    type: AST_NODE_TYPES.ImportNamespaceSpecifier;
+    local: Identifier;
+}
+declare interface ImportSpecifier extends BaseNode {
+    type: AST_NODE_TYPES.ImportSpecifier;
+    imported: Identifier | StringLiteral;
+    importKind: ImportKind;
+    local: Identifier;
+}
+declare interface JSXAttribute extends BaseNode {
+    type: AST_NODE_TYPES.JSXAttribute;
+    name: JSXIdentifier | JSXNamespacedName;
+    value: JSXElement | JSXExpression | Literal | null;
+}
+declare type JSXChild = JSXElement | JSXExpression | JSXFragment | JSXText;
+declare interface JSXClosingElement extends BaseNode {
+    type: AST_NODE_TYPES.JSXClosingElement;
+    name: JSXTagNameExpression;
+}
+declare interface JSXClosingFragment extends BaseNode {
+    type: AST_NODE_TYPES.JSXClosingFragment;
+}
+declare interface JSXElement extends BaseNode {
+    type: AST_NODE_TYPES.JSXElement;
+    children: JSXChild[];
+    closingElement: JSXClosingElement | null;
+    openingElement: JSXOpeningElement;
+}
+declare interface JSXEmptyExpression extends BaseNode {
+    type: AST_NODE_TYPES.JSXEmptyExpression;
+}
+declare type JSXExpression = JSXExpressionContainer | JSXSpreadChild;
+declare interface JSXExpressionContainer extends BaseNode {
+    type: AST_NODE_TYPES.JSXExpressionContainer;
+    expression: Expression | JSXEmptyExpression;
+}
+declare interface JSXFragment extends BaseNode {
+    type: AST_NODE_TYPES.JSXFragment;
+    children: JSXChild[];
+    closingFragment: JSXClosingFragment;
+    openingFragment: JSXOpeningFragment;
+}
+declare interface JSXIdentifier extends BaseNode {
+    type: AST_NODE_TYPES.JSXIdentifier;
+    name: string;
+}
+declare interface JSXIdentifierToken extends BaseToken {
+    type: AST_TOKEN_TYPES.JSXIdentifier;
+}
+declare interface JSXMemberExpression extends BaseNode {
+    type: AST_NODE_TYPES.JSXMemberExpression;
+    object: JSXTagNameExpression;
+    property: JSXIdentifier;
+}
+declare interface JSXNamespacedName extends BaseNode {
+    type: AST_NODE_TYPES.JSXNamespacedName;
+    name: JSXIdentifier;
+    namespace: JSXIdentifier;
+}
+declare interface JSXOpeningElement extends BaseNode {
+    type: AST_NODE_TYPES.JSXOpeningElement;
+    attributes: (JSXAttribute | JSXSpreadAttribute)[];
+    name: JSXTagNameExpression;
+    selfClosing: boolean;
+    typeArguments: TSTypeParameterInstantiation | undefined;
+}
+declare interface JSXOpeningFragment extends BaseNode {
+    type: AST_NODE_TYPES.JSXOpeningFragment;
+}
+declare interface JSXSpreadAttribute extends BaseNode {
+    type: AST_NODE_TYPES.JSXSpreadAttribute;
+    argument: Expression;
+}
+declare interface JSXSpreadChild extends BaseNode {
+    type: AST_NODE_TYPES.JSXSpreadChild;
+    expression: Expression | JSXEmptyExpression;
+}
+declare type JSXTagNameExpression = JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+declare interface JSXText extends BaseNode {
+    type: AST_NODE_TYPES.JSXText;
+    raw: string;
+    value: string;
+}
+declare interface JSXTextToken extends BaseToken {
+    type: AST_TOKEN_TYPES.JSXText;
+}
+declare interface KeywordToken extends BaseToken {
+    type: AST_TOKEN_TYPES.Keyword;
+}
+declare interface LabeledStatement extends BaseNode {
+    type: AST_NODE_TYPES.LabeledStatement;
+    body: Statement;
+    label: Identifier;
+}
+declare type LeftHandSideExpression = ArrayExpression | ArrayPattern | ArrowFunctionExpression | CallExpression | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | LiteralExpression | MemberExpression | MetaProperty | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | ThisExpression | TSAsExpression | TSNonNullExpression | TSTypeAssertion;
+declare type LetOrConstOrVarDeclaration = ConstDeclaration | LetOrVarDeclaredDeclaration | LetOrVarNonDeclaredDeclaration;
+declare interface LetOrConstOrVarDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.VariableDeclaration;
+    /**
+     * The variables declared by this declaration.
+     * Always non-empty.
+     * @example
+     * ```ts
+     * let x;
+     * let y, z;
+     * ```
+     */
+    declarations: LetOrConstOrVarDeclarator[];
+    /**
+     * Whether the declaration is `declare`d
+     * @example
+     * ```ts
+     * declare const x = 1;
+     * ```
+     */
+    declare: boolean;
+    /**
+     * The keyword used to declare the variable(s)
+     * @example
+     * ```ts
+     * const x = 1;
+     * let y = 2;
+     * var z = 3;
+     * ```
+     */
+    kind: 'const' | 'let' | 'var';
+}
+declare type LetOrConstOrVarDeclarator = VariableDeclaratorDefiniteAssignment | VariableDeclaratorMaybeInit | VariableDeclaratorNoInit;
+declare interface LetOrVarDeclaredDeclaration extends LetOrConstOrVarDeclarationBase {
+    /**
+     * In a `declare let` declaration, the declarators must not have definite assignment
+     * assertions or initializers.
+     *
+     * @example
+     * ```ts
+     * using x = 1;
+     * using y =1, z = 2;
+     * ```
+     */
+    declarations: VariableDeclaratorNoInit[];
+    declare: true;
+    kind: 'let' | 'var';
+}
+declare interface LetOrVarNonDeclaredDeclaration extends LetOrConstOrVarDeclarationBase {
+    /**
+     * In a `let`/`var` declaration, the declarators may have definite assignment
+     * assertions or initializers, but not both.
+     */
+    declarations: (VariableDeclaratorDefiniteAssignment | VariableDeclaratorMaybeInit)[];
+    declare: false;
+    kind: 'let' | 'var';
+}
+declare interface LineComment extends BaseToken {
+    type: AST_TOKEN_TYPES.Line;
+}
+declare type Literal = BigIntLiteral | BooleanLiteral | NullLiteral | NumberLiteral | RegExpLiteral | StringLiteral;
+declare interface LiteralBase extends BaseNode {
+    type: AST_NODE_TYPES.Literal;
+    raw: string;
+    value: bigint | boolean | number | string | RegExp | null;
+}
+declare type LiteralExpression = Literal | TemplateLiteral;
+declare interface LogicalExpression extends BaseNode {
+    type: AST_NODE_TYPES.LogicalExpression;
+    left: Expression;
+    operator: '&&' | '??' | '||';
+    right: Expression;
+}
+declare type MemberExpression = MemberExpressionComputedName | MemberExpressionNonComputedName;
+declare interface MemberExpressionBase extends BaseNode {
+    computed: boolean;
+    object: Expression;
+    optional: boolean;
+    property: Expression | Identifier | PrivateIdentifier;
+}
+declare interface MemberExpressionComputedName extends MemberExpressionBase {
+    type: AST_NODE_TYPES.MemberExpression;
+    computed: true;
+    property: Expression;
+}
+declare interface MemberExpressionNonComputedName extends MemberExpressionBase {
+    type: AST_NODE_TYPES.MemberExpression;
+    computed: false;
+    property: Identifier | PrivateIdentifier;
+}
+declare interface MetaProperty extends BaseNode {
+    type: AST_NODE_TYPES.MetaProperty;
+    meta: Identifier;
+    property: Identifier;
+}
+declare type MethodDefinition = MethodDefinitionComputedName | MethodDefinitionNonComputedName;
+/** this should not be directly used - instead use MethodDefinitionComputedNameBase or MethodDefinitionNonComputedNameBase */
+declare interface MethodDefinitionBase extends BaseNode {
+    accessibility: Accessibility | undefined;
+    computed: boolean;
+    decorators: Decorator[];
+    key: PropertyName;
+    kind: 'constructor' | 'get' | 'method' | 'set';
+    optional: boolean;
+    override: boolean;
+    static: boolean;
+    value: FunctionExpression | TSEmptyBodyFunctionExpression;
+}
+declare interface MethodDefinitionComputedName extends MethodDefinitionComputedNameBase {
+    type: AST_NODE_TYPES.MethodDefinition;
+}
+declare interface MethodDefinitionComputedNameBase extends MethodDefinitionBase {
+    computed: true;
+    key: PropertyNameComputed;
+}
+declare interface MethodDefinitionNonComputedName extends ClassMethodDefinitionNonComputedNameBase {
+    type: AST_NODE_TYPES.MethodDefinition;
+}
+declare interface MethodDefinitionNonComputedNameBase extends MethodDefinitionBase {
+    computed: false;
+    key: PropertyNameNonComputed;
+}
+declare type NamedExportDeclarations = ClassDeclarationWithName | ClassDeclarationWithOptionalName | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration;
+declare interface NewExpression extends BaseNode {
+    type: AST_NODE_TYPES.NewExpression;
+    arguments: CallExpressionArgument[];
+    callee: Expression;
+    typeArguments: TSTypeParameterInstantiation | undefined;
+}
+declare type Node = AccessorProperty | ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BlockStatement | BreakStatement | CallExpression | CatchClause | ChainExpression | ClassBody | ClassDeclaration | ClassExpression | ConditionalExpression | ContinueStatement | DebuggerStatement | Decorator | DoWhileStatement | EmptyStatement | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | Identifier | IfStatement | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportSpecifier | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LabeledStatement | Literal | LogicalExpression | MemberExpression | MetaProperty | MethodDefinition | NewExpression | ObjectExpression | ObjectPattern | PrivateIdentifier | Program | Property | PropertyDefinition | RestElement | ReturnStatement | SequenceExpression | SpreadElement | StaticBlock | Super | SwitchCase | SwitchStatement | TaggedTemplateExpression | TemplateElement | TemplateLiteral | ThisExpression | ThrowStatement | TryStatement | TSAbstractAccessorProperty | TSAbstractKeyword | TSAbstractMethodDefinition | TSAbstractPropertyDefinition | TSAnyKeyword | TSArrayType | TSAsExpression | TSAsyncKeyword | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSClassImplements | TSConditionalType | TSConstructorType | TSConstructSignatureDeclaration | TSDeclareFunction | TSDeclareKeyword | TSEmptyBodyFunctionExpression | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExportKeyword | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexedAccessType | TSIndexSignature | TSInferType | TSInstantiationExpression | TSInterfaceBody | TSInterfaceDeclaration | TSInterfaceHeritage | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSPrivateKeyword | TSPropertySignature | TSProtectedKeyword | TSPublicKeyword | TSQualifiedName | TSReadonlyKeyword | TSRestType | TSSatisfiesExpression | TSStaticKeyword | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | UnaryExpression | UpdateExpression | VariableDeclaration | VariableDeclarator | WhileStatement | WithStatement | YieldExpression;
+declare interface NodeOrTokenData {
+    type: string;
+    /**
+     * The source location information of the node.
+     *
+     * The loc property is defined as nullable by ESTree, but ESLint requires this property.
+     */
+    loc: SourceLocation;
+    range: Range;
+}
+declare interface NullLiteral extends LiteralBase {
+    raw: 'null';
+    value: null;
+}
+declare interface NullToken extends BaseToken {
+    type: AST_TOKEN_TYPES.Null;
+}
+declare interface NumberLiteral extends LiteralBase {
+    value: number;
+}
+declare interface NumericToken extends BaseToken {
+    type: AST_TOKEN_TYPES.Numeric;
+}
+declare interface ObjectExpression extends BaseNode {
+    type: AST_NODE_TYPES.ObjectExpression;
+    properties: ObjectLiteralElement[];
+}
+declare type ObjectLiteralElement = Property | SpreadElement;
+declare interface ObjectPattern extends BaseNode {
+    type: AST_NODE_TYPES.ObjectPattern;
+    decorators: Decorator[];
+    optional: boolean;
+    properties: (Property | RestElement)[];
+    typeAnnotation: TSTypeAnnotation | undefined;
+}
+declare type Parameter = ArrayPattern | AssignmentPattern | Identifier | ObjectPattern | RestElement | TSParameterProperty;
+declare interface Position {
+    /**
+     * Column number on the line (0-indexed)
+     */
+    column: number;
+    /**
+     * Line number (1-indexed)
+     */
+    line: number;
+}
+declare interface PrivateIdentifier extends BaseNode {
+    type: AST_NODE_TYPES.PrivateIdentifier;
+    name: string;
+}
+declare interface PrivateIdentifierToken extends BaseToken {
+    type: AST_TOKEN_TYPES.PrivateIdentifier;
+}
+declare interface Program extends NodeOrTokenData {
+    type: AST_NODE_TYPES.Program;
+    body: ProgramStatement[];
+    comments: Comment[] | undefined;
+    sourceType: 'module' | 'script';
+    tokens: Token[] | undefined;
+}
+declare type ProgramStatement = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | Statement | TSImportEqualsDeclaration | TSNamespaceExportDeclaration;
+declare type Property = PropertyComputedName | PropertyNonComputedName;
+declare interface PropertyBase extends BaseNode {
+    type: AST_NODE_TYPES.Property;
+    computed: boolean;
+    key: PropertyName;
+    kind: 'get' | 'init' | 'set';
+    method: boolean;
+    optional: boolean;
+    shorthand: boolean;
+    value: AssignmentPattern | BindingName | Expression | TSEmptyBodyFunctionExpression;
+}
+declare interface PropertyComputedName extends PropertyBase {
+    computed: true;
+    key: PropertyNameComputed;
+}
+declare type PropertyDefinition = PropertyDefinitionComputedName | PropertyDefinitionNonComputedName;
+declare interface PropertyDefinitionBase extends BaseNode {
+    accessibility: Accessibility | undefined;
+    computed: boolean;
+    declare: boolean;
+    decorators: Decorator[];
+    definite: boolean;
+    key: PropertyName;
+    optional: boolean;
+    override: boolean;
+    readonly: boolean;
+    static: boolean;
+    typeAnnotation: TSTypeAnnotation | undefined;
+    value: Expression | null;
+}
+declare interface PropertyDefinitionComputedName extends PropertyDefinitionComputedNameBase {
+    type: AST_NODE_TYPES.PropertyDefinition;
+}
+declare interface PropertyDefinitionComputedNameBase extends PropertyDefinitionBase {
+    computed: true;
+    key: PropertyNameComputed;
+}
+declare interface PropertyDefinitionNonComputedName extends ClassPropertyDefinitionNonComputedNameBase {
+    type: AST_NODE_TYPES.PropertyDefinition;
+}
+declare interface PropertyDefinitionNonComputedNameBase extends PropertyDefinitionBase {
+    computed: false;
+    key: PropertyNameNonComputed;
+}
+declare type PropertyName = ClassPropertyNameNonComputed | PropertyNameComputed | PropertyNameNonComputed;
+declare type PropertyNameComputed = Expression;
+declare type PropertyNameNonComputed = Identifier | NumberLiteral | StringLiteral;
+declare interface PropertyNonComputedName extends PropertyBase {
+    computed: false;
+    key: PropertyNameNonComputed;
+}
+declare interface PunctuatorToken extends BaseToken {
+    type: AST_TOKEN_TYPES.Punctuator;
+    value: ValueOf<PunctuatorTokenToText>;
+}
+declare interface PunctuatorTokenToText extends AssignmentOperatorToText {
+    [SyntaxKind.AmpersandAmpersandToken]: '&&';
+    [SyntaxKind.AmpersandToken]: '&';
+    [SyntaxKind.AsteriskAsteriskToken]: '**';
+    [SyntaxKind.AsteriskToken]: '*';
+    [SyntaxKind.AtToken]: '@';
+    [SyntaxKind.BacktickToken]: '`';
+    [SyntaxKind.BarBarToken]: '||';
+    [SyntaxKind.BarToken]: '|';
+    [SyntaxKind.CaretToken]: '^';
+    [SyntaxKind.CloseBraceToken]: '}';
+    [SyntaxKind.CloseBracketToken]: ']';
+    [SyntaxKind.CloseParenToken]: ')';
+    [SyntaxKind.ColonToken]: ':';
+    [SyntaxKind.CommaToken]: ',';
+    [SyntaxKind.DotDotDotToken]: '...';
+    [SyntaxKind.DotToken]: '.';
+    [SyntaxKind.EqualsEqualsEqualsToken]: '===';
+    [SyntaxKind.EqualsEqualsToken]: '==';
+    [SyntaxKind.EqualsGreaterThanToken]: '=>';
+    [SyntaxKind.ExclamationEqualsEqualsToken]: '!==';
+    [SyntaxKind.ExclamationEqualsToken]: '!=';
+    [SyntaxKind.ExclamationToken]: '!';
+    [SyntaxKind.GreaterThanEqualsToken]: '>=';
+    [SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: '>>>';
+    [SyntaxKind.GreaterThanGreaterThanToken]: '>>';
+    [SyntaxKind.GreaterThanToken]: '>';
+    [SyntaxKind.HashToken]: '#';
+    [SyntaxKind.LessThanEqualsToken]: '<=';
+    [SyntaxKind.LessThanLessThanToken]: '<<';
+    [SyntaxKind.LessThanSlashToken]: '</';
+    [SyntaxKind.LessThanToken]: '<';
+    [SyntaxKind.MinusMinusToken]: '--';
+    [SyntaxKind.MinusToken]: '-';
+    [SyntaxKind.OpenBraceToken]: '{';
+    [SyntaxKind.OpenBracketToken]: '[';
+    [SyntaxKind.OpenParenToken]: '(';
+    [SyntaxKind.PercentToken]: '%';
+    [SyntaxKind.PlusPlusToken]: '++';
+    [SyntaxKind.PlusToken]: '+';
+    [SyntaxKind.QuestionDotToken]: '?.';
+    [SyntaxKind.QuestionQuestionToken]: '??';
+    [SyntaxKind.QuestionToken]: '?';
+    [SyntaxKind.SemicolonToken]: ';';
+    [SyntaxKind.SlashToken]: '/';
+    [SyntaxKind.TildeToken]: '~';
+}
+/**
+ * An array of two numbers.
+ * Both numbers are a 0-based index which is the position in the array of source code characters.
+ * The first is the start position of the node, the second is the end position of the node.
+ */
+declare type Range = [number, number];
+declare interface RegExpLiteral extends LiteralBase {
+    regex: {
+        flags: string;
+        pattern: string;
+    };
+    value: RegExp | null;
+}
+declare interface RegularExpressionToken extends BaseToken {
+    type: AST_TOKEN_TYPES.RegularExpression;
+    regex: {
+        flags: string;
+        pattern: string;
+    };
+}
+declare interface RestElement extends BaseNode {
+    type: AST_NODE_TYPES.RestElement;
+    argument: DestructuringPattern;
+    decorators: Decorator[];
+    optional: boolean;
+    typeAnnotation: TSTypeAnnotation | undefined;
+    value: AssignmentPattern | undefined;
+}
+declare interface ReturnStatement extends BaseNode {
+    type: AST_NODE_TYPES.ReturnStatement;
+    argument: Expression | null;
+}
+declare interface SequenceExpression extends BaseNode {
+    type: AST_NODE_TYPES.SequenceExpression;
+    expressions: Expression[];
+}
+declare interface SourceLocation {
+    /**
+     * The position of the first character after the parsed source region
+     */
+    end: Position;
+    /**
+     * The position of the first character of the parsed source region
+     */
+    start: Position;
+}
+declare interface SpreadElement extends BaseNode {
+    type: AST_NODE_TYPES.SpreadElement;
+    argument: Expression;
+}
+declare type Statement = BlockStatement | BreakStatement | ClassDeclarationWithName | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclarationWithName | IfStatement | ImportDeclaration | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | TSDeclareFunction | TSEnumDeclaration | TSExportAssignment | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSNamespaceExportDeclaration | TSTypeAliasDeclaration | VariableDeclaration | WhileStatement | WithStatement;
+declare interface StaticBlock extends BaseNode {
+    type: AST_NODE_TYPES.StaticBlock;
+    body: Statement[];
+}
+declare interface StringLiteral extends LiteralBase {
+    value: string;
+}
+declare interface StringToken extends BaseToken {
+    type: AST_TOKEN_TYPES.String;
+}
+declare interface Super extends BaseNode {
+    type: AST_NODE_TYPES.Super;
+}
+declare interface SwitchCase extends BaseNode {
+    type: AST_NODE_TYPES.SwitchCase;
+    consequent: Statement[];
+    test: Expression | null;
+}
+declare interface SwitchStatement extends BaseNode {
+    type: AST_NODE_TYPES.SwitchStatement;
+    cases: SwitchCase[];
+    discriminant: Expression;
+}
+declare interface TaggedTemplateExpression extends BaseNode {
+    type: AST_NODE_TYPES.TaggedTemplateExpression;
+    quasi: TemplateLiteral;
+    tag: Expression;
+    typeArguments: TSTypeParameterInstantiation | undefined;
+}
+declare interface TemplateElement extends BaseNode {
+    type: AST_NODE_TYPES.TemplateElement;
+    tail: boolean;
+    value: {
+        cooked: string;
+        raw: string;
+    };
+}
+declare interface TemplateLiteral extends BaseNode {
+    type: AST_NODE_TYPES.TemplateLiteral;
+    expressions: Expression[];
+    quasis: TemplateElement[];
+}
+declare interface TemplateToken extends BaseToken {
+    type: AST_TOKEN_TYPES.Template;
+}
+declare interface ThisExpression extends BaseNode {
+    type: AST_NODE_TYPES.ThisExpression;
+}
+declare interface ThrowStatement extends BaseNode {
+    type: AST_NODE_TYPES.ThrowStatement;
+    argument: Expression;
+}
+declare type Token = BooleanToken | Comment | IdentifierToken | JSXIdentifierToken | JSXTextToken | KeywordToken | NullToken | NumericToken | PrivateIdentifierToken | PunctuatorToken | RegularExpressionToken | StringToken | TemplateToken;
+declare interface TryStatement extends BaseNode {
+    type: AST_NODE_TYPES.TryStatement;
+    block: BlockStatement;
+    finalizer: BlockStatement | null;
+    handler: CatchClause | null;
+}
+declare type TSAbstractAccessorProperty = TSAbstractAccessorPropertyComputedName | TSAbstractAccessorPropertyNonComputedName;
+declare interface TSAbstractAccessorPropertyComputedName extends PropertyDefinitionComputedNameBase {
+    type: AST_NODE_TYPES.TSAbstractAccessorProperty;
+    value: null;
+}
+declare interface TSAbstractAccessorPropertyNonComputedName extends PropertyDefinitionNonComputedNameBase {
+    type: AST_NODE_TYPES.TSAbstractAccessorProperty;
+    value: null;
+}
+declare interface TSAbstractKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSAbstractKeyword;
+}
+declare type TSAbstractMethodDefinition = TSAbstractMethodDefinitionComputedName | TSAbstractMethodDefinitionNonComputedName;
+declare interface TSAbstractMethodDefinitionComputedName extends MethodDefinitionComputedNameBase {
+    type: AST_NODE_TYPES.TSAbstractMethodDefinition;
+}
+declare interface TSAbstractMethodDefinitionNonComputedName extends MethodDefinitionNonComputedNameBase {
+    type: AST_NODE_TYPES.TSAbstractMethodDefinition;
+}
+declare type TSAbstractPropertyDefinition = TSAbstractPropertyDefinitionComputedName | TSAbstractPropertyDefinitionNonComputedName;
+declare interface TSAbstractPropertyDefinitionComputedName extends PropertyDefinitionComputedNameBase {
+    type: AST_NODE_TYPES.TSAbstractPropertyDefinition;
+    value: null;
+}
+declare interface TSAbstractPropertyDefinitionNonComputedName extends PropertyDefinitionNonComputedNameBase {
+    type: AST_NODE_TYPES.TSAbstractPropertyDefinition;
+    value: null;
+}
+declare interface TSAnyKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSAnyKeyword;
+}
+declare interface TSArrayType extends BaseNode {
+    type: AST_NODE_TYPES.TSArrayType;
+    elementType: TypeNode;
+}
+declare interface TSAsExpression extends BaseNode {
+    type: AST_NODE_TYPES.TSAsExpression;
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+declare interface TSAsyncKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSAsyncKeyword;
+}
+declare interface TSBigIntKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSBigIntKeyword;
+}
+declare interface TSBooleanKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSBooleanKeyword;
+}
+declare interface TSCallSignatureDeclaration extends TSFunctionSignatureBase {
+    type: AST_NODE_TYPES.TSCallSignatureDeclaration;
+}
+declare interface TSClassImplements extends TSHeritageBase {
+    type: AST_NODE_TYPES.TSClassImplements;
+}
+declare interface TSConditionalType extends BaseNode {
+    type: AST_NODE_TYPES.TSConditionalType;
+    checkType: TypeNode;
+    extendsType: TypeNode;
+    falseType: TypeNode;
+    trueType: TypeNode;
+}
+declare interface TSConstructorType extends TSFunctionSignatureBase {
+    type: AST_NODE_TYPES.TSConstructorType;
+    abstract: boolean;
+}
+declare interface TSConstructSignatureDeclaration extends TSFunctionSignatureBase {
+    type: AST_NODE_TYPES.TSConstructSignatureDeclaration;
+}
+declare type TSDeclareFunction = TSDeclareFunctionNoDeclare | TSDeclareFunctionWithDeclare;
+declare interface TSDeclareFunctionBase extends FunctionBase {
+    type: AST_NODE_TYPES.TSDeclareFunction;
+    /**
+     * TS1183: An implementation cannot be declared in ambient contexts.
+     */
+    body: undefined;
+    /**
+     * Whether the declaration has `declare` modifier.
+     */
+    declare: boolean;
+    expression: false;
+}
+/**
+ * Function declaration without the `declare` keyword:
+ * ```
+ * function foo(): void;
+ * ```
+ * This can either be an overload signature or a declaration in an ambient context
+ * (e.g. `declare module`)
+ */
+declare interface TSDeclareFunctionNoDeclare extends TSDeclareFunctionBase {
+    declare: false;
+    /**
+     * - TS1221: Generators are not allowed in an ambient context.
+     * - TS1222: An overload signature cannot be declared as a generator.
+     */
+    generator: false;
+}
+/**
+ * Function declaration with the `declare` keyword:
+ * ```
+ * declare function foo(): void;
+ * ```
+ */
+declare interface TSDeclareFunctionWithDeclare extends TSDeclareFunctionBase {
+    /**
+     * TS1040: 'async' modifier cannot be used in an ambient context.
+     */
+    async: false;
+    declare: true;
+    /**
+     * TS1221: Generators are not allowed in an ambient context.
+     */
+    generator: false;
+}
+declare interface TSDeclareKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSDeclareKeyword;
+}
+declare interface TSEmptyBodyFunctionExpression extends FunctionBase {
+    type: AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
+    body: null;
+    id: null;
+}
+declare interface TSEnumBody extends BaseNode {
+    type: AST_NODE_TYPES.TSEnumBody;
+    members: TSEnumMember[];
+}
+declare interface TSEnumDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSEnumDeclaration;
+    /**
+     * The body of the enum.
+     */
+    body: TSEnumBody;
+    /**
+     * Whether this is a `const` enum.
+     * @example
+     * ```ts
+     * const enum Foo {}
+     * ```
+     */
+    const: boolean;
+    /**
+     * Whether this is a `declare`d enum.
+     * @example
+     * ```ts
+     * declare enum Foo {}
+     * ```
+     */
+    declare: boolean;
+    /**
+     * The enum name.
+     */
+    id: Identifier;
+    /**
+     * The enum members.
+     * @deprecated Use {@link body} instead.
+     */
+    members: TSEnumMember[];
+}
+declare type TSEnumMember = TSEnumMemberComputedName | TSEnumMemberNonComputedName;
+declare interface TSEnumMemberBase extends BaseNode {
+    type: AST_NODE_TYPES.TSEnumMember;
+    computed: boolean;
+    id: PropertyNameComputed | PropertyNameNonComputed;
+    initializer: Expression | undefined;
+}
+/**
+ * this should only really happen in semantically invalid code (errors 1164 and 2452)
+ *
+ * @example
+ * ```ts
+ * // VALID:
+ * enum Foo { ['a'] }
+ *
+ * // INVALID:
+ * const x = 'a';
+ * enum Foo { [x] }
+ * enum Bar { ['a' + 'b'] }
+ * ```
+ */
+declare interface TSEnumMemberComputedName extends TSEnumMemberBase {
+    computed: true;
+    id: PropertyNameComputed;
+}
+declare interface TSEnumMemberNonComputedName extends TSEnumMemberBase {
+    computed: false;
+    id: PropertyNameNonComputed;
+}
+declare interface TSExportAssignment extends BaseNode {
+    type: AST_NODE_TYPES.TSExportAssignment;
+    expression: Expression;
+}
+declare interface TSExportKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSExportKeyword;
+}
+declare interface TSExternalModuleReference extends BaseNode {
+    type: AST_NODE_TYPES.TSExternalModuleReference;
+    expression: StringLiteral;
+}
+declare interface TSFunctionSignatureBase extends BaseNode {
+    params: Parameter[];
+    returnType: TSTypeAnnotation | undefined;
+    typeParameters: TSTypeParameterDeclaration | undefined;
+}
+declare interface TSFunctionType extends TSFunctionSignatureBase {
+    type: AST_NODE_TYPES.TSFunctionType;
+}
+declare interface TSHeritageBase extends BaseNode {
+    expression: Expression;
+    typeArguments: TSTypeParameterInstantiation | undefined;
+}
+declare type TSImportEqualsDeclaration = TSImportEqualsNamespaceDeclaration | TSImportEqualsRequireDeclaration;
+declare interface TSImportEqualsDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.TSImportEqualsDeclaration;
+    /**
+     * The locally imported name.
+     */
+    id: Identifier;
+    /**
+     * The kind of the import. Always `'value'` unless `moduleReference` is a
+     * `TSExternalModuleReference`.
+     */
+    importKind: ImportKind;
+    /**
+     * The value being aliased.
+     * @example
+     * ```ts
+     * import F1 = A;
+     * import F2 = A.B.C;
+     * import F3 = require('mod');
+     * ```
+     */
+    moduleReference: Identifier | TSExternalModuleReference | TSQualifiedName;
+}
+declare interface TSImportEqualsNamespaceDeclaration extends TSImportEqualsDeclarationBase {
+    /**
+     * The kind of the import.
+     */
+    importKind: 'value';
+    /**
+     * The value being aliased.
+     * ```
+     * import F1 = A;
+     * import F2 = A.B.C;
+     * ```
+     */
+    moduleReference: Identifier | TSQualifiedName;
+}
+declare interface TSImportEqualsRequireDeclaration extends TSImportEqualsDeclarationBase {
+    /**
+     * The kind of the import.
+     */
+    importKind: ImportKind;
+    /**
+     * The value being aliased.
+     * ```
+     * import F3 = require('mod');
+     * ```
+     */
+    moduleReference: TSExternalModuleReference;
+}
+declare interface TSImportType extends BaseNode {
+    type: AST_NODE_TYPES.TSImportType;
+    argument: TypeNode;
+    options: ObjectExpression | null;
+    qualifier: EntityName | null;
+    typeArguments: TSTypeParameterInstantiation | null;
+}
+declare interface TSIndexedAccessType extends BaseNode {
+    type: AST_NODE_TYPES.TSIndexedAccessType;
+    indexType: TypeNode;
+    objectType: TypeNode;
+}
+declare interface TSIndexSignature extends BaseNode {
+    type: AST_NODE_TYPES.TSIndexSignature;
+    accessibility: Accessibility | undefined;
+    parameters: Parameter[];
+    readonly: boolean;
+    static: boolean;
+    typeAnnotation: TSTypeAnnotation | undefined;
+}
+declare interface TSInferType extends BaseNode {
+    type: AST_NODE_TYPES.TSInferType;
+    typeParameter: TSTypeParameter;
+}
+declare interface TSInstantiationExpression extends BaseNode {
+    type: AST_NODE_TYPES.TSInstantiationExpression;
+    expression: Expression;
+    typeArguments: TSTypeParameterInstantiation;
+}
+declare interface TSInterfaceBody extends BaseNode {
+    type: AST_NODE_TYPES.TSInterfaceBody;
+    body: TypeElement[];
+}
+declare interface TSInterfaceDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSInterfaceDeclaration;
+    /**
+     * The body of the interface
+     */
+    body: TSInterfaceBody;
+    /**
+     * Whether the interface was `declare`d
+     */
+    declare: boolean;
+    /**
+     * The types this interface `extends`
+     */
+    extends: TSInterfaceHeritage[];
+    /**
+     * The name of this interface
+     */
+    id: Identifier;
+    /**
+     * The generic type parameters declared for the interface. Empty declaration
+     * (`<>`) is different from no declaration.
+     */
+    typeParameters: TSTypeParameterDeclaration | undefined;
+}
+declare interface TSInterfaceHeritage extends TSHeritageBase {
+    type: AST_NODE_TYPES.TSInterfaceHeritage;
+}
+declare interface TSIntersectionType extends BaseNode {
+    type: AST_NODE_TYPES.TSIntersectionType;
+    types: TypeNode[];
+}
+declare interface TSIntrinsicKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSIntrinsicKeyword;
+}
+declare interface TSLiteralType extends BaseNode {
+    type: AST_NODE_TYPES.TSLiteralType;
+    literal: LiteralExpression | UnaryExpression | UpdateExpression;
+}
+declare interface TSMappedType extends BaseNode {
+    type: AST_NODE_TYPES.TSMappedType;
+    constraint: TypeNode;
+    key: Identifier;
+    nameType: TypeNode | null;
+    optional: boolean | '+' | '-' | undefined;
+    readonly: boolean | '+' | '-' | undefined;
+    typeAnnotation: TypeNode | undefined;
+    /** @deprecated Use {@link `constraint`} and {@link `key`} instead. */
+    typeParameter: TSTypeParameter;
+}
+declare type TSMethodSignature = TSMethodSignatureComputedName | TSMethodSignatureNonComputedName;
+declare interface TSMethodSignatureBase extends BaseNode {
+    type: AST_NODE_TYPES.TSMethodSignature;
+    accessibility: Accessibility | undefined;
+    computed: boolean;
+    key: PropertyName;
+    kind: 'get' | 'method' | 'set';
+    optional: boolean;
+    params: Parameter[];
+    readonly: boolean;
+    returnType: TSTypeAnnotation | undefined;
+    static: boolean;
+    typeParameters: TSTypeParameterDeclaration | undefined;
+}
+declare interface TSMethodSignatureComputedName extends TSMethodSignatureBase {
+    computed: true;
+    key: PropertyNameComputed;
+}
+declare interface TSMethodSignatureNonComputedName extends TSMethodSignatureBase {
+    computed: false;
+    key: PropertyNameNonComputed;
+}
+declare interface TSModuleBlock extends BaseNode {
+    type: AST_NODE_TYPES.TSModuleBlock;
+    body: ProgramStatement[];
+}
+declare type TSModuleDeclaration = TSModuleDeclarationGlobal | TSModuleDeclarationModule | TSModuleDeclarationNamespace;
+declare interface TSModuleDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.TSModuleDeclaration;
+    /**
+     * The body of the module.
+     * This can only be `undefined` for the code `declare module 'mod';`
+     */
+    body?: TSModuleBlock;
+    /**
+     * Whether the module is `declare`d
+     * @example
+     * ```ts
+     * declare namespace F {}
+     * ```
+     */
+    declare: boolean;
+    /**
+     * Whether this is a global declaration
+     * @example
+     * ```ts
+     * declare global {}
+     * ```
+     *
+     * @deprecated Use {@link kind} instead
+     */
+    global: boolean;
+    /**
+     * The name of the module
+     * ```
+     * namespace A {}
+     * namespace A.B.C {}
+     * module 'a' {}
+     * ```
+     */
+    id: Identifier | Literal | TSQualifiedName;
+    /**
+     * The keyword used to define this module declaration
+     * @example
+     * ```ts
+     * namespace Foo {}
+     * ^^^^^^^^^
+     *
+     * module 'foo' {}
+     * ^^^^^^
+     *
+     * global {}
+     * ^^^^^^
+     * ```
+     */
+    kind: TSModuleDeclarationKind;
+}
+declare interface TSModuleDeclarationGlobal extends TSModuleDeclarationBase {
+    body: TSModuleBlock;
+    /**
+     * This will always be an Identifier with name `global`
+     */
+    id: Identifier;
+    kind: 'global';
+}
+declare type TSModuleDeclarationKind = 'global' | 'module' | 'namespace';
+declare type TSModuleDeclarationModule = TSModuleDeclarationModuleWithIdentifierId | TSModuleDeclarationModuleWithStringId;
+declare interface TSModuleDeclarationModuleBase extends TSModuleDeclarationBase {
+    kind: 'module';
+}
+/**
+ * The legacy module declaration, replaced with namespace declarations.
+ * ```
+ * module A {}
+ * ```
+ */
+declare interface TSModuleDeclarationModuleWithIdentifierId extends TSModuleDeclarationModuleBase {
+    body: TSModuleBlock;
+    id: Identifier;
+    kind: 'module';
+}
+declare type TSModuleDeclarationModuleWithStringId = TSModuleDeclarationModuleWithStringIdDeclared | TSModuleDeclarationModuleWithStringIdNotDeclared;
+/**
+ * A string module declaration that is declared:
+ * ```
+ * declare module 'foo' {}
+ * declare module 'foo';
+ * ```
+ */
+declare interface TSModuleDeclarationModuleWithStringIdDeclared extends TSModuleDeclarationModuleBase {
+    body?: TSModuleBlock;
+    declare: true;
+    id: StringLiteral;
+    kind: 'module';
+}
+/**
+ * A string module declaration that is not declared:
+ * ```
+ * module 'foo' {}
+ * ```
+ */
+declare interface TSModuleDeclarationModuleWithStringIdNotDeclared extends TSModuleDeclarationModuleBase {
+    body: TSModuleBlock;
+    declare: false;
+    id: StringLiteral;
+    kind: 'module';
+}
+declare interface TSModuleDeclarationNamespace extends TSModuleDeclarationBase {
+    body: TSModuleBlock;
+    id: Identifier | TSQualifiedName;
+    kind: 'namespace';
+}
+declare interface TSNamedTupleMember extends BaseNode {
+    type: AST_NODE_TYPES.TSNamedTupleMember;
+    elementType: TypeNode;
+    label: Identifier;
+    optional: boolean;
+}
+/**
+ * For the following declaration:
+ * ```
+ * export as namespace X;
+ * ```
+ */
+declare interface TSNamespaceExportDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSNamespaceExportDeclaration;
+    /**
+     * The name of the global variable that's exported as namespace
+     */
+    id: Identifier;
+}
+declare interface TSNeverKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSNeverKeyword;
+}
+declare interface TSNonNullExpression extends BaseNode {
+    type: AST_NODE_TYPES.TSNonNullExpression;
+    expression: Expression;
+}
+declare interface TSNullKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSNullKeyword;
+}
+declare interface TSNumberKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSNumberKeyword;
+}
+declare interface TSObjectKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSObjectKeyword;
+}
+declare interface TSOptionalType extends BaseNode {
+    type: AST_NODE_TYPES.TSOptionalType;
+    typeAnnotation: TypeNode;
+}
+declare interface TSParameterProperty extends BaseNode {
+    type: AST_NODE_TYPES.TSParameterProperty;
+    accessibility: Accessibility | undefined;
+    decorators: Decorator[];
+    override: boolean;
+    parameter: AssignmentPattern | BindingName | RestElement;
+    readonly: boolean;
+    static: boolean;
+}
+declare interface TSPrivateKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSPrivateKeyword;
+}
+declare type TSPropertySignature = TSPropertySignatureComputedName | TSPropertySignatureNonComputedName;
+declare interface TSPropertySignatureBase extends BaseNode {
+    type: AST_NODE_TYPES.TSPropertySignature;
+    accessibility: Accessibility | undefined;
+    computed: boolean;
+    key: PropertyName;
+    optional: boolean;
+    readonly: boolean;
+    static: boolean;
+    typeAnnotation: TSTypeAnnotation | undefined;
+}
+declare interface TSPropertySignatureComputedName extends TSPropertySignatureBase {
+    computed: true;
+    key: PropertyNameComputed;
+}
+declare interface TSPropertySignatureNonComputedName extends TSPropertySignatureBase {
+    computed: false;
+    key: PropertyNameNonComputed;
+}
+declare interface TSProtectedKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSProtectedKeyword;
+}
+declare interface TSPublicKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSPublicKeyword;
+}
+declare interface TSQualifiedName extends BaseNode {
+    type: AST_NODE_TYPES.TSQualifiedName;
+    left: EntityName;
+    right: Identifier;
+}
+declare interface TSReadonlyKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSReadonlyKeyword;
+}
+declare interface TSRestType extends BaseNode {
+    type: AST_NODE_TYPES.TSRestType;
+    typeAnnotation: TypeNode;
+}
+declare interface TSSatisfiesExpression extends BaseNode {
+    type: AST_NODE_TYPES.TSSatisfiesExpression;
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+declare interface TSStaticKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSStaticKeyword;
+}
+declare interface TSStringKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSStringKeyword;
+}
+declare interface TSSymbolKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSSymbolKeyword;
+}
+declare interface TSTemplateLiteralType extends BaseNode {
+    type: AST_NODE_TYPES.TSTemplateLiteralType;
+    quasis: TemplateElement[];
+    types: TypeNode[];
+}
+declare interface TSThisType extends BaseNode {
+    type: AST_NODE_TYPES.TSThisType;
+}
+declare interface TSTupleType extends BaseNode {
+    type: AST_NODE_TYPES.TSTupleType;
+    elementTypes: TypeNode[];
+}
+declare interface TSTypeAliasDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeAliasDeclaration;
+    /**
+     * Whether the type was `declare`d.
+     * @example
+     * ```ts
+     * declare type T = 1;
+     * ```
+     */
+    declare: boolean;
+    /**
+     * The name of the type.
+     */
+    id: Identifier;
+    /**
+     * The "value" (type) of the declaration
+     */
+    typeAnnotation: TypeNode;
+    /**
+     * The generic type parameters declared for the type. Empty declaration
+     * (`<>`) is different from no declaration.
+     */
+    typeParameters: TSTypeParameterDeclaration | undefined;
+}
+declare interface TSTypeAnnotation extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeAnnotation;
+    typeAnnotation: TypeNode;
+}
+declare interface TSTypeAssertion extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeAssertion;
+    expression: Expression;
+    typeAnnotation: TypeNode;
+}
+declare interface TSTypeLiteral extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeLiteral;
+    members: TypeElement[];
+}
+declare interface TSTypeOperator extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeOperator;
+    operator: 'keyof' | 'readonly' | 'unique';
+    typeAnnotation: TypeNode | undefined;
+}
+declare interface TSTypeParameter extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeParameter;
+    const: boolean;
+    constraint: TypeNode | undefined;
+    default: TypeNode | undefined;
+    in: boolean;
+    name: Identifier;
+    out: boolean;
+}
+declare interface TSTypeParameterDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeParameterDeclaration;
+    params: TSTypeParameter[];
+}
+declare interface TSTypeParameterInstantiation extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeParameterInstantiation;
+    params: TypeNode[];
+}
+declare interface TSTypePredicate extends BaseNode {
+    type: AST_NODE_TYPES.TSTypePredicate;
+    asserts: boolean;
+    parameterName: Identifier | TSThisType;
+    typeAnnotation: TSTypeAnnotation | null;
+}
+declare interface TSTypeQuery extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeQuery;
+    exprName: EntityName | TSImportType;
+    typeArguments: TSTypeParameterInstantiation | undefined;
+}
+declare interface TSTypeReference extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeReference;
+    typeArguments: TSTypeParameterInstantiation | undefined;
+    typeName: EntityName;
+}
+declare interface TSUndefinedKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSUndefinedKeyword;
+}
+declare interface TSUnionType extends BaseNode {
+    type: AST_NODE_TYPES.TSUnionType;
+    types: TypeNode[];
+}
+declare interface TSUnknownKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSUnknownKeyword;
+}
+declare interface TSVoidKeyword extends BaseNode {
+    type: AST_NODE_TYPES.TSVoidKeyword;
+}
+declare type TypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSIndexSignature | TSMethodSignature | TSPropertySignature;
+declare type TypeNode = TSAbstractKeyword | TSAnyKeyword | TSArrayType | TSAsyncKeyword | TSBigIntKeyword | TSBooleanKeyword | TSConditionalType | TSConstructorType | TSDeclareKeyword | TSExportKeyword | TSFunctionType | TSImportType | TSIndexedAccessType | TSInferType | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSNamedTupleMember | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSPrivateKeyword | TSProtectedKeyword | TSPublicKeyword | TSQualifiedName | TSReadonlyKeyword | TSRestType | TSStaticKeyword | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeLiteral | TSTypeOperator | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword;
+declare interface UnaryExpression extends UnaryExpressionBase {
+    type: AST_NODE_TYPES.UnaryExpression;
+    operator: '!' | '+' | '~' | '-' | 'delete' | 'typeof' | 'void';
+}
+declare interface UnaryExpressionBase extends BaseNode {
+    argument: Expression;
+    operator: string;
+    prefix: boolean;
+}
+declare interface UpdateExpression extends UnaryExpressionBase {
+    type: AST_NODE_TYPES.UpdateExpression;
+    operator: '++' | '--';
+}
+declare type UsingDeclaration = UsingInForOfDeclaration | UsingInNormalContextDeclaration;
+declare interface UsingDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.VariableDeclaration;
+    /**
+     * This value will always be `false`
+     * because 'declare' modifier cannot appear on a 'using' declaration.
+     */
+    declare: false;
+    /**
+     * The keyword used to declare the variable(s)
+     * @example
+     * ```ts
+     * using x = 1;
+     * await using y = 2;
+     * ```
+     */
+    kind: 'await using' | 'using';
+}
+declare type UsingDeclarator = UsingInForOfDeclarator | UsingInNormalContextDeclarator;
+declare interface UsingInForOfDeclaration extends UsingDeclarationBase {
+    /**
+     * The variables declared by this declaration.
+     * Always has exactly one element.
+     * @example
+     * ```ts
+     * for (using x of y) {}
+     * ```
+     */
+    declarations: [UsingInForOfDeclarator];
+}
+declare interface UsingInForOfDeclarator extends VariableDeclaratorBase {
+    definite: false;
+    id: Identifier;
+    init: null;
+}
+declare interface UsingInNormalContextDeclaration extends UsingDeclarationBase {
+    /**
+     * The variables declared by this declaration.
+     * Always non-empty.
+     * @example
+     * ```ts
+     * using x = 1;
+     * using y = 1, z = 2;
+     * ```
+     */
+    declarations: UsingInNormalContextDeclarator[];
+}
+declare interface UsingInNormalContextDeclarator extends VariableDeclaratorBase {
+    definite: false;
+    id: Identifier;
+    init: Expression;
+}
+declare type ValueOf<T> = T[keyof T];
+declare type VariableDeclaration = LetOrConstOrVarDeclaration | UsingDeclaration;
+declare type VariableDeclarator = LetOrConstOrVarDeclarator | UsingDeclarator;
+declare interface VariableDeclaratorBase extends BaseNode {
+    type: AST_NODE_TYPES.VariableDeclarator;
+    /**
+     * Whether there's definite assignment assertion (`let x!: number`).
+     * If `true`, then: `id` must be an identifier with a type annotation,
+     * `init` must be `null`, and the declarator must be a `var`/`let` declarator.
+     */
+    definite: boolean;
+    /**
+     * The name(s) of the variable(s).
+     */
+    id: BindingName;
+    /**
+     * The initializer expression of the variable. Must be present for `const` unless
+     * in a `declare const`.
+     */
+    init: Expression | null;
+}
+declare interface VariableDeclaratorDefiniteAssignment extends VariableDeclaratorBase {
+    definite: true;
+    /**
+     * The name of the variable. Must have a type annotation.
+     */
+    id: Identifier;
+    init: null;
+}
+declare interface VariableDeclaratorMaybeInit extends VariableDeclaratorBase {
+    definite: false;
+}
+declare interface VariableDeclaratorNoInit extends VariableDeclaratorBase {
+    definite: false;
+    init: null;
+}
+declare interface WhileStatement extends BaseNode {
+    type: AST_NODE_TYPES.WhileStatement;
+    body: Statement;
+    test: Expression;
+}
+declare interface WithStatement extends BaseNode {
+    type: AST_NODE_TYPES.WithStatement;
+    body: Statement;
+    object: Expression;
+}
+declare interface YieldExpression extends BaseNode {
+    type: AST_NODE_TYPES.YieldExpression;
+    argument: Expression | null;
+    delegate: boolean;
+}
+
+declare const is: <NodeType extends AST_NODE_TYPES$2>(nodeType: NodeType) => (node: Node | null | undefined) => node is Extract<Node, {
     type: NodeType;
 }>;
-declare const isOneOf: <NodeTypes extends readonly TSESTree$1.AST_NODE_TYPES[]>(nodeTypes: NodeTypes) => (node: TSESTree$1.Node | null | undefined) => node is Extract<TSESTree$1.Node, {
+declare const isOneOf: <NodeTypes extends readonly AST_NODE_TYPES$2[]>(nodeTypes: NodeTypes) => (node: Node | null | undefined) => node is Extract<Node, {
     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.TSDeclareFunctionNoDeclare | TSESTree$1.TSDeclareFunctionWithDeclare | 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 isMethodOrProperty: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.MethodDefinitionComputedName | TSESTree$1.MethodDefinitionNonComputedName | TSESTree$1.PropertyDefinitionComputedName | TSESTree$1.PropertyDefinitionNonComputedName;
-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 isControlFlow: (data: TSESTree$1.Node | null | undefined) => data is TSESTree$1.DoWhileStatement | TSESTree$1.ForInStatement | TSESTree$1.ForOfStatement | TSESTree$1.ForStatement | TSESTree$1.IfStatement | TSESTree$1.SwitchStatement | TSESTree$1.WhileStatement;
-declare const isConditional: (data: TSESTree$1.Node | null | undefined) => data is TSESTree$1.ConditionalExpression | TSESTree$1.DoWhileStatement | TSESTree$1.ForInStatement | TSESTree$1.ForOfStatement | TSESTree$1.ForStatement | TSESTree$1.IfStatement | TSESTree$1.LogicalExpression | TSESTree$1.SwitchStatement | 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 isJSXTagNameExpression: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.JSXIdentifier | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXNamespacedName;
-declare const isJSX: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.JSXAttribute | TSESTree$1.JSXClosingElement | TSESTree$1.JSXClosingFragment | TSESTree$1.JSXElement | TSESTree$1.JSXEmptyExpression | TSESTree$1.JSXExpressionContainer | TSESTree$1.JSXFragment | TSESTree$1.JSXIdentifier | TSESTree$1.JSXMemberExpression | TSESTree$1.JSXNamespacedName | TSESTree$1.JSXOpeningElement | TSESTree$1.JSXOpeningFragment | TSESTree$1.JSXSpreadAttribute | TSESTree$1.JSXSpreadChild | TSESTree$1.JSXText;
-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.ArrayExpression | TSESTree$1.ArrayPattern | TSESTree$1.ArrowFunctionExpression | TSESTree$1.CallExpression | TSESTree$1.ClassExpression | TSESTree$1.FunctionExpression | TSESTree$1.Identifier | TSESTree$1.JSXElement | TSESTree$1.JSXFragment | 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.ObjectPattern | 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.ArrayExpression | TSESTree$1.ArrayPattern | TSESTree$1.ArrowFunctionExpression | TSESTree$1.CallExpression | TSESTree$1.ClassExpression | TSESTree$1.FunctionExpression | TSESTree$1.Identifier | TSESTree$1.JSXElement | TSESTree$1.JSXFragment | 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.ObjectPattern | TSESTree$1.SequenceExpression | TSESTree$1.Super | TSESTree$1.TaggedTemplateExpression | TSESTree$1.TemplateLiteral | TSESTree$1.ThisExpression | TSESTree$1.TSAsExpression | TSESTree$1.TSNonNullExpression | TSESTree$1.TSTypeAssertion;
-declare const isTypeExpression: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.TSAsExpression | TSESTree$1.TSInstantiationExpression | TSESTree$1.TSNonNullExpression | TSESTree$1.TSSatisfiesExpression | TSESTree$1.TSTypeAssertion;
-declare const isTypeAssertionExpression: (node: TSESTree$1.Node | null | undefined) => node is TSESTree$1.TSAsExpression | TSESTree$1.TSNonNullExpression | TSESTree$1.TSSatisfiesExpression | TSESTree$1.TSTypeAssertion;
+declare const isFunction: (node: Node | null | undefined) => node is ArrowFunctionExpression | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | FunctionExpression;
+declare const isFunctionType: (node: Node | null | undefined) => node is ArrowFunctionExpression | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | FunctionExpression | TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSDeclareFunctionNoDeclare | TSDeclareFunctionWithDeclare | TSEmptyBodyFunctionExpression | TSFunctionType | TSMethodSignatureComputedName | TSMethodSignatureNonComputedName;
+declare const isClass: (node: Node | null | undefined) => node is ClassDeclarationWithName | ClassDeclarationWithOptionalName | ClassExpression;
+declare const isMethodOrProperty: (node: Node | null | undefined) => node is MethodDefinitionComputedName | MethodDefinitionNonComputedName | PropertyDefinitionComputedName | PropertyDefinitionNonComputedName;
+declare const isLoop: (node: Node | null | undefined) => node is DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | WhileStatement;
+declare const isControlFlow: (data: Node | null | undefined) => data is DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | SwitchStatement | WhileStatement;
+declare const isConditional: (data: Node | null | undefined) => data is ConditionalExpression | DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | IfStatement | LogicalExpression | SwitchStatement | WhileStatement;
+declare const isArrayTupleType: (node: Node | null | undefined) => node is TSArrayType | TSTupleType;
+declare const isProperty: (node: Node | null | undefined) => node is PropertyDefinitionComputedName | PropertyDefinitionNonComputedName | TSIndexSignature | TSParameterProperty | TSPropertySignatureComputedName | TSPropertySignatureNonComputedName;
+declare const isJSXElement: (node: Node | null | undefined) => node is JSXElement;
+declare const isJSXFragment: (node: Node | null | undefined) => node is JSXFragment;
+declare const isJSXTagNameExpression: (node: Node | null | undefined) => node is JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+declare const isJSX: (node: Node | null | undefined) => node is JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText;
+declare const isDestructuringPattern: (node: Node | null | undefined) => node is ArrayPattern | AssignmentPattern | ObjectPattern | RestElement;
+declare const isTypeDeclaration: (node: Node | null | undefined) => node is TSInterfaceDeclaration | TSTypeAliasDeclaration;
+declare const isLeftHandSideExpression: (node: Node | null | undefined) => node is ArrayExpression | ArrayPattern | ArrowFunctionExpression | CallExpression | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | BigIntLiteral | BooleanLiteral | NullLiteral | NumberLiteral | RegExpLiteral | StringLiteral | MemberExpressionComputedName | MemberExpressionNonComputedName | MetaProperty | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | TemplateLiteral | ThisExpression;
+declare const isLeftHandSideExpressionType: (node: Node | null | undefined) => node is ArrayExpression | ArrayPattern | ArrowFunctionExpression | CallExpression | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | BigIntLiteral | BooleanLiteral | NullLiteral | NumberLiteral | RegExpLiteral | StringLiteral | MemberExpressionComputedName | MemberExpressionNonComputedName | MetaProperty | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | TemplateLiteral | ThisExpression | TSAsExpression | TSNonNullExpression | TSTypeAssertion;
+declare const isTypeExpression: (node: Node | null | undefined) => node is TSAsExpression | TSInstantiationExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
+declare const isTypeAssertionExpression: (node: Node | null | undefined) => node is TSAsExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion;
 
 declare function isArrayFromCall(node: TSESTree.Node, loose?: boolean): node is TSESTree.CallExpression;