@saasmakers/eslint 1.0.18 → 1.0.19

package/dist/index.d.ts

@@ -1,2412 +1,7 @@
 import * as ts from 'typescript';
-import { SyntaxKind, Program as Program$2 } from 'typescript';
+import { SyntaxKind, Program as Program$1 } from 'typescript';
 import * as eslint from 'eslint';
 
-/**********************************************
- *      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    *
- *                 pnpm run build             *
- **********************************************/
-
-declare type Accessibility$1 = 'private' | 'protected' | 'public';
-declare type AccessorProperty$1 = AccessorPropertyComputedName$1 | AccessorPropertyNonComputedName$1;
-declare interface AccessorPropertyComputedName$1 extends PropertyDefinitionComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.AccessorProperty;
-}
-declare interface AccessorPropertyNonComputedName$1 extends PropertyDefinitionNonComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.AccessorProperty;
-}
-declare interface ArrayExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ArrayExpression;
-    /**
-     * an element will be `null` in the case of a sparse array: `[1, ,3]`
-     */
-    elements: (Expression$1 | SpreadElement$1 | null)[];
-}
-declare interface ArrayPattern$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ArrayPattern;
-    decorators: Decorator$1[];
-    elements: (DestructuringPattern$1 | null)[];
-    optional: boolean;
-    typeAnnotation: TSTypeAnnotation$1 | undefined;
-}
-declare interface ArrowFunctionExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ArrowFunctionExpression;
-    async: boolean;
-    body: BlockStatement$1 | Expression$1;
-    expression: boolean;
-    generator: false;
-    id: null;
-    params: Parameter$1[];
-    returnType: TSTypeAnnotation$1 | undefined;
-    typeParameters: TSTypeParameterDeclaration$1 | undefined;
-}
-declare interface AssignmentExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.AssignmentExpression;
-    left: Expression$1;
-    operator: ValueOf$1<AssignmentOperatorToText$1>;
-    right: Expression$1;
-}
-declare interface AssignmentOperatorToText$1 {
-    [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$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.AssignmentPattern;
-    decorators: Decorator$1[];
-    left: BindingName$1;
-    optional: boolean;
-    right: Expression$1;
-    typeAnnotation: TSTypeAnnotation$1 | undefined;
-}
-declare enum AST_NODE_TYPES$1 {
-    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$1 {
-    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$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.AwaitExpression;
-    argument: Expression$1;
-}
-declare interface BaseNode$1 extends NodeOrTokenData$1 {
-    type: AST_NODE_TYPES$1;
-}
-declare interface BaseToken$1 extends NodeOrTokenData$1 {
-    type: AST_TOKEN_TYPES$1;
-    value: string;
-}
-declare interface BigIntLiteral$1 extends LiteralBase$1 {
-    bigint: string;
-    value: bigint | null;
-}
-declare type BinaryExpression$1 = PrivateInExpression$1 | SymmetricBinaryExpression$1;
-declare interface BinaryOperatorToText$1 {
-    [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$1 = BindingPattern$1 | Identifier$1;
-declare type BindingPattern$1 = ArrayPattern$1 | ObjectPattern$1;
-declare interface BlockComment$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Block;
-}
-declare interface BlockStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.BlockStatement;
-    body: Statement$1[];
-}
-declare interface BooleanLiteral$1 extends LiteralBase$1 {
-    raw: 'false' | 'true';
-    value: boolean;
-}
-declare interface BooleanToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Boolean;
-}
-declare interface BreakStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.BreakStatement;
-    label: Identifier$1 | null;
-}
-declare interface CallExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.CallExpression;
-    arguments: CallExpressionArgument$1[];
-    callee: Expression$1;
-    optional: boolean;
-    typeArguments: TSTypeParameterInstantiation$1 | undefined;
-}
-declare type CallExpressionArgument$1 = Expression$1 | SpreadElement$1;
-declare interface CatchClause$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.CatchClause;
-    body: BlockStatement$1;
-    param: BindingName$1 | null;
-}
-declare type ChainElement$1 = CallExpression$1 | MemberExpression$1 | TSNonNullExpression$1;
-declare interface ChainExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ChainExpression;
-    expression: ChainElement$1;
-}
-declare interface ClassBase$1 extends BaseNode$1 {
-    /**
-     * Whether the class is an abstract class.
-     * @example
-     * ```ts
-     * abstract class Foo {}
-     * ```
-     */
-    abstract: boolean;
-    /**
-     * The class body.
-     */
-    body: ClassBody$1;
-    /**
-     * 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$1[];
-    /**
-     * 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$1 | null;
-    /**
-     * The implemented interfaces for the class.
-     */
-    implements: TSClassImplements$1[];
-    /**
-     * The super class this class extends.
-     */
-    superClass: LeftHandSideExpression$1 | null;
-    /**
-     * The generic type parameters passed to the superClass.
-     */
-    superTypeArguments: TSTypeParameterInstantiation$1 | undefined;
-    /**
-     * The generic type parameters declared for the class.
-     */
-    typeParameters: TSTypeParameterDeclaration$1 | undefined;
-}
-declare interface ClassBody$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ClassBody;
-    body: ClassElement$1[];
-}
-declare type ClassDeclaration$1 = ClassDeclarationWithName$1 | ClassDeclarationWithOptionalName$1;
-declare interface ClassDeclarationBase$1 extends ClassBase$1 {
-    type: AST_NODE_TYPES$1.ClassDeclaration;
-}
-/**
- * A normal class declaration:
- * ```
- * class A {}
- * ```
- */
-declare interface ClassDeclarationWithName$1 extends ClassDeclarationBase$1 {
-    id: Identifier$1;
-}
-/**
- * Default-exported class declarations have optional names:
- * ```
- * export default class {}
- * ```
- */
-declare interface ClassDeclarationWithOptionalName$1 extends ClassDeclarationBase$1 {
-    id: Identifier$1 | null;
-}
-declare type ClassElement$1 = AccessorProperty$1 | MethodDefinition$1 | PropertyDefinition$1 | StaticBlock$1 | TSAbstractAccessorProperty$1 | TSAbstractMethodDefinition$1 | TSAbstractPropertyDefinition$1 | TSIndexSignature$1;
-declare interface ClassExpression$1 extends ClassBase$1 {
-    type: AST_NODE_TYPES$1.ClassExpression;
-    abstract: false;
-    declare: false;
-}
-declare interface ClassMethodDefinitionNonComputedNameBase$1 extends MethodDefinitionBase$1 {
-    computed: false;
-    key: ClassPropertyNameNonComputed$1;
-}
-declare interface ClassPropertyDefinitionNonComputedNameBase$1 extends PropertyDefinitionBase$1 {
-    computed: false;
-    key: ClassPropertyNameNonComputed$1;
-}
-declare type ClassPropertyNameNonComputed$1 = PrivateIdentifier$1 | PropertyNameNonComputed$1;
-declare type Comment$1 = BlockComment$1 | LineComment$1;
-declare interface ConditionalExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ConditionalExpression;
-    alternate: Expression$1;
-    consequent: Expression$1;
-    test: Expression$1;
-}
-declare interface ConstDeclaration$1 extends LetOrConstOrVarDeclarationBase$1 {
-    /**
-     * 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$1[];
-    kind: 'const';
-}
-declare interface ContinueStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ContinueStatement;
-    label: Identifier$1 | null;
-}
-declare interface DebuggerStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.DebuggerStatement;
-}
-declare interface Decorator$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.Decorator;
-    expression: LeftHandSideExpression$1;
-}
-declare type DefaultExportDeclarations$1 = ClassDeclarationWithOptionalName$1 | Expression$1 | FunctionDeclarationWithName$1 | FunctionDeclarationWithOptionalName$1 | TSDeclareFunction$1 | TSEnumDeclaration$1 | TSInterfaceDeclaration$1 | TSModuleDeclaration$1 | TSTypeAliasDeclaration$1 | VariableDeclaration$1;
-declare type DestructuringPattern$1 = ArrayPattern$1 | AssignmentPattern$1 | Identifier$1 | MemberExpression$1 | ObjectPattern$1 | RestElement$1;
-declare interface DoWhileStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.DoWhileStatement;
-    body: Statement$1;
-    test: Expression$1;
-}
-declare interface EmptyStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.EmptyStatement;
-}
-declare type EntityName$1 = Identifier$1 | ThisExpression$1 | TSQualifiedName$1;
-declare interface ExportAllDeclaration$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ExportAllDeclaration;
-    /**
-     * The assertions declared for the export.
-     * @example
-     * ```ts
-     * export * from 'mod' assert \{ type: 'json' \};
-     * ```
-     * @deprecated Replaced with {@link `attributes`}.
-     */
-    assertions: ImportAttribute$1[];
-    /**
-     * The attributes declared for the export.
-     * @example
-     * ```ts
-     * export * from 'mod' with \{ type: 'json' \};
-     * ```
-     */
-    attributes: ImportAttribute$1[];
-    /**
-     * The name for the exported items (`as X`). `null` if no name is assigned.
-     */
-    exported: Identifier$1 | null;
-    /**
-     * The kind of the export.
-     */
-    exportKind: ExportKind$1;
-    /**
-     * The source module being exported from.
-     */
-    source: StringLiteral$1;
-}
-declare type ExportAndImportKind$1 = 'type' | 'value';
-declare interface ExportDefaultDeclaration$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ExportDefaultDeclaration;
-    /**
-     * The declaration being exported.
-     */
-    declaration: DefaultExportDeclarations$1;
-    /**
-     * The kind of the export. Always `value` for default exports.
-     */
-    exportKind: 'value';
-}
-declare type ExportKind$1 = ExportAndImportKind$1;
-declare type ExportNamedDeclaration$1 = ExportNamedDeclarationWithoutSourceWithMultiple$1 | ExportNamedDeclarationWithoutSourceWithSingle$1 | ExportNamedDeclarationWithSource$1;
-declare interface ExportNamedDeclarationBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.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$1[];
-    /**
-     * 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$1[];
-    /**
-     * 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$1 | null;
-    /**
-     * The kind of the export.
-     */
-    exportKind: ExportKind$1;
-    /**
-     * The source module being exported from.
-     */
-    source: StringLiteral$1 | null;
-    /**
-     * The specifiers being exported.
-     * @example
-     * ```ts
-     * export { a, b };
-     * ```
-     * This will be an empty array if `declaration` is not `null`
-     */
-    specifiers: ExportSpecifier$1[];
-}
-/**
- * Exporting names from the current module.
- * ```
- * export {};
- * export { a, b };
- * ```
- */
-declare interface ExportNamedDeclarationWithoutSourceWithMultiple$1 extends ExportNamedDeclarationBase$1 {
-    /**
-     * This will always be an empty array.
-     * @deprecated Replaced with {@link `attributes`}.
-     */
-    assertions: ImportAttribute$1[];
-    /**
-     * This will always be an empty array.
-     */
-    attributes: ImportAttribute$1[];
-    declaration: null;
-    source: null;
-    specifiers: ExportSpecifierWithIdentifierLocal$1[];
-}
-/**
- * Exporting a single named declaration.
- * ```
- * export const x = 1;
- * ```
- */
-declare interface ExportNamedDeclarationWithoutSourceWithSingle$1 extends ExportNamedDeclarationBase$1 {
-    /**
-     * This will always be an empty array.
-     * @deprecated Replaced with {@link `attributes`}.
-     */
-    assertions: ImportAttribute$1[];
-    /**
-     * This will always be an empty array.
-     */
-    attributes: ImportAttribute$1[];
-    declaration: NamedExportDeclarations$1;
-    source: null;
-    /**
-     * This will always be an empty array.
-     */
-    specifiers: ExportSpecifierWithIdentifierLocal$1[];
-}
-/**
- * Export names from another module.
- * ```
- * export { a, b } from 'mod';
- * ```
- */
-declare interface ExportNamedDeclarationWithSource$1 extends ExportNamedDeclarationBase$1 {
-    declaration: null;
-    source: StringLiteral$1;
-}
-declare type ExportSpecifier$1 = ExportSpecifierWithIdentifierLocal$1 | ExportSpecifierWithStringOrLiteralLocal$1;
-declare interface ExportSpecifierBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ExportSpecifier;
-    exported: Identifier$1 | StringLiteral$1;
-    exportKind: ExportKind$1;
-    local: Identifier$1 | StringLiteral$1;
-}
-declare interface ExportSpecifierWithIdentifierLocal$1 extends ExportSpecifierBase$1 {
-    local: Identifier$1;
-}
-declare interface ExportSpecifierWithStringOrLiteralLocal$1 extends ExportSpecifierBase$1 {
-    local: Identifier$1 | StringLiteral$1;
-}
-declare type Expression$1 = ArrayExpression$1 | ArrayPattern$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AwaitExpression$1 | BinaryExpression$1 | CallExpression$1 | ChainExpression$1 | ClassExpression$1 | ConditionalExpression$1 | FunctionExpression$1 | Identifier$1 | ImportExpression$1 | JSXElement$1 | JSXFragment$1 | LiteralExpression$1 | LogicalExpression$1 | MemberExpression$1 | MetaProperty$1 | NewExpression$1 | ObjectExpression$1 | ObjectPattern$1 | SequenceExpression$1 | Super$1 | TaggedTemplateExpression$1 | TemplateLiteral$1 | ThisExpression$1 | TSAsExpression$1 | TSInstantiationExpression$1 | TSNonNullExpression$1 | TSSatisfiesExpression$1 | TSTypeAssertion$1 | UnaryExpression$1 | UpdateExpression$1 | YieldExpression$1;
-declare interface ExpressionStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ExpressionStatement;
-    directive: string | undefined;
-    expression: Expression$1;
-}
-declare type ForInitialiser$1 = Expression$1 | LetOrConstOrVarDeclaration$1;
-declare interface ForInStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ForInStatement;
-    body: Statement$1;
-    left: ForInitialiser$1;
-    right: Expression$1;
-}
-declare type ForOfInitialiser$1 = Expression$1 | LetOrConstOrVarDeclaration$1 | UsingInForOfDeclaration$1;
-declare interface ForOfStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ForOfStatement;
-    await: boolean;
-    body: Statement$1;
-    left: ForOfInitialiser$1;
-    right: Expression$1;
-}
-declare interface ForStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ForStatement;
-    body: Statement$1;
-    init: Expression$1 | ForInitialiser$1 | null;
-    test: Expression$1 | null;
-    update: Expression$1 | null;
-}
-declare interface FunctionBase$1 extends BaseNode$1 {
-    /**
-     * 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$1 | Expression$1 | 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$1 | null;
-    /**
-     * The list of parameters declared for the function.
-     */
-    params: Parameter$1[];
-    /**
-     * The return type annotation for the function.
-     */
-    returnType: TSTypeAnnotation$1 | undefined;
-    /**
-     * The generic type parameter declaration for the function.
-     */
-    typeParameters: TSTypeParameterDeclaration$1 | undefined;
-}
-declare type FunctionDeclaration$1 = FunctionDeclarationWithName$1 | FunctionDeclarationWithOptionalName$1;
-declare interface FunctionDeclarationBase$1 extends FunctionBase$1 {
-    type: AST_NODE_TYPES$1.FunctionDeclaration;
-    body: BlockStatement$1;
-    declare: false;
-    expression: false;
-}
-/**
- * A normal function declaration:
- * ```
- * function f() {}
- * ```
- */
-declare interface FunctionDeclarationWithName$1 extends FunctionDeclarationBase$1 {
-    id: Identifier$1;
-}
-/**
- * Default-exported function declarations have optional names:
- * ```
- * export default function () {}
- * ```
- */
-declare interface FunctionDeclarationWithOptionalName$1 extends FunctionDeclarationBase$1 {
-    id: Identifier$1 | null;
-}
-declare interface FunctionExpression$1 extends FunctionBase$1 {
-    type: AST_NODE_TYPES$1.FunctionExpression;
-    body: BlockStatement$1;
-    expression: false;
-}
-declare type FunctionLike$1 = ArrowFunctionExpression$1 | FunctionDeclaration$1 | FunctionExpression$1 | TSDeclareFunction$1 | TSEmptyBodyFunctionExpression$1;
-declare interface Identifier$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.Identifier;
-    decorators: Decorator$1[];
-    name: string;
-    optional: boolean;
-    typeAnnotation: TSTypeAnnotation$1 | undefined;
-}
-declare interface IdentifierToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Identifier;
-}
-declare interface IfStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.IfStatement;
-    alternate: Statement$1 | null;
-    consequent: Statement$1;
-    test: Expression$1;
-}
-declare interface ImportAttribute$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ImportAttribute;
-    key: Identifier$1 | Literal$1;
-    value: Literal$1;
-}
-declare type ImportClause$1 = ImportDefaultSpecifier$1 | ImportNamespaceSpecifier$1 | ImportSpecifier$1;
-declare interface ImportDeclaration$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ImportDeclaration;
-    /**
-     * The assertions declared for the export.
-     * @example
-     * ```ts
-     * import * from 'mod' assert \{ type: 'json' \};
-     * ```
-     * @deprecated Replaced with {@link `attributes`}.
-     */
-    assertions: ImportAttribute$1[];
-    /**
-     * The attributes declared for the export.
-     * @example
-     * ```ts
-     * import * from 'mod' with \{ type: 'json' \};
-     * ```
-     */
-    attributes: ImportAttribute$1[];
-    /**
-     * The kind of the import.
-     */
-    importKind: ImportKind$1;
-    /**
-     * The source module being imported from.
-     */
-    source: StringLiteral$1;
-    /**
-     * 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$1[];
-}
-declare interface ImportDefaultSpecifier$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ImportDefaultSpecifier;
-    local: Identifier$1;
-}
-declare interface ImportExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ImportExpression;
-    /**
-     * The attributes declared for the dynamic import.
-     * @example
-     * ```ts
-     * import('mod', \{ assert: \{ type: 'json' \} \});
-     * ```
-     * @deprecated Replaced with {@link `options`}.
-     */
-    attributes: Expression$1 | null;
-    /**
-     * The options bag declared for the dynamic import.
-     * @example
-     * ```ts
-     * import('mod', \{ assert: \{ type: 'json' \} \});
-     * ```
-     */
-    options: Expression$1 | null;
-    source: Expression$1;
-}
-declare type ImportKind$1 = ExportAndImportKind$1;
-declare interface ImportNamespaceSpecifier$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ImportNamespaceSpecifier;
-    local: Identifier$1;
-}
-declare interface ImportSpecifier$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ImportSpecifier;
-    imported: Identifier$1 | StringLiteral$1;
-    importKind: ImportKind$1;
-    local: Identifier$1;
-}
-declare interface JSXAttribute$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXAttribute;
-    name: JSXIdentifier$1 | JSXNamespacedName$1;
-    value: JSXElement$1 | JSXExpression$1 | Literal$1 | null;
-}
-declare type JSXChild$1 = JSXElement$1 | JSXExpression$1 | JSXFragment$1 | JSXText$1;
-declare interface JSXClosingElement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXClosingElement;
-    name: JSXTagNameExpression$1;
-}
-declare interface JSXClosingFragment$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXClosingFragment;
-}
-declare interface JSXElement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXElement;
-    children: JSXChild$1[];
-    closingElement: JSXClosingElement$1 | null;
-    openingElement: JSXOpeningElement$1;
-}
-declare interface JSXEmptyExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXEmptyExpression;
-}
-declare type JSXExpression$1 = JSXExpressionContainer$1 | JSXSpreadChild$1;
-declare interface JSXExpressionContainer$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXExpressionContainer;
-    expression: Expression$1 | JSXEmptyExpression$1;
-}
-declare interface JSXFragment$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXFragment;
-    children: JSXChild$1[];
-    closingFragment: JSXClosingFragment$1;
-    openingFragment: JSXOpeningFragment$1;
-}
-declare interface JSXIdentifier$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXIdentifier;
-    name: string;
-}
-declare interface JSXIdentifierToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.JSXIdentifier;
-}
-declare interface JSXMemberExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXMemberExpression;
-    object: JSXTagNameExpression$1;
-    property: JSXIdentifier$1;
-}
-declare interface JSXNamespacedName$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXNamespacedName;
-    name: JSXIdentifier$1;
-    namespace: JSXIdentifier$1;
-}
-declare interface JSXOpeningElement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXOpeningElement;
-    attributes: (JSXAttribute$1 | JSXSpreadAttribute$1)[];
-    name: JSXTagNameExpression$1;
-    selfClosing: boolean;
-    typeArguments: TSTypeParameterInstantiation$1 | undefined;
-}
-declare interface JSXOpeningFragment$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXOpeningFragment;
-}
-declare interface JSXSpreadAttribute$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXSpreadAttribute;
-    argument: Expression$1;
-}
-declare interface JSXSpreadChild$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXSpreadChild;
-    expression: Expression$1 | JSXEmptyExpression$1;
-}
-declare type JSXTagNameExpression$1 = JSXIdentifier$1 | JSXMemberExpression$1 | JSXNamespacedName$1;
-declare interface JSXText$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.JSXText;
-    raw: string;
-    value: string;
-}
-declare interface JSXTextToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.JSXText;
-}
-declare interface KeywordToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Keyword;
-}
-declare interface LabeledStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.LabeledStatement;
-    body: Statement$1;
-    label: Identifier$1;
-}
-declare type LeftHandSideExpression$1 = ArrayExpression$1 | ArrayPattern$1 | ArrowFunctionExpression$1 | CallExpression$1 | ClassExpression$1 | FunctionExpression$1 | Identifier$1 | JSXElement$1 | JSXFragment$1 | LiteralExpression$1 | MemberExpression$1 | MetaProperty$1 | ObjectExpression$1 | ObjectPattern$1 | SequenceExpression$1 | Super$1 | TaggedTemplateExpression$1 | ThisExpression$1 | TSAsExpression$1 | TSNonNullExpression$1 | TSTypeAssertion$1;
-declare type LetOrConstOrVarDeclaration$1 = ConstDeclaration$1 | LetOrVarDeclaredDeclaration$1 | LetOrVarNonDeclaredDeclaration$1;
-declare interface LetOrConstOrVarDeclarationBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.VariableDeclaration;
-    /**
-     * The variables declared by this declaration.
-     * Always non-empty.
-     * @example
-     * ```ts
-     * let x;
-     * let y, z;
-     * ```
-     */
-    declarations: LetOrConstOrVarDeclarator$1[];
-    /**
-     * 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$1 = VariableDeclaratorDefiniteAssignment$1 | VariableDeclaratorMaybeInit$1 | VariableDeclaratorNoInit$1;
-declare interface LetOrVarDeclaredDeclaration$1 extends LetOrConstOrVarDeclarationBase$1 {
-    /**
-     * 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$1[];
-    declare: true;
-    kind: 'let' | 'var';
-}
-declare interface LetOrVarNonDeclaredDeclaration$1 extends LetOrConstOrVarDeclarationBase$1 {
-    /**
-     * In a `let`/`var` declaration, the declarators may have definite assignment
-     * assertions or initializers, but not both.
-     */
-    declarations: (VariableDeclaratorDefiniteAssignment$1 | VariableDeclaratorMaybeInit$1)[];
-    declare: false;
-    kind: 'let' | 'var';
-}
-declare interface LineComment$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Line;
-}
-declare type Literal$1 = BigIntLiteral$1 | BooleanLiteral$1 | NullLiteral$1 | NumberLiteral$1 | RegExpLiteral$1 | StringLiteral$1;
-declare interface LiteralBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.Literal;
-    raw: string;
-    value: bigint | boolean | number | string | RegExp | null;
-}
-declare type LiteralExpression$1 = Literal$1 | TemplateLiteral$1;
-declare interface LogicalExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.LogicalExpression;
-    left: Expression$1;
-    operator: '&&' | '??' | '||';
-    right: Expression$1;
-}
-declare type MemberExpression$1 = MemberExpressionComputedName$1 | MemberExpressionNonComputedName$1;
-declare interface MemberExpressionBase$1 extends BaseNode$1 {
-    computed: boolean;
-    object: Expression$1;
-    optional: boolean;
-    property: Expression$1 | Identifier$1 | PrivateIdentifier$1;
-}
-declare interface MemberExpressionComputedName$1 extends MemberExpressionBase$1 {
-    type: AST_NODE_TYPES$1.MemberExpression;
-    computed: true;
-    property: Expression$1;
-}
-declare interface MemberExpressionNonComputedName$1 extends MemberExpressionBase$1 {
-    type: AST_NODE_TYPES$1.MemberExpression;
-    computed: false;
-    property: Identifier$1 | PrivateIdentifier$1;
-}
-declare interface MetaProperty$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.MetaProperty;
-    meta: Identifier$1;
-    property: Identifier$1;
-}
-declare type MethodDefinition$1 = MethodDefinitionComputedName$1 | MethodDefinitionNonComputedName$1;
-/** this should not be directly used - instead use MethodDefinitionComputedNameBase or MethodDefinitionNonComputedNameBase */
-declare interface MethodDefinitionBase$1 extends BaseNode$1 {
-    accessibility: Accessibility$1 | undefined;
-    computed: boolean;
-    decorators: Decorator$1[];
-    key: PropertyName$1;
-    kind: 'constructor' | 'get' | 'method' | 'set';
-    optional: boolean;
-    override: boolean;
-    static: boolean;
-    value: FunctionExpression$1 | TSEmptyBodyFunctionExpression$1;
-}
-declare interface MethodDefinitionComputedName$1 extends MethodDefinitionComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.MethodDefinition;
-}
-declare interface MethodDefinitionComputedNameBase$1 extends MethodDefinitionBase$1 {
-    computed: true;
-    key: PropertyNameComputed$1;
-}
-declare interface MethodDefinitionNonComputedName$1 extends ClassMethodDefinitionNonComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.MethodDefinition;
-}
-declare interface MethodDefinitionNonComputedNameBase$1 extends MethodDefinitionBase$1 {
-    computed: false;
-    key: PropertyNameNonComputed$1;
-}
-declare type NamedExportDeclarations$1 = ClassDeclarationWithName$1 | ClassDeclarationWithOptionalName$1 | FunctionDeclarationWithName$1 | FunctionDeclarationWithOptionalName$1 | TSDeclareFunction$1 | TSEnumDeclaration$1 | TSImportEqualsDeclaration$1 | TSInterfaceDeclaration$1 | TSModuleDeclaration$1 | TSTypeAliasDeclaration$1 | VariableDeclaration$1;
-declare interface NewExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.NewExpression;
-    arguments: CallExpressionArgument$1[];
-    callee: Expression$1;
-    typeArguments: TSTypeParameterInstantiation$1 | undefined;
-}
-declare type Node$1 = AccessorProperty$1 | ArrayExpression$1 | ArrayPattern$1 | ArrowFunctionExpression$1 | AssignmentExpression$1 | AssignmentPattern$1 | AwaitExpression$1 | BinaryExpression$1 | BlockStatement$1 | BreakStatement$1 | CallExpression$1 | CatchClause$1 | ChainExpression$1 | ClassBody$1 | ClassDeclaration$1 | ClassExpression$1 | ConditionalExpression$1 | ContinueStatement$1 | DebuggerStatement$1 | Decorator$1 | DoWhileStatement$1 | EmptyStatement$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | ExportSpecifier$1 | ExpressionStatement$1 | ForInStatement$1 | ForOfStatement$1 | ForStatement$1 | FunctionDeclaration$1 | FunctionExpression$1 | Identifier$1 | IfStatement$1 | ImportAttribute$1 | ImportDeclaration$1 | ImportDefaultSpecifier$1 | ImportExpression$1 | ImportNamespaceSpecifier$1 | ImportSpecifier$1 | JSXAttribute$1 | JSXClosingElement$1 | JSXClosingFragment$1 | JSXElement$1 | JSXEmptyExpression$1 | JSXExpressionContainer$1 | JSXFragment$1 | JSXIdentifier$1 | JSXMemberExpression$1 | JSXNamespacedName$1 | JSXOpeningElement$1 | JSXOpeningFragment$1 | JSXSpreadAttribute$1 | JSXSpreadChild$1 | JSXText$1 | LabeledStatement$1 | Literal$1 | LogicalExpression$1 | MemberExpression$1 | MetaProperty$1 | MethodDefinition$1 | NewExpression$1 | ObjectExpression$1 | ObjectPattern$1 | PrivateIdentifier$1 | Program$1 | Property$1 | PropertyDefinition$1 | RestElement$1 | ReturnStatement$1 | SequenceExpression$1 | SpreadElement$1 | StaticBlock$1 | Super$1 | SwitchCase$1 | SwitchStatement$1 | TaggedTemplateExpression$1 | TemplateElement$1 | TemplateLiteral$1 | ThisExpression$1 | ThrowStatement$1 | TryStatement$1 | TSAbstractAccessorProperty$1 | TSAbstractKeyword$1 | TSAbstractMethodDefinition$1 | TSAbstractPropertyDefinition$1 | TSAnyKeyword$1 | TSArrayType$1 | TSAsExpression$1 | TSAsyncKeyword$1 | TSBigIntKeyword$1 | TSBooleanKeyword$1 | TSCallSignatureDeclaration$1 | TSClassImplements$1 | TSConditionalType$1 | TSConstructorType$1 | TSConstructSignatureDeclaration$1 | TSDeclareFunction$1 | TSDeclareKeyword$1 | TSEmptyBodyFunctionExpression$1 | TSEnumBody$1 | TSEnumDeclaration$1 | TSEnumMember$1 | TSExportAssignment$1 | TSExportKeyword$1 | TSExternalModuleReference$1 | TSFunctionType$1 | TSImportEqualsDeclaration$1 | TSImportType$1 | TSIndexedAccessType$1 | TSIndexSignature$1 | TSInferType$1 | TSInstantiationExpression$1 | TSInterfaceBody$1 | TSInterfaceDeclaration$1 | TSInterfaceHeritage$1 | TSIntersectionType$1 | TSIntrinsicKeyword$1 | TSLiteralType$1 | TSMappedType$1 | TSMethodSignature$1 | TSModuleBlock$1 | TSModuleDeclaration$1 | TSNamedTupleMember$1 | TSNamespaceExportDeclaration$1 | TSNeverKeyword$1 | TSNonNullExpression$1 | TSNullKeyword$1 | TSNumberKeyword$1 | TSObjectKeyword$1 | TSOptionalType$1 | TSParameterProperty$1 | TSPrivateKeyword$1 | TSPropertySignature$1 | TSProtectedKeyword$1 | TSPublicKeyword$1 | TSQualifiedName$1 | TSReadonlyKeyword$1 | TSRestType$1 | TSSatisfiesExpression$1 | TSStaticKeyword$1 | TSStringKeyword$1 | TSSymbolKeyword$1 | TSTemplateLiteralType$1 | TSThisType$1 | TSTupleType$1 | TSTypeAliasDeclaration$1 | TSTypeAnnotation$1 | TSTypeAssertion$1 | TSTypeLiteral$1 | TSTypeOperator$1 | TSTypeParameter$1 | TSTypeParameterDeclaration$1 | TSTypeParameterInstantiation$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUndefinedKeyword$1 | TSUnionType$1 | TSUnknownKeyword$1 | TSVoidKeyword$1 | UnaryExpression$1 | UpdateExpression$1 | VariableDeclaration$1 | VariableDeclarator$1 | WhileStatement$1 | WithStatement$1 | YieldExpression$1;
-declare interface NodeOrTokenData$1 {
-    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$1;
-    range: Range$1;
-}
-declare interface NullLiteral$1 extends LiteralBase$1 {
-    raw: 'null';
-    value: null;
-}
-declare interface NullToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Null;
-}
-declare interface NumberLiteral$1 extends LiteralBase$1 {
-    value: number;
-}
-declare interface NumericToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Numeric;
-}
-declare interface ObjectExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ObjectExpression;
-    properties: ObjectLiteralElement$1[];
-}
-declare type ObjectLiteralElement$1 = Property$1 | SpreadElement$1;
-declare interface ObjectPattern$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ObjectPattern;
-    decorators: Decorator$1[];
-    optional: boolean;
-    properties: (Property$1 | RestElement$1)[];
-    typeAnnotation: TSTypeAnnotation$1 | undefined;
-}
-declare type Parameter$1 = ArrayPattern$1 | AssignmentPattern$1 | Identifier$1 | ObjectPattern$1 | RestElement$1 | TSParameterProperty$1;
-declare type ParameterPropertyParameter$1 = (AssignmentPattern$1 & {
-    left: Identifier$1;
-}) | Identifier$1;
-declare interface Position$1 {
-    /**
-     * Column number on the line (0-indexed)
-     */
-    column: number;
-    /**
-     * Line number (1-indexed)
-     */
-    line: number;
-}
-declare interface PrivateIdentifier$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.PrivateIdentifier;
-    name: string;
-}
-declare interface PrivateIdentifierToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.PrivateIdentifier;
-}
-declare interface PrivateInExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.BinaryExpression;
-    left: PrivateIdentifier$1;
-    operator: 'in';
-    right: Expression$1;
-}
-declare interface Program$1 extends NodeOrTokenData$1 {
-    type: AST_NODE_TYPES$1.Program;
-    body: ProgramStatement$1[];
-    comments: Comment$1[] | undefined;
-    sourceType: 'module' | 'script';
-    tokens: Token$1[] | undefined;
-}
-declare type ProgramStatement$1 = ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | ImportDeclaration$1 | Statement$1 | TSImportEqualsDeclaration$1 | TSNamespaceExportDeclaration$1;
-declare type Property$1 = PropertyComputedName$1 | PropertyNonComputedName$1;
-declare interface PropertyBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.Property;
-    computed: boolean;
-    key: PropertyName$1;
-    kind: 'get' | 'init' | 'set';
-    method: boolean;
-    optional: boolean;
-    shorthand: boolean;
-    value: AssignmentPattern$1 | BindingName$1 | Expression$1 | TSEmptyBodyFunctionExpression$1;
-}
-declare interface PropertyComputedName$1 extends PropertyBase$1 {
-    computed: true;
-    key: PropertyNameComputed$1;
-}
-declare type PropertyDefinition$1 = PropertyDefinitionComputedName$1 | PropertyDefinitionNonComputedName$1;
-declare interface PropertyDefinitionBase$1 extends BaseNode$1 {
-    accessibility: Accessibility$1 | undefined;
-    computed: boolean;
-    declare: boolean;
-    decorators: Decorator$1[];
-    definite: boolean;
-    key: PropertyName$1;
-    optional: boolean;
-    override: boolean;
-    readonly: boolean;
-    static: boolean;
-    typeAnnotation: TSTypeAnnotation$1 | undefined;
-    value: Expression$1 | null;
-}
-declare interface PropertyDefinitionComputedName$1 extends PropertyDefinitionComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.PropertyDefinition;
-}
-declare interface PropertyDefinitionComputedNameBase$1 extends PropertyDefinitionBase$1 {
-    computed: true;
-    key: PropertyNameComputed$1;
-}
-declare interface PropertyDefinitionNonComputedName$1 extends ClassPropertyDefinitionNonComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.PropertyDefinition;
-}
-declare interface PropertyDefinitionNonComputedNameBase$1 extends PropertyDefinitionBase$1 {
-    computed: false;
-    key: PropertyNameNonComputed$1;
-}
-declare type PropertyName$1 = ClassPropertyNameNonComputed$1 | PropertyNameComputed$1 | PropertyNameNonComputed$1;
-declare type PropertyNameComputed$1 = Expression$1;
-declare type PropertyNameNonComputed$1 = Identifier$1 | NumberLiteral$1 | StringLiteral$1;
-declare interface PropertyNonComputedName$1 extends PropertyBase$1 {
-    computed: false;
-    key: PropertyNameNonComputed$1;
-}
-declare interface PunctuatorToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Punctuator;
-    value: ValueOf$1<PunctuatorTokenToText$1>;
-}
-declare interface PunctuatorTokenToText$1 extends AssignmentOperatorToText$1 {
-    [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$1 = [number, number];
-declare interface RegExpLiteral$1 extends LiteralBase$1 {
-    regex: {
-        flags: string;
-        pattern: string;
-    };
-    value: RegExp | null;
-}
-declare interface RegularExpressionToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.RegularExpression;
-    regex: {
-        flags: string;
-        pattern: string;
-    };
-}
-declare interface RestElement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.RestElement;
-    argument: DestructuringPattern$1;
-    decorators: Decorator$1[];
-    optional: boolean;
-    typeAnnotation: TSTypeAnnotation$1 | undefined;
-    value: AssignmentPattern$1 | undefined;
-}
-declare interface ReturnStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ReturnStatement;
-    argument: Expression$1 | null;
-}
-declare interface SequenceExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.SequenceExpression;
-    expressions: Expression$1[];
-}
-declare interface SourceLocation$1 {
-    /**
-     * The position of the first character after the parsed source region
-     */
-    end: Position$1;
-    /**
-     * The position of the first character of the parsed source region
-     */
-    start: Position$1;
-}
-declare interface SpreadElement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.SpreadElement;
-    argument: Expression$1;
-}
-declare type Statement$1 = BlockStatement$1 | BreakStatement$1 | ClassDeclarationWithName$1 | ContinueStatement$1 | DebuggerStatement$1 | DoWhileStatement$1 | EmptyStatement$1 | ExportAllDeclaration$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | ExpressionStatement$1 | ForInStatement$1 | ForOfStatement$1 | ForStatement$1 | FunctionDeclarationWithName$1 | IfStatement$1 | ImportDeclaration$1 | LabeledStatement$1 | ReturnStatement$1 | SwitchStatement$1 | ThrowStatement$1 | TryStatement$1 | TSDeclareFunction$1 | TSEnumDeclaration$1 | TSExportAssignment$1 | TSImportEqualsDeclaration$1 | TSInterfaceDeclaration$1 | TSModuleDeclaration$1 | TSNamespaceExportDeclaration$1 | TSTypeAliasDeclaration$1 | VariableDeclaration$1 | WhileStatement$1 | WithStatement$1;
-declare interface StaticBlock$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.StaticBlock;
-    body: Statement$1[];
-}
-declare interface StringLiteral$1 extends LiteralBase$1 {
-    value: string;
-}
-declare interface StringToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.String;
-}
-declare interface Super$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.Super;
-}
-declare interface SwitchCase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.SwitchCase;
-    consequent: Statement$1[];
-    test: Expression$1 | null;
-}
-declare interface SwitchStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.SwitchStatement;
-    cases: SwitchCase$1[];
-    discriminant: Expression$1;
-}
-declare interface SymmetricBinaryExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.BinaryExpression;
-    left: Expression$1;
-    operator: ValueOf$1<BinaryOperatorToText$1>;
-    right: Expression$1;
-}
-declare interface TaggedTemplateExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TaggedTemplateExpression;
-    quasi: TemplateLiteral$1;
-    tag: Expression$1;
-    typeArguments: TSTypeParameterInstantiation$1 | undefined;
-}
-declare interface TemplateElement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TemplateElement;
-    tail: boolean;
-    value: {
-        cooked: string;
-        raw: string;
-    };
-}
-declare interface TemplateLiteral$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TemplateLiteral;
-    expressions: Expression$1[];
-    quasis: TemplateElement$1[];
-}
-declare interface TemplateToken$1 extends BaseToken$1 {
-    type: AST_TOKEN_TYPES$1.Template;
-}
-declare interface ThisExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ThisExpression;
-}
-declare interface ThrowStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.ThrowStatement;
-    argument: Expression$1;
-}
-declare type Token$1 = BooleanToken$1 | Comment$1 | IdentifierToken$1 | JSXIdentifierToken$1 | JSXTextToken$1 | KeywordToken$1 | NullToken$1 | NumericToken$1 | PrivateIdentifierToken$1 | PunctuatorToken$1 | RegularExpressionToken$1 | StringToken$1 | TemplateToken$1;
-declare interface TryStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TryStatement;
-    block: BlockStatement$1;
-    finalizer: BlockStatement$1 | null;
-    handler: CatchClause$1 | null;
-}
-declare type TSAbstractAccessorProperty$1 = TSAbstractAccessorPropertyComputedName$1 | TSAbstractAccessorPropertyNonComputedName$1;
-declare interface TSAbstractAccessorPropertyComputedName$1 extends PropertyDefinitionComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.TSAbstractAccessorProperty;
-    value: null;
-}
-declare interface TSAbstractAccessorPropertyNonComputedName$1 extends PropertyDefinitionNonComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.TSAbstractAccessorProperty;
-    value: null;
-}
-declare interface TSAbstractKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSAbstractKeyword;
-}
-declare type TSAbstractMethodDefinition$1 = TSAbstractMethodDefinitionComputedName$1 | TSAbstractMethodDefinitionNonComputedName$1;
-declare interface TSAbstractMethodDefinitionComputedName$1 extends MethodDefinitionComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.TSAbstractMethodDefinition;
-}
-declare interface TSAbstractMethodDefinitionNonComputedName$1 extends MethodDefinitionNonComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.TSAbstractMethodDefinition;
-}
-declare type TSAbstractPropertyDefinition$1 = TSAbstractPropertyDefinitionComputedName$1 | TSAbstractPropertyDefinitionNonComputedName$1;
-declare interface TSAbstractPropertyDefinitionComputedName$1 extends PropertyDefinitionComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.TSAbstractPropertyDefinition;
-    value: null;
-}
-declare interface TSAbstractPropertyDefinitionNonComputedName$1 extends PropertyDefinitionNonComputedNameBase$1 {
-    type: AST_NODE_TYPES$1.TSAbstractPropertyDefinition;
-    value: null;
-}
-declare interface TSAnyKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSAnyKeyword;
-}
-declare interface TSArrayType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSArrayType;
-    elementType: TypeNode$1;
-}
-declare interface TSAsExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSAsExpression;
-    expression: Expression$1;
-    typeAnnotation: TypeNode$1;
-}
-declare interface TSAsyncKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSAsyncKeyword;
-}
-declare interface TSBigIntKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSBigIntKeyword;
-}
-declare interface TSBooleanKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSBooleanKeyword;
-}
-declare interface TSCallSignatureDeclaration$1 extends TSFunctionSignatureBase$1 {
-    type: AST_NODE_TYPES$1.TSCallSignatureDeclaration;
-}
-declare interface TSClassImplements$1 extends TSHeritageBase$1 {
-    type: AST_NODE_TYPES$1.TSClassImplements;
-}
-declare interface TSConditionalType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSConditionalType;
-    checkType: TypeNode$1;
-    extendsType: TypeNode$1;
-    falseType: TypeNode$1;
-    trueType: TypeNode$1;
-}
-declare interface TSConstructorType$1 extends TSFunctionSignatureBase$1 {
-    type: AST_NODE_TYPES$1.TSConstructorType;
-    abstract: boolean;
-}
-declare interface TSConstructSignatureDeclaration$1 extends TSFunctionSignatureBase$1 {
-    type: AST_NODE_TYPES$1.TSConstructSignatureDeclaration;
-}
-declare type TSDeclareFunction$1 = TSDeclareFunctionNoDeclare$1 | TSDeclareFunctionWithDeclare$1;
-declare interface TSDeclareFunctionBase$1 extends FunctionBase$1 {
-    type: AST_NODE_TYPES$1.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$1 extends TSDeclareFunctionBase$1 {
-    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$1 extends TSDeclareFunctionBase$1 {
-    /**
-     * 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$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSDeclareKeyword;
-}
-declare interface TSEmptyBodyFunctionExpression$1 extends FunctionBase$1 {
-    type: AST_NODE_TYPES$1.TSEmptyBodyFunctionExpression;
-    body: null;
-    id: null;
-}
-declare interface TSEnumBody$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSEnumBody;
-    members: TSEnumMember$1[];
-}
-declare interface TSEnumDeclaration$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSEnumDeclaration;
-    /**
-     * The body of the enum.
-     */
-    body: TSEnumBody$1;
-    /**
-     * 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$1;
-    /**
-     * The enum members.
-     * @deprecated Use {@link body} instead.
-     */
-    members: TSEnumMember$1[];
-}
-declare interface TSEnumMember$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSEnumMember;
-    id: Identifier$1 | StringLiteral$1;
-    initializer: Expression$1 | undefined;
-    /**
-     * @deprecated the enum member is always non-computed.
-     */
-    computed: boolean;
-}
-declare interface TSExportAssignment$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSExportAssignment;
-    expression: Expression$1;
-}
-declare interface TSExportKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSExportKeyword;
-}
-declare interface TSExternalModuleReference$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSExternalModuleReference;
-    expression: StringLiteral$1;
-}
-declare interface TSFunctionSignatureBase$1 extends BaseNode$1 {
-    params: Parameter$1[];
-    returnType: TSTypeAnnotation$1 | undefined;
-    typeParameters: TSTypeParameterDeclaration$1 | undefined;
-}
-declare interface TSFunctionType$1 extends TSFunctionSignatureBase$1 {
-    type: AST_NODE_TYPES$1.TSFunctionType;
-}
-declare interface TSHeritageBase$1 extends BaseNode$1 {
-    expression: Expression$1;
-    typeArguments: TSTypeParameterInstantiation$1 | undefined;
-}
-declare type TSImportEqualsDeclaration$1 = TSImportEqualsNamespaceDeclaration$1 | TSImportEqualsRequireDeclaration$1;
-declare interface TSImportEqualsDeclarationBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSImportEqualsDeclaration;
-    /**
-     * The locally imported name.
-     */
-    id: Identifier$1;
-    /**
-     * The kind of the import. Always `'value'` unless `moduleReference` is a
-     * `TSExternalModuleReference`.
-     */
-    importKind: ImportKind$1;
-    /**
-     * The value being aliased.
-     * @example
-     * ```ts
-     * import F1 = A;
-     * import F2 = A.B.C;
-     * import F3 = require('mod');
-     * ```
-     */
-    moduleReference: Identifier$1 | TSExternalModuleReference$1 | TSQualifiedName$1;
-}
-declare interface TSImportEqualsNamespaceDeclaration$1 extends TSImportEqualsDeclarationBase$1 {
-    /**
-     * The kind of the import.
-     */
-    importKind: 'value';
-    /**
-     * The value being aliased.
-     * ```
-     * import F1 = A;
-     * import F2 = A.B.C;
-     * ```
-     */
-    moduleReference: Identifier$1 | TSQualifiedName$1;
-}
-declare interface TSImportEqualsRequireDeclaration$1 extends TSImportEqualsDeclarationBase$1 {
-    /**
-     * The kind of the import.
-     */
-    importKind: ImportKind$1;
-    /**
-     * The value being aliased.
-     * ```
-     * import F3 = require('mod');
-     * ```
-     */
-    moduleReference: TSExternalModuleReference$1;
-}
-declare interface TSImportType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSImportType;
-    /** @deprecated Use {@link `source`} instead. */
-    argument: TypeNode$1;
-    options: ObjectExpression$1 | null;
-    qualifier: EntityName$1 | null;
-    source: StringLiteral$1;
-    typeArguments: TSTypeParameterInstantiation$1 | null;
-}
-declare interface TSIndexedAccessType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSIndexedAccessType;
-    indexType: TypeNode$1;
-    objectType: TypeNode$1;
-}
-declare interface TSIndexSignature$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSIndexSignature;
-    accessibility: Accessibility$1 | undefined;
-    parameters: Parameter$1[];
-    readonly: boolean;
-    static: boolean;
-    typeAnnotation: TSTypeAnnotation$1 | undefined;
-}
-declare interface TSInferType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSInferType;
-    typeParameter: TSTypeParameter$1;
-}
-declare interface TSInstantiationExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSInstantiationExpression;
-    expression: Expression$1;
-    typeArguments: TSTypeParameterInstantiation$1;
-}
-declare interface TSInterfaceBody$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSInterfaceBody;
-    body: TypeElement$1[];
-}
-declare interface TSInterfaceDeclaration$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSInterfaceDeclaration;
-    /**
-     * The body of the interface
-     */
-    body: TSInterfaceBody$1;
-    /**
-     * Whether the interface was `declare`d
-     */
-    declare: boolean;
-    /**
-     * The types this interface `extends`
-     */
-    extends: TSInterfaceHeritage$1[];
-    /**
-     * The name of this interface
-     */
-    id: Identifier$1;
-    /**
-     * The generic type parameters declared for the interface. Empty declaration
-     * (`<>`) is different from no declaration.
-     */
-    typeParameters: TSTypeParameterDeclaration$1 | undefined;
-}
-declare interface TSInterfaceHeritage$1 extends TSHeritageBase$1 {
-    type: AST_NODE_TYPES$1.TSInterfaceHeritage;
-}
-declare interface TSIntersectionType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSIntersectionType;
-    types: TypeNode$1[];
-}
-declare interface TSIntrinsicKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSIntrinsicKeyword;
-}
-declare interface TSLiteralType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSLiteralType;
-    literal: Exclude<LiteralExpression$1, NullLiteral$1 | RegExpLiteral$1> | UnaryExpressionMinus$1 | UnaryExpressionPlus$1;
-}
-declare interface TSMappedType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSMappedType;
-    constraint: TypeNode$1;
-    key: Identifier$1;
-    nameType: TypeNode$1 | null;
-    optional: boolean | '+' | '-' | undefined;
-    readonly: boolean | '+' | '-' | undefined;
-    typeAnnotation: TypeNode$1 | undefined;
-    /** @deprecated Use {@link `constraint`} and {@link `key`} instead. */
-    typeParameter: TSTypeParameter$1;
-}
-declare type TSMethodSignature$1 = TSMethodSignatureComputedName$1 | TSMethodSignatureNonComputedName$1;
-declare interface TSMethodSignatureBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSMethodSignature;
-    accessibility: Accessibility$1 | undefined;
-    computed: boolean;
-    key: PropertyName$1;
-    kind: 'get' | 'method' | 'set';
-    optional: boolean;
-    params: Parameter$1[];
-    readonly: boolean;
-    returnType: TSTypeAnnotation$1 | undefined;
-    static: boolean;
-    typeParameters: TSTypeParameterDeclaration$1 | undefined;
-}
-declare interface TSMethodSignatureComputedName$1 extends TSMethodSignatureBase$1 {
-    computed: true;
-    key: PropertyNameComputed$1;
-}
-declare interface TSMethodSignatureNonComputedName$1 extends TSMethodSignatureBase$1 {
-    computed: false;
-    key: PropertyNameNonComputed$1;
-}
-declare interface TSModuleBlock$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSModuleBlock;
-    body: ProgramStatement$1[];
-}
-declare type TSModuleDeclaration$1 = TSModuleDeclarationGlobal$1 | TSModuleDeclarationModule$1 | TSModuleDeclarationNamespace$1;
-declare interface TSModuleDeclarationBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSModuleDeclaration;
-    /**
-     * The body of the module.
-     * This can only be `undefined` for the code `declare module 'mod';`
-     */
-    body?: TSModuleBlock$1;
-    /**
-     * 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$1 | Literal$1 | TSQualifiedName$1;
-    /**
-     * The keyword used to define this module declaration
-     * @example
-     * ```ts
-     * namespace Foo {}
-     * ^^^^^^^^^
-     *
-     * module 'foo' {}
-     * ^^^^^^
-     *
-     * global {}
-     * ^^^^^^
-     * ```
-     */
-    kind: TSModuleDeclarationKind$1;
-}
-declare interface TSModuleDeclarationGlobal$1 extends TSModuleDeclarationBase$1 {
-    body: TSModuleBlock$1;
-    /**
-     * This will always be an Identifier with name `global`
-     */
-    id: Identifier$1;
-    kind: 'global';
-}
-declare type TSModuleDeclarationKind$1 = 'global' | 'module' | 'namespace';
-declare type TSModuleDeclarationModule$1 = TSModuleDeclarationModuleWithIdentifierId$1 | TSModuleDeclarationModuleWithStringId$1;
-declare interface TSModuleDeclarationModuleBase$1 extends TSModuleDeclarationBase$1 {
-    kind: 'module';
-}
-/**
- * The legacy module declaration, replaced with namespace declarations.
- * ```
- * module A {}
- * ```
- */
-declare interface TSModuleDeclarationModuleWithIdentifierId$1 extends TSModuleDeclarationModuleBase$1 {
-    body: TSModuleBlock$1;
-    id: Identifier$1;
-    kind: 'module';
-}
-declare type TSModuleDeclarationModuleWithStringId$1 = TSModuleDeclarationModuleWithStringIdDeclared$1 | TSModuleDeclarationModuleWithStringIdNotDeclared$1;
-/**
- * A string module declaration that is declared:
- * ```
- * declare module 'foo' {}
- * declare module 'foo';
- * ```
- */
-declare interface TSModuleDeclarationModuleWithStringIdDeclared$1 extends TSModuleDeclarationModuleBase$1 {
-    body?: TSModuleBlock$1;
-    declare: true;
-    id: StringLiteral$1;
-    kind: 'module';
-}
-/**
- * A string module declaration that is not declared:
- * ```
- * module 'foo' {}
- * ```
- */
-declare interface TSModuleDeclarationModuleWithStringIdNotDeclared$1 extends TSModuleDeclarationModuleBase$1 {
-    body: TSModuleBlock$1;
-    declare: false;
-    id: StringLiteral$1;
-    kind: 'module';
-}
-declare interface TSModuleDeclarationNamespace$1 extends TSModuleDeclarationBase$1 {
-    body: TSModuleBlock$1;
-    id: Identifier$1 | TSQualifiedName$1;
-    kind: 'namespace';
-}
-declare interface TSNamedTupleMember$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSNamedTupleMember;
-    elementType: TypeNode$1;
-    label: Identifier$1;
-    optional: boolean;
-}
-/**
- * For the following declaration:
- * ```
- * export as namespace X;
- * ```
- */
-declare interface TSNamespaceExportDeclaration$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSNamespaceExportDeclaration;
-    /**
-     * The name of the global variable that's exported as namespace
-     */
-    id: Identifier$1;
-}
-declare interface TSNeverKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSNeverKeyword;
-}
-declare interface TSNonNullExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSNonNullExpression;
-    expression: Expression$1;
-}
-declare interface TSNullKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSNullKeyword;
-}
-declare interface TSNumberKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSNumberKeyword;
-}
-declare interface TSObjectKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSObjectKeyword;
-}
-declare interface TSOptionalType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSOptionalType;
-    typeAnnotation: TypeNode$1;
-}
-declare interface TSParameterProperty$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSParameterProperty;
-    accessibility: Accessibility$1 | undefined;
-    decorators: Decorator$1[];
-    override: boolean;
-    parameter: ParameterPropertyParameter$1;
-    readonly: boolean;
-    static: boolean;
-}
-declare interface TSPrivateKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSPrivateKeyword;
-}
-declare type TSPropertySignature$1 = TSPropertySignatureComputedName$1 | TSPropertySignatureNonComputedName$1;
-declare interface TSPropertySignatureBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSPropertySignature;
-    accessibility: Accessibility$1 | undefined;
-    computed: boolean;
-    key: PropertyName$1;
-    optional: boolean;
-    readonly: boolean;
-    static: boolean;
-    typeAnnotation: TSTypeAnnotation$1 | undefined;
-}
-declare interface TSPropertySignatureComputedName$1 extends TSPropertySignatureBase$1 {
-    computed: true;
-    key: PropertyNameComputed$1;
-}
-declare interface TSPropertySignatureNonComputedName$1 extends TSPropertySignatureBase$1 {
-    computed: false;
-    key: PropertyNameNonComputed$1;
-}
-declare interface TSProtectedKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSProtectedKeyword;
-}
-declare interface TSPublicKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSPublicKeyword;
-}
-declare interface TSQualifiedName$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSQualifiedName;
-    left: EntityName$1;
-    right: Identifier$1;
-}
-declare interface TSReadonlyKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSReadonlyKeyword;
-}
-declare interface TSRestType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSRestType;
-    typeAnnotation: TypeNode$1;
-}
-declare interface TSSatisfiesExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSSatisfiesExpression;
-    expression: Expression$1;
-    typeAnnotation: TypeNode$1;
-}
-declare interface TSStaticKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSStaticKeyword;
-}
-declare interface TSStringKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSStringKeyword;
-}
-declare interface TSSymbolKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSSymbolKeyword;
-}
-declare interface TSTemplateLiteralType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTemplateLiteralType;
-    quasis: TemplateElement$1[];
-    types: TypeNode$1[];
-}
-declare interface TSThisType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSThisType;
-}
-declare interface TSTupleType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTupleType;
-    elementTypes: TypeNode$1[];
-}
-declare interface TSTypeAliasDeclaration$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeAliasDeclaration;
-    /**
-     * Whether the type was `declare`d.
-     * @example
-     * ```ts
-     * declare type T = 1;
-     * ```
-     */
-    declare: boolean;
-    /**
-     * The name of the type.
-     */
-    id: Identifier$1;
-    /**
-     * The "value" (type) of the declaration
-     */
-    typeAnnotation: TypeNode$1;
-    /**
-     * The generic type parameters declared for the type. Empty declaration
-     * (`<>`) is different from no declaration.
-     */
-    typeParameters: TSTypeParameterDeclaration$1 | undefined;
-}
-declare interface TSTypeAnnotation$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeAnnotation;
-    typeAnnotation: TypeNode$1;
-}
-declare interface TSTypeAssertion$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeAssertion;
-    expression: Expression$1;
-    typeAnnotation: TypeNode$1;
-}
-declare interface TSTypeLiteral$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeLiteral;
-    members: TypeElement$1[];
-}
-declare interface TSTypeOperator$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeOperator;
-    operator: 'keyof' | 'readonly' | 'unique';
-    typeAnnotation: TypeNode$1 | undefined;
-}
-declare interface TSTypeParameter$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeParameter;
-    const: boolean;
-    constraint: TypeNode$1 | undefined;
-    default: TypeNode$1 | undefined;
-    in: boolean;
-    name: Identifier$1;
-    out: boolean;
-}
-declare interface TSTypeParameterDeclaration$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeParameterDeclaration;
-    params: TSTypeParameter$1[];
-}
-declare interface TSTypeParameterInstantiation$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeParameterInstantiation;
-    params: TypeNode$1[];
-}
-declare interface TSTypePredicate$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypePredicate;
-    asserts: boolean;
-    parameterName: Identifier$1 | TSThisType$1;
-    typeAnnotation: TSTypeAnnotation$1 | null;
-}
-declare interface TSTypeQuery$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeQuery;
-    exprName: EntityName$1 | TSImportType$1;
-    typeArguments: TSTypeParameterInstantiation$1 | undefined;
-}
-declare interface TSTypeReference$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSTypeReference;
-    typeArguments: TSTypeParameterInstantiation$1 | undefined;
-    typeName: EntityName$1;
-}
-declare interface TSUndefinedKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSUndefinedKeyword;
-}
-declare interface TSUnionType$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSUnionType;
-    types: TypeNode$1[];
-}
-declare interface TSUnknownKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSUnknownKeyword;
-}
-declare interface TSVoidKeyword$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.TSVoidKeyword;
-}
-declare type TypeElement$1 = TSCallSignatureDeclaration$1 | TSConstructSignatureDeclaration$1 | TSIndexSignature$1 | TSMethodSignature$1 | TSPropertySignature$1;
-declare type TypeNode$1 = TSAbstractKeyword$1 | TSAnyKeyword$1 | TSArrayType$1 | TSAsyncKeyword$1 | TSBigIntKeyword$1 | TSBooleanKeyword$1 | TSConditionalType$1 | TSConstructorType$1 | TSDeclareKeyword$1 | TSExportKeyword$1 | TSFunctionType$1 | TSImportType$1 | TSIndexedAccessType$1 | TSInferType$1 | TSIntersectionType$1 | TSIntrinsicKeyword$1 | TSLiteralType$1 | TSMappedType$1 | TSNamedTupleMember$1 | TSNeverKeyword$1 | TSNullKeyword$1 | TSNumberKeyword$1 | TSObjectKeyword$1 | TSOptionalType$1 | TSPrivateKeyword$1 | TSProtectedKeyword$1 | TSPublicKeyword$1 | TSQualifiedName$1 | TSReadonlyKeyword$1 | TSRestType$1 | TSStaticKeyword$1 | TSStringKeyword$1 | TSSymbolKeyword$1 | TSTemplateLiteralType$1 | TSThisType$1 | TSTupleType$1 | TSTypeLiteral$1 | TSTypeOperator$1 | TSTypePredicate$1 | TSTypeQuery$1 | TSTypeReference$1 | TSUndefinedKeyword$1 | TSUnionType$1 | TSUnknownKeyword$1 | TSVoidKeyword$1;
-declare type UnaryExpression$1 = UnaryExpressionBitwiseNot$1 | UnaryExpressionDelete$1 | UnaryExpressionMinus$1 | UnaryExpressionNot$1 | UnaryExpressionPlus$1 | UnaryExpressionTypeof$1 | UnaryExpressionVoid$1;
-declare interface UnaryExpressionBase$1 extends BaseNode$1 {
-    argument: Expression$1;
-    operator: string;
-    prefix: boolean;
-}
-declare type UnaryExpressionBitwiseNot$1 = UnaryExpressionSpecific$1<'~'>;
-declare type UnaryExpressionDelete$1 = UnaryExpressionSpecific$1<'delete'>;
-declare type UnaryExpressionMinus$1 = UnaryExpressionSpecific$1<'-'>;
-declare type UnaryExpressionNot$1 = UnaryExpressionSpecific$1<'!'>;
-declare type UnaryExpressionPlus$1 = UnaryExpressionSpecific$1<'+'>;
-declare interface UnaryExpressionSpecific$1<T extends string> extends UnaryExpressionBase$1 {
-    type: AST_NODE_TYPES$1.UnaryExpression;
-    operator: T;
-}
-declare type UnaryExpressionTypeof$1 = UnaryExpressionSpecific$1<'typeof'>;
-declare type UnaryExpressionVoid$1 = UnaryExpressionSpecific$1<'void'>;
-declare interface UpdateExpression$1 extends UnaryExpressionBase$1 {
-    type: AST_NODE_TYPES$1.UpdateExpression;
-    operator: '++' | '--';
-}
-declare type UsingDeclaration$1 = UsingInForOfDeclaration$1 | UsingInNormalContextDeclaration$1;
-declare interface UsingDeclarationBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.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$1 = UsingInForOfDeclarator$1 | UsingInNormalContextDeclarator$1;
-declare interface UsingInForOfDeclaration$1 extends UsingDeclarationBase$1 {
-    /**
-     * The variables declared by this declaration.
-     * Always has exactly one element.
-     * @example
-     * ```ts
-     * for (using x of y) {}
-     * ```
-     */
-    declarations: [UsingInForOfDeclarator$1];
-}
-declare interface UsingInForOfDeclarator$1 extends VariableDeclaratorBase$1 {
-    definite: false;
-    id: Identifier$1;
-    init: null;
-}
-declare interface UsingInNormalContextDeclaration$1 extends UsingDeclarationBase$1 {
-    /**
-     * The variables declared by this declaration.
-     * Always non-empty.
-     * @example
-     * ```ts
-     * using x = 1;
-     * using y = 1, z = 2;
-     * ```
-     */
-    declarations: UsingInNormalContextDeclarator$1[];
-}
-declare interface UsingInNormalContextDeclarator$1 extends VariableDeclaratorBase$1 {
-    definite: false;
-    id: Identifier$1;
-    init: Expression$1;
-}
-declare type ValueOf$1<T> = T[keyof T];
-declare type VariableDeclaration$1 = LetOrConstOrVarDeclaration$1 | UsingDeclaration$1;
-declare type VariableDeclarator$1 = LetOrConstOrVarDeclarator$1 | UsingDeclarator$1;
-declare interface VariableDeclaratorBase$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.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$1;
-    /**
-     * The initializer expression of the variable. Must be present for `const` unless
-     * in a `declare const`.
-     */
-    init: Expression$1 | null;
-}
-declare interface VariableDeclaratorDefiniteAssignment$1 extends VariableDeclaratorBase$1 {
-    definite: true;
-    /**
-     * The name of the variable. Must have a type annotation.
-     */
-    id: Identifier$1;
-    init: null;
-}
-declare interface VariableDeclaratorMaybeInit$1 extends VariableDeclaratorBase$1 {
-    definite: false;
-}
-declare interface VariableDeclaratorNoInit$1 extends VariableDeclaratorBase$1 {
-    definite: false;
-    init: null;
-}
-declare interface WhileStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.WhileStatement;
-    body: Statement$1;
-    test: Expression$1;
-}
-declare interface WithStatement$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.WithStatement;
-    body: Statement$1;
-    object: Expression$1;
-}
-declare interface YieldExpression$1 extends BaseNode$1 {
-    type: AST_NODE_TYPES$1.YieldExpression;
-    argument: Expression$1 | null;
-    delegate: boolean;
-}
-
-type Lib = 'decorators' | 'decorators.legacy' | 'dom' | 'dom.asynciterable' | 'dom.iterable' | 'es5' | 'es6' | 'es7' | 'es2015' | 'es2015.collection' | 'es2015.core' | 'es2015.generator' | 'es2015.iterable' | 'es2015.promise' | 'es2015.proxy' | 'es2015.reflect' | 'es2015.symbol' | 'es2015.symbol.wellknown' | 'es2016' | 'es2016.array.include' | 'es2016.full' | 'es2016.intl' | 'es2017' | 'es2017.arraybuffer' | 'es2017.date' | 'es2017.full' | 'es2017.intl' | 'es2017.object' | 'es2017.sharedmemory' | 'es2017.string' | 'es2017.typedarrays' | 'es2018' | 'es2018.asyncgenerator' | 'es2018.asynciterable' | 'es2018.full' | 'es2018.intl' | 'es2018.promise' | 'es2018.regexp' | 'es2019' | 'es2019.array' | 'es2019.full' | 'es2019.intl' | 'es2019.object' | 'es2019.string' | 'es2019.symbol' | 'es2020' | 'es2020.bigint' | 'es2020.date' | 'es2020.full' | 'es2020.intl' | 'es2020.number' | 'es2020.promise' | 'es2020.sharedmemory' | 'es2020.string' | 'es2020.symbol.wellknown' | 'es2021' | 'es2021.full' | 'es2021.intl' | 'es2021.promise' | 'es2021.string' | 'es2021.weakref' | 'es2022' | 'es2022.array' | 'es2022.error' | 'es2022.full' | 'es2022.intl' | 'es2022.object' | 'es2022.regexp' | 'es2022.string' | 'es2023' | 'es2023.array' | 'es2023.collection' | 'es2023.full' | 'es2023.intl' | 'es2024' | 'es2024.arraybuffer' | 'es2024.collection' | 'es2024.full' | 'es2024.object' | 'es2024.promise' | 'es2024.regexp' | 'es2024.sharedmemory' | 'es2024.string' | 'esnext' | 'esnext.array' | 'esnext.asynciterable' | 'esnext.bigint' | 'esnext.collection' | 'esnext.decorators' | 'esnext.disposable' | 'esnext.error' | 'esnext.float16' | 'esnext.full' | 'esnext.intl' | 'esnext.iterator' | 'esnext.object' | 'esnext.promise' | 'esnext.regexp' | 'esnext.sharedmemory' | 'esnext.string' | 'esnext.symbol' | 'esnext.weakref' | 'lib' | 'scripthost' | 'webworker' | 'webworker.asynciterable' | 'webworker.importscripts' | 'webworker.iterable';
-
-type DebugLevel = boolean | ('eslint' | 'typescript' | 'typescript-eslint')[];
-type CacheDurationSeconds = number | 'Infinity';
-type EcmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | 'latest' | undefined;
-type SourceTypeClassic = 'module' | 'script';
-type SourceType = 'commonjs' | SourceTypeClassic;
-type JSDocParsingMode = 'all' | 'none' | 'type-info';
-/**
- * Granular options to configure the project service.
- */
-interface ProjectServiceOptions {
-    /**
-     * Globs of files to allow running with the default project compiler options
-     * despite not being matched by the project service.
-     */
-    allowDefaultProject?: string[];
-    /**
-     * Path to a TSConfig to use instead of TypeScript's default project configuration.
-     * @default 'tsconfig.json'
-     */
-    defaultProject?: string;
-    /**
-     * Whether to allow TypeScript plugins as configured in the TSConfig.
-     */
-    loadTypeScriptPlugins?: boolean;
-    /**
-     * The maximum number of files {@link allowDefaultProject} may match.
-     * Each file match slows down linting, so if you do need to use this, please
-     * file an informative issue on typescript-eslint explaining why - so we can
-     * help you avoid using it!
-     * @default 8
-     */
-    maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING?: number;
-}
-interface ParserOptions {
-    [additionalProperties: string]: unknown;
-    cacheLifetime?: {
-        glob?: CacheDurationSeconds;
-    };
-    debugLevel?: DebugLevel;
-    ecmaFeatures?: {
-        [key: string]: unknown;
-        globalReturn?: boolean | undefined;
-        jsx?: boolean | undefined;
-    } | undefined;
-    ecmaVersion?: EcmaVersion;
-    emitDecoratorMetadata?: boolean;
-    errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
-    errorOnUnknownASTType?: boolean;
-    experimentalDecorators?: boolean;
-    extraFileExtensions?: string[];
-    filePath?: string;
-    isolatedDeclarations?: boolean;
-    jsDocParsingMode?: JSDocParsingMode;
-    jsxFragmentName?: string | null;
-    jsxPragma?: string | null;
-    lib?: Lib[];
-    programs?: Program$2[] | null;
-    project?: boolean | string | string[] | null;
-    projectFolderIgnoreList?: string[];
-    projectService?: boolean | ProjectServiceOptions;
-    range?: boolean;
-    sourceType?: SourceType | undefined;
-    tokens?: boolean;
-    tsconfigRootDir?: string;
-    warnOnUnsupportedTypeScriptVersion?: boolean;
-}
-
-declare module "./index" {
-    interface BaseNode {
-        parent: Node$1;
-    }
-    interface Program {
-        /**
-         * @remarks This never-used property exists only as a convenience for code that tries to access node parents repeatedly.
-         */
-        parent?: never;
-    }
-    interface AccessorPropertyComputedName {
-        parent: ClassBody$1;
-    }
-    interface AccessorPropertyNonComputedName {
-        parent: ClassBody$1;
-    }
-    interface TSAbstractAccessorPropertyComputedName {
-        parent: ClassBody$1;
-    }
-    interface TSAbstractAccessorPropertyNonComputedName {
-        parent: ClassBody$1;
-    }
-    interface VariableDeclaratorDefiniteAssignment {
-        parent: VariableDeclaration$1;
-    }
-    interface VariableDeclaratorMaybeInit {
-        parent: VariableDeclaration$1;
-    }
-    interface VariableDeclaratorNoInit {
-        parent: VariableDeclaration$1;
-    }
-    interface UsingInForOfDeclarator {
-        parent: VariableDeclaration$1;
-    }
-    interface UsingInNormalContextDeclarator {
-        parent: VariableDeclaration$1;
-    }
-    interface CatchClause {
-        parent: TryStatement$1;
-    }
-    interface ClassBody {
-        parent: ClassDeclaration$1 | ClassExpression$1;
-    }
-    interface ImportAttribute {
-        parent: ExportAllDeclaration$1 | ExportNamedDeclaration$1 | ImportDeclaration$1 | TSImportType$1;
-    }
-    interface ImportDefaultSpecifier {
-        parent: ImportDeclaration$1;
-    }
-    interface ImportNamespaceSpecifier {
-        parent: ImportDeclaration$1;
-    }
-    interface ImportSpecifier {
-        parent: ExportAllDeclaration$1 | ExportNamedDeclaration$1 | ImportDeclaration$1;
-    }
-    interface ExportDefaultDeclaration {
-        parent: BlockStatement$1 | Program$1 | TSModuleBlock$1;
-    }
-    interface ExportNamedDeclarationWithoutSourceWithMultiple {
-        parent: BlockStatement$1 | Program$1 | TSModuleBlock$1;
-    }
-    interface ExportNamedDeclarationWithoutSourceWithSingle {
-        parent: BlockStatement$1 | Program$1 | TSModuleBlock$1;
-    }
-    interface ExportNamedDeclarationWithSource {
-        parent: BlockStatement$1 | Program$1 | TSModuleBlock$1;
-    }
-    interface FunctionDeclarationWithName {
-        parent: BlockStatement$1 | ExportDefaultDeclaration$1 | ExportNamedDeclaration$1 | Program$1;
-    }
-    interface FunctionDeclarationWithOptionalName {
-        parent: ExportDefaultDeclaration$1;
-    }
-    interface JSXAttribute {
-        parent: JSXOpeningElement$1;
-    }
-    interface JSXClosingElement {
-        parent: JSXElement$1;
-    }
-    interface JSXClosingFragment {
-        parent: JSXFragment$1;
-    }
-    interface JSXOpeningElement {
-        parent: JSXElement$1;
-    }
-    interface JSXOpeningFragment {
-        parent: JSXFragment$1;
-    }
-    interface JSXSpreadAttribute {
-        parent: JSXOpeningElement$1;
-    }
-    interface MethodDefinitionComputedName {
-        parent: ClassBody$1;
-    }
-    interface MethodDefinitionNonComputedName {
-        parent: ClassBody$1;
-    }
-    interface TSAbstractMethodDefinitionComputedName {
-        parent: ClassBody$1;
-    }
-    interface TSAbstractMethodDefinitionNonComputedName {
-        parent: ClassBody$1;
-    }
-    interface PropertyComputedName {
-        parent: ObjectExpression$1 | ObjectPattern$1;
-    }
-    interface PropertyNonComputedName {
-        parent: ObjectExpression$1 | ObjectPattern$1;
-    }
-    interface PropertyDefinitionComputedName {
-        parent: ClassBody$1;
-    }
-    interface PropertyDefinitionNonComputedName {
-        parent: ClassBody$1;
-    }
-    interface TSAbstractPropertyDefinitionComputedName {
-        parent: ClassBody$1;
-    }
-    interface TSAbstractPropertyDefinitionNonComputedName {
-        parent: ClassBody$1;
-    }
-    interface SpreadElement {
-        parent: ArrayExpression$1 | CallExpression$1 | NewExpression$1 | ObjectExpression$1;
-    }
-    interface StaticBlock {
-        parent: ClassBody$1;
-    }
-    interface SwitchCase {
-        parent: SwitchStatement$1;
-    }
-    interface TemplateElement {
-        parent: TemplateLiteral$1 | TSTemplateLiteralType$1;
-    }
-    interface TSCallSignatureDeclaration {
-        parent: TSInterfaceBody$1 | TSTypeLiteral$1;
-    }
-    interface TSConstructSignatureDeclaration {
-        parent: TSInterfaceBody$1 | TSTypeLiteral$1;
-    }
-    interface TSClassImplements {
-        parent: ClassDeclaration$1 | ClassExpression$1;
-    }
-    interface TSEnumBody {
-        parent: TSEnumDeclaration$1;
-    }
-    interface TSEnumMember {
-        parent: TSEnumBody$1;
-    }
-    interface TSIndexSignature {
-        parent: ClassBody$1 | TSInterfaceBody$1 | TSTypeLiteral$1;
-    }
-    interface TSInterfaceBody {
-        parent: TSInterfaceDeclaration$1;
-    }
-    interface TSInterfaceHeritage {
-        parent: TSInterfaceBody$1;
-    }
-    interface TSMethodSignatureComputedName {
-        parent: TSInterfaceBody$1 | TSTypeLiteral$1;
-    }
-    interface TSMethodSignatureNonComputedName {
-        parent: TSInterfaceBody$1 | TSTypeLiteral$1;
-    }
-    interface TSModuleBlock {
-        parent: TSModuleDeclaration$1;
-    }
-    interface TSParameterProperty {
-        parent: FunctionLike$1;
-    }
-    interface TSPropertySignatureComputedName {
-        parent: TSInterfaceBody$1 | TSTypeLiteral$1;
-    }
-    interface TSPropertySignatureNonComputedName {
-        parent: TSInterfaceBody$1 | TSTypeLiteral$1;
-    }
-    interface TSTypeParameter {
-        parent: TSInferType$1 | TSMappedType$1 | TSTypeParameterDeclaration$1;
-    }
-    interface ExportSpecifierWithIdentifierLocal {
-        parent: ExportNamedDeclaration$1;
-    }
-    interface ExportSpecifierWithStringOrLiteralLocal {
-        parent: ExportNamedDeclaration$1;
-    }
-}
-
-type NodeWithParent = Exclude<Node$1, Program$1>;
-
 /**********************************************
  *      DO NOT MODIFY THIS FILE MANUALLY      *
  *                                            *
@@ -4555,6 +2150,75 @@ declare interface YieldExpression extends BaseNode {
     delegate: boolean;
 }
 
+type Lib = 'decorators' | 'decorators.legacy' | 'dom' | 'dom.asynciterable' | 'dom.iterable' | 'es5' | 'es6' | 'es7' | 'es2015' | 'es2015.collection' | 'es2015.core' | 'es2015.generator' | 'es2015.iterable' | 'es2015.promise' | 'es2015.proxy' | 'es2015.reflect' | 'es2015.symbol' | 'es2015.symbol.wellknown' | 'es2016' | 'es2016.array.include' | 'es2016.full' | 'es2016.intl' | 'es2017' | 'es2017.arraybuffer' | 'es2017.date' | 'es2017.full' | 'es2017.intl' | 'es2017.object' | 'es2017.sharedmemory' | 'es2017.string' | 'es2017.typedarrays' | 'es2018' | 'es2018.asyncgenerator' | 'es2018.asynciterable' | 'es2018.full' | 'es2018.intl' | 'es2018.promise' | 'es2018.regexp' | 'es2019' | 'es2019.array' | 'es2019.full' | 'es2019.intl' | 'es2019.object' | 'es2019.string' | 'es2019.symbol' | 'es2020' | 'es2020.bigint' | 'es2020.date' | 'es2020.full' | 'es2020.intl' | 'es2020.number' | 'es2020.promise' | 'es2020.sharedmemory' | 'es2020.string' | 'es2020.symbol.wellknown' | 'es2021' | 'es2021.full' | 'es2021.intl' | 'es2021.promise' | 'es2021.string' | 'es2021.weakref' | 'es2022' | 'es2022.array' | 'es2022.error' | 'es2022.full' | 'es2022.intl' | 'es2022.object' | 'es2022.regexp' | 'es2022.string' | 'es2023' | 'es2023.array' | 'es2023.collection' | 'es2023.full' | 'es2023.intl' | 'es2024' | 'es2024.arraybuffer' | 'es2024.collection' | 'es2024.full' | 'es2024.object' | 'es2024.promise' | 'es2024.regexp' | 'es2024.sharedmemory' | 'es2024.string' | 'es2025' | 'es2025.collection' | 'es2025.float16' | 'es2025.full' | 'es2025.intl' | 'es2025.iterator' | 'es2025.promise' | 'es2025.regexp' | 'esnext' | 'esnext.array' | 'esnext.asynciterable' | 'esnext.bigint' | 'esnext.collection' | 'esnext.date' | 'esnext.decorators' | 'esnext.disposable' | 'esnext.error' | 'esnext.float16' | 'esnext.full' | 'esnext.intl' | 'esnext.iterator' | 'esnext.object' | 'esnext.promise' | 'esnext.regexp' | 'esnext.sharedmemory' | 'esnext.string' | 'esnext.symbol' | 'esnext.temporal' | 'esnext.typedarrays' | 'esnext.weakref' | 'lib' | 'scripthost' | 'webworker' | 'webworker.asynciterable' | 'webworker.importscripts' | 'webworker.iterable';
+
+type DebugLevel = boolean | ('eslint' | 'typescript' | 'typescript-eslint')[];
+type CacheDurationSeconds = number | 'Infinity';
+type EcmaVersion = 3 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022 | 2023 | 2024 | 2025 | 2026 | 'latest' | undefined;
+type SourceTypeClassic = 'module' | 'script';
+type SourceType = 'commonjs' | SourceTypeClassic;
+type JSDocParsingMode = 'all' | 'none' | 'type-info';
+/**
+ * Granular options to configure the project service.
+ */
+interface ProjectServiceOptions {
+    /**
+     * Globs of files to allow running with the default project compiler options
+     * despite not being matched by the project service.
+     */
+    allowDefaultProject?: string[];
+    /**
+     * Path to a TSConfig to use instead of TypeScript's default project configuration.
+     * @default 'tsconfig.json'
+     */
+    defaultProject?: string;
+    /**
+     * Whether to allow TypeScript plugins as configured in the TSConfig.
+     */
+    loadTypeScriptPlugins?: boolean;
+    /**
+     * The maximum number of files {@link allowDefaultProject} may match.
+     * Each file match slows down linting, so if you do need to use this, please
+     * file an informative issue on typescript-eslint explaining why - so we can
+     * help you avoid using it!
+     * @default 8
+     */
+    maximumDefaultProjectFileMatchCount_THIS_WILL_SLOW_DOWN_LINTING?: number;
+}
+interface ParserOptions {
+    [additionalProperties: string]: unknown;
+    cacheLifetime?: {
+        glob?: CacheDurationSeconds;
+    };
+    debugLevel?: DebugLevel;
+    ecmaFeatures?: {
+        [key: string]: unknown;
+        globalReturn?: boolean | undefined;
+        jsx?: boolean | undefined;
+    } | undefined;
+    ecmaVersion?: EcmaVersion;
+    emitDecoratorMetadata?: boolean;
+    errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
+    errorOnUnknownASTType?: boolean;
+    experimentalDecorators?: boolean;
+    extraFileExtensions?: string[];
+    filePath?: string;
+    isolatedDeclarations?: boolean;
+    jsDocParsingMode?: JSDocParsingMode;
+    jsxFragmentName?: string | null;
+    jsxPragma?: string | null;
+    lib?: Lib[];
+    programs?: Program$1[] | null;
+    project?: boolean | string | string[] | null;
+    projectFolderIgnoreList?: string[];
+    projectService?: boolean | ProjectServiceOptions;
+    range?: boolean;
+    sourceType?: SourceType | undefined;
+    tokens?: boolean;
+    tsconfigRootDir?: string;
+    warnOnUnsupportedTypeScriptVersion?: boolean;
+}
+
 declare module "./index" {
     interface BaseNode {
         parent: Node;
@@ -4741,6 +2405,8 @@ declare module "./index" {
     }
 }
 
+type NodeWithParent = Exclude<Node, Program>;
+
 declare module 'typescript' {
     interface AssertClause extends ts.ImportAttributes {
     }
@@ -4759,180 +2425,180 @@ type TSToken = ts.Token<ts.SyntaxKind>;
 type TSNode = ts.ArrayBindingPattern | ts.ArrayLiteralExpression | ts.ArrayTypeNode | ts.ArrowFunction | ts.AsExpression | ts.AssertClause | ts.AssertEntry | ts.AwaitExpression | ts.BigIntLiteral | ts.BinaryExpression | ts.BindingElement | ts.Block | ts.BooleanLiteral | ts.BreakStatement | ts.Bundle | ts.CallExpression | ts.CallSignatureDeclaration | ts.CaseBlock | ts.CaseClause | ts.CatchClause | ts.ClassDeclaration | ts.ClassExpression | ts.ClassStaticBlockDeclaration | ts.CommaListExpression | ts.ComputedPropertyName | ts.ConditionalExpression | ts.ConditionalTypeNode | ts.ConstructorDeclaration | ts.ConstructorTypeNode | ts.ConstructSignatureDeclaration | ts.ContinueStatement | ts.DebuggerStatement | ts.Decorator | ts.DefaultClause | ts.DeleteExpression | ts.DoStatement | ts.ElementAccessExpression | ts.EmptyStatement | ts.EnumDeclaration | ts.EnumMember | ts.ExportAssignment | ts.ExportDeclaration | ts.ExportSpecifier | ts.ExpressionStatement | ts.ExpressionWithTypeArguments | ts.ExternalModuleReference | ts.ForInStatement | ts.ForOfStatement | ts.ForStatement | ts.FunctionDeclaration | ts.FunctionExpression | ts.FunctionTypeNode | ts.GetAccessorDeclaration | ts.HeritageClause | ts.Identifier | ts.IfStatement | ts.ImportAttribute | ts.ImportAttributes | ts.ImportClause | ts.ImportDeclaration | ts.ImportEqualsDeclaration | ts.ImportExpression | ts.ImportSpecifier | ts.ImportTypeNode | ts.IndexedAccessTypeNode | ts.IndexSignatureDeclaration | ts.InferTypeNode | ts.InterfaceDeclaration | ts.IntersectionTypeNode | ts.JSDoc | ts.JSDocAllType | ts.JSDocAugmentsTag | ts.JSDocAuthorTag | ts.JSDocCallbackTag | ts.JSDocClassTag | ts.JSDocEnumTag | ts.JSDocFunctionType | ts.JSDocNonNullableType | ts.JSDocNullableType | ts.JSDocOptionalType | ts.JSDocParameterTag | ts.JSDocPropertyTag | ts.JSDocReturnTag | ts.JSDocSignature | ts.JSDocTemplateTag | ts.JSDocThisTag | ts.JSDocTypedefTag | ts.JSDocTypeExpression | ts.JSDocTypeLiteral | ts.JSDocTypeTag | ts.JSDocUnknownTag | ts.JSDocUnknownType | ts.JSDocVariadicType | ts.JsonMinusNumericLiteral | ts.JsxAttribute | ts.JsxClosingElement | ts.JsxClosingFragment | ts.JsxElement | ts.JsxExpression | ts.JsxFragment | ts.JsxNamespacedName | ts.JsxOpeningElement | ts.JsxOpeningFragment | ts.JsxSelfClosingElement | ts.JsxSpreadAttribute | ts.JsxText | ts.KeywordTypeNode | ts.LabeledStatement | ts.LiteralTypeNode | ts.MappedTypeNode | ts.MetaProperty | ts.MethodDeclaration | ts.MethodSignature | ts.MissingDeclaration | ts.Modifier | ts.ModuleBlock | ts.ModuleDeclaration | ts.NamedExports | ts.NamedImports | ts.NamedTupleMember | ts.NamespaceExportDeclaration | ts.NamespaceImport | ts.NewExpression | ts.NonNullExpression | ts.NoSubstitutionTemplateLiteral | ts.NotEmittedStatement | ts.NullLiteral | ts.NumericLiteral | ts.ObjectBindingPattern | ts.ObjectLiteralExpression | ts.OmittedExpression | ts.OptionalTypeNode | ts.ParameterDeclaration | ts.ParenthesizedExpression | ts.ParenthesizedTypeNode | ts.PartiallyEmittedExpression | ts.PostfixUnaryExpression | ts.PrefixUnaryExpression | ts.PrivateIdentifier | ts.PropertyAccessExpression | ts.PropertyAssignment | ts.PropertyDeclaration | ts.PropertySignature | ts.QualifiedName | ts.RegularExpressionLiteral | ts.RestTypeNode | ts.ReturnStatement | ts.SatisfiesExpression | ts.SemicolonClassElement | ts.SetAccessorDeclaration | ts.ShorthandPropertyAssignment | ts.SourceFile | ts.SpreadAssignment | ts.SpreadElement | ts.StringLiteral | ts.SuperExpression | ts.SwitchStatement | ts.SyntheticExpression | ts.TaggedTemplateExpression | ts.TemplateExpression | ts.TemplateHead | ts.TemplateLiteralTypeNode | ts.TemplateMiddle | ts.TemplateSpan | ts.TemplateTail | ts.ThisExpression | ts.ThisTypeNode | ts.ThrowStatement | ts.TryStatement | ts.TupleTypeNode | ts.TypeAliasDeclaration | ts.TypeAssertion | ts.TypeLiteralNode | ts.TypeOfExpression | ts.TypeOperatorNode | ts.TypeParameterDeclaration | ts.TypePredicateNode | ts.TypeQueryNode | ts.TypeReferenceNode | ts.UnionTypeNode | ts.VariableDeclaration | ts.VariableDeclarationList | ts.VariableStatement | ts.VoidExpression | ts.WhileStatement | ts.WithStatement | ts.YieldExpression;
 
 interface EstreeToTsNodeTypes {
-    [AST_NODE_TYPES$1.AccessorProperty]: ts.PropertyDeclaration;
-    [AST_NODE_TYPES$1.ArrayExpression]: ts.ArrayLiteralExpression;
-    [AST_NODE_TYPES$1.ArrayPattern]: ts.ArrayBindingPattern | ts.ArrayLiteralExpression;
-    [AST_NODE_TYPES$1.ArrowFunctionExpression]: ts.ArrowFunction;
-    [AST_NODE_TYPES$1.AssignmentExpression]: ts.BinaryExpression;
-    [AST_NODE_TYPES$1.AssignmentPattern]: ts.BinaryExpression | ts.BindingElement | ts.ParameterDeclaration | ts.ShorthandPropertyAssignment;
-    [AST_NODE_TYPES$1.AwaitExpression]: ts.AwaitExpression;
-    [AST_NODE_TYPES$1.BinaryExpression]: ts.BinaryExpression;
-    [AST_NODE_TYPES$1.BlockStatement]: ts.Block;
-    [AST_NODE_TYPES$1.BreakStatement]: ts.BreakStatement;
-    [AST_NODE_TYPES$1.CallExpression]: ts.CallExpression;
-    [AST_NODE_TYPES$1.CatchClause]: ts.CatchClause;
-    [AST_NODE_TYPES$1.ChainExpression]: ts.CallExpression | ts.ElementAccessExpression | ts.NonNullExpression | ts.PropertyAccessExpression;
-    [AST_NODE_TYPES$1.ClassBody]: ts.ClassDeclaration | ts.ClassExpression;
-    [AST_NODE_TYPES$1.ClassDeclaration]: ts.ClassDeclaration;
-    [AST_NODE_TYPES$1.ClassExpression]: ts.ClassExpression;
-    [AST_NODE_TYPES$1.ConditionalExpression]: ts.ConditionalExpression;
-    [AST_NODE_TYPES$1.ContinueStatement]: ts.ContinueStatement;
-    [AST_NODE_TYPES$1.DebuggerStatement]: ts.DebuggerStatement;
-    [AST_NODE_TYPES$1.Decorator]: ts.Decorator;
-    [AST_NODE_TYPES$1.DoWhileStatement]: ts.DoStatement;
-    [AST_NODE_TYPES$1.EmptyStatement]: ts.EmptyStatement;
-    [AST_NODE_TYPES$1.ExportAllDeclaration]: ts.ExportDeclaration;
-    [AST_NODE_TYPES$1.ExportDefaultDeclaration]: ts.ClassDeclaration | ts.ClassExpression | ts.EnumDeclaration | ts.ExportAssignment | ts.FunctionDeclaration | ts.InterfaceDeclaration | ts.ModuleDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement;
-    [AST_NODE_TYPES$1.ExportNamedDeclaration]: ts.ClassDeclaration | ts.ClassExpression | ts.EnumDeclaration | ts.ExportDeclaration | ts.FunctionDeclaration | ts.ImportEqualsDeclaration | ts.InterfaceDeclaration | ts.ModuleDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement;
-    [AST_NODE_TYPES$1.ExportSpecifier]: ts.ExportSpecifier;
-    [AST_NODE_TYPES$1.ExpressionStatement]: ts.ExpressionStatement;
-    [AST_NODE_TYPES$1.ForInStatement]: ts.ForInStatement;
-    [AST_NODE_TYPES$1.ForOfStatement]: ts.ForOfStatement;
-    [AST_NODE_TYPES$1.ForStatement]: ts.ForStatement;
-    [AST_NODE_TYPES$1.FunctionDeclaration]: ts.FunctionDeclaration;
-    [AST_NODE_TYPES$1.FunctionExpression]: ts.ConstructorDeclaration | ts.FunctionExpression | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
-    [AST_NODE_TYPES$1.Identifier]: ts.ConstructorDeclaration | ts.Identifier | ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword>;
-    [AST_NODE_TYPES$1.IfStatement]: ts.IfStatement;
-    [AST_NODE_TYPES$1.PrivateIdentifier]: ts.PrivateIdentifier;
-    [AST_NODE_TYPES$1.PropertyDefinition]: ts.PropertyDeclaration;
-    [AST_NODE_TYPES$1.ImportAttribute]: 'ImportAttribute' extends keyof typeof ts ? ts.ImportAttribute : ts.AssertEntry;
-    [AST_NODE_TYPES$1.ImportDeclaration]: ts.ImportDeclaration;
-    [AST_NODE_TYPES$1.ImportDefaultSpecifier]: ts.ImportClause;
-    [AST_NODE_TYPES$1.ImportExpression]: ts.CallExpression;
-    [AST_NODE_TYPES$1.ImportNamespaceSpecifier]: ts.NamespaceImport;
-    [AST_NODE_TYPES$1.ImportSpecifier]: ts.ImportSpecifier;
-    [AST_NODE_TYPES$1.JSXAttribute]: ts.JsxAttribute;
-    [AST_NODE_TYPES$1.JSXClosingElement]: ts.JsxClosingElement;
-    [AST_NODE_TYPES$1.JSXClosingFragment]: ts.JsxClosingFragment;
-    [AST_NODE_TYPES$1.JSXElement]: ts.JsxElement | ts.JsxSelfClosingElement;
-    [AST_NODE_TYPES$1.JSXEmptyExpression]: ts.JsxExpression;
-    [AST_NODE_TYPES$1.JSXExpressionContainer]: ts.JsxExpression;
-    [AST_NODE_TYPES$1.JSXFragment]: ts.JsxFragment;
-    [AST_NODE_TYPES$1.JSXIdentifier]: ts.Identifier | ts.ThisExpression;
-    [AST_NODE_TYPES$1.JSXMemberExpression]: ts.PropertyAccessExpression;
-    [AST_NODE_TYPES$1.JSXNamespacedName]: ts.JsxNamespacedName;
-    [AST_NODE_TYPES$1.JSXOpeningElement]: ts.JsxOpeningElement | ts.JsxSelfClosingElement;
-    [AST_NODE_TYPES$1.JSXOpeningFragment]: ts.JsxOpeningFragment;
-    [AST_NODE_TYPES$1.JSXSpreadAttribute]: ts.JsxSpreadAttribute;
-    [AST_NODE_TYPES$1.JSXSpreadChild]: ts.JsxExpression;
-    [AST_NODE_TYPES$1.JSXText]: ts.JsxText;
-    [AST_NODE_TYPES$1.LabeledStatement]: ts.LabeledStatement;
-    [AST_NODE_TYPES$1.Literal]: ts.BigIntLiteral | ts.BooleanLiteral | ts.NullLiteral | ts.NumericLiteral | ts.RegularExpressionLiteral | ts.StringLiteral;
-    [AST_NODE_TYPES$1.LogicalExpression]: ts.BinaryExpression;
-    [AST_NODE_TYPES$1.MemberExpression]: ts.ElementAccessExpression | ts.PropertyAccessExpression;
-    [AST_NODE_TYPES$1.MetaProperty]: ts.MetaProperty;
-    [AST_NODE_TYPES$1.MethodDefinition]: ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
-    [AST_NODE_TYPES$1.NewExpression]: ts.NewExpression;
-    [AST_NODE_TYPES$1.ObjectExpression]: ts.ObjectLiteralExpression;
-    [AST_NODE_TYPES$1.ObjectPattern]: ts.ObjectBindingPattern | ts.ObjectLiteralExpression;
-    [AST_NODE_TYPES$1.Program]: ts.SourceFile;
-    [AST_NODE_TYPES$1.Property]: ts.BindingElement | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.PropertyAssignment | ts.SetAccessorDeclaration | ts.ShorthandPropertyAssignment;
-    [AST_NODE_TYPES$1.RestElement]: ts.BindingElement | ts.ParameterDeclaration | ts.SpreadAssignment | ts.SpreadElement;
-    [AST_NODE_TYPES$1.ReturnStatement]: ts.ReturnStatement;
-    [AST_NODE_TYPES$1.SequenceExpression]: ts.BinaryExpression;
-    [AST_NODE_TYPES$1.SpreadElement]: ts.SpreadAssignment | ts.SpreadElement;
-    [AST_NODE_TYPES$1.StaticBlock]: ts.ClassStaticBlockDeclaration;
-    [AST_NODE_TYPES$1.Super]: ts.SuperExpression;
-    [AST_NODE_TYPES$1.SwitchCase]: ts.CaseClause | ts.DefaultClause;
-    [AST_NODE_TYPES$1.SwitchStatement]: ts.SwitchStatement;
-    [AST_NODE_TYPES$1.TaggedTemplateExpression]: ts.TaggedTemplateExpression;
-    [AST_NODE_TYPES$1.TemplateElement]: ts.NoSubstitutionTemplateLiteral | ts.TemplateHead | ts.TemplateMiddle | ts.TemplateTail;
-    [AST_NODE_TYPES$1.TemplateLiteral]: ts.NoSubstitutionTemplateLiteral | ts.TemplateExpression;
-    [AST_NODE_TYPES$1.ThisExpression]: ts.Identifier | ts.KeywordTypeNode | ts.ThisExpression;
-    [AST_NODE_TYPES$1.ThrowStatement]: ts.ThrowStatement;
-    [AST_NODE_TYPES$1.TryStatement]: ts.TryStatement;
-    [AST_NODE_TYPES$1.TSAbstractAccessorProperty]: ts.PropertyDeclaration;
-    [AST_NODE_TYPES$1.TSAbstractMethodDefinition]: ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
-    [AST_NODE_TYPES$1.TSAbstractPropertyDefinition]: ts.PropertyDeclaration;
-    [AST_NODE_TYPES$1.TSArrayType]: ts.ArrayTypeNode;
-    [AST_NODE_TYPES$1.TSAsExpression]: ts.AsExpression;
-    [AST_NODE_TYPES$1.TSCallSignatureDeclaration]: ts.CallSignatureDeclaration;
-    [AST_NODE_TYPES$1.TSClassImplements]: ts.ExpressionWithTypeArguments;
-    [AST_NODE_TYPES$1.TSConditionalType]: ts.ConditionalTypeNode;
-    [AST_NODE_TYPES$1.TSConstructorType]: ts.ConstructorTypeNode;
-    [AST_NODE_TYPES$1.TSConstructSignatureDeclaration]: ts.ConstructSignatureDeclaration;
-    [AST_NODE_TYPES$1.TSDeclareFunction]: ts.FunctionDeclaration;
-    [AST_NODE_TYPES$1.TSEnumBody]: ts.EnumDeclaration;
-    [AST_NODE_TYPES$1.TSEnumDeclaration]: ts.EnumDeclaration;
-    [AST_NODE_TYPES$1.TSEnumMember]: ts.EnumMember;
-    [AST_NODE_TYPES$1.TSExportAssignment]: ts.ExportAssignment;
-    [AST_NODE_TYPES$1.TSExternalModuleReference]: ts.ExternalModuleReference;
-    [AST_NODE_TYPES$1.TSFunctionType]: ts.FunctionTypeNode;
-    [AST_NODE_TYPES$1.TSImportEqualsDeclaration]: ts.ImportEqualsDeclaration;
-    [AST_NODE_TYPES$1.TSImportType]: ts.ImportTypeNode;
-    [AST_NODE_TYPES$1.TSIndexedAccessType]: ts.IndexedAccessTypeNode;
-    [AST_NODE_TYPES$1.TSIndexSignature]: ts.IndexSignatureDeclaration;
-    [AST_NODE_TYPES$1.TSInferType]: ts.InferTypeNode;
-    [AST_NODE_TYPES$1.TSInstantiationExpression]: ts.ExpressionWithTypeArguments;
-    [AST_NODE_TYPES$1.TSInterfaceBody]: ts.InterfaceDeclaration;
-    [AST_NODE_TYPES$1.TSInterfaceDeclaration]: ts.InterfaceDeclaration;
-    [AST_NODE_TYPES$1.TSInterfaceHeritage]: ts.ExpressionWithTypeArguments;
-    [AST_NODE_TYPES$1.TSIntersectionType]: ts.IntersectionTypeNode;
-    [AST_NODE_TYPES$1.TSLiteralType]: ts.LiteralTypeNode;
-    [AST_NODE_TYPES$1.TSMappedType]: ts.MappedTypeNode;
-    [AST_NODE_TYPES$1.TSMethodSignature]: ts.GetAccessorDeclaration | ts.MethodSignature | ts.SetAccessorDeclaration;
-    [AST_NODE_TYPES$1.TSModuleBlock]: ts.ModuleBlock;
-    [AST_NODE_TYPES$1.TSModuleDeclaration]: ts.ModuleDeclaration;
-    [AST_NODE_TYPES$1.TSNamedTupleMember]: ts.NamedTupleMember;
-    [AST_NODE_TYPES$1.TSNamespaceExportDeclaration]: ts.NamespaceExportDeclaration;
-    [AST_NODE_TYPES$1.TSNonNullExpression]: ts.NonNullExpression;
-    [AST_NODE_TYPES$1.TSOptionalType]: ts.OptionalTypeNode;
-    [AST_NODE_TYPES$1.TSParameterProperty]: ts.ParameterDeclaration;
-    [AST_NODE_TYPES$1.TSPropertySignature]: ts.PropertySignature;
-    [AST_NODE_TYPES$1.TSQualifiedName]: ts.Identifier | ts.QualifiedName;
-    [AST_NODE_TYPES$1.TSRestType]: ts.NamedTupleMember | ts.RestTypeNode;
-    [AST_NODE_TYPES$1.TSSatisfiesExpression]: ts.SatisfiesExpression;
-    [AST_NODE_TYPES$1.TSTemplateLiteralType]: ts.TemplateLiteralTypeNode;
-    [AST_NODE_TYPES$1.TSThisType]: ts.ThisTypeNode;
-    [AST_NODE_TYPES$1.TSTupleType]: ts.TupleTypeNode;
-    [AST_NODE_TYPES$1.TSTypeAliasDeclaration]: ts.TypeAliasDeclaration;
-    [AST_NODE_TYPES$1.TSTypeAnnotation]: undefined;
-    [AST_NODE_TYPES$1.TSTypeAssertion]: ts.TypeAssertion;
-    [AST_NODE_TYPES$1.TSTypeLiteral]: ts.TypeLiteralNode;
-    [AST_NODE_TYPES$1.TSTypeOperator]: ts.TypeOperatorNode;
-    [AST_NODE_TYPES$1.TSTypeParameter]: ts.TypeParameterDeclaration;
-    [AST_NODE_TYPES$1.TSTypeParameterDeclaration]: undefined;
-    [AST_NODE_TYPES$1.TSTypeParameterInstantiation]: ts.CallExpression | ts.ExpressionWithTypeArguments | ts.ImportTypeNode | ts.JsxOpeningElement | ts.JsxSelfClosingElement | ts.NewExpression | ts.TaggedTemplateExpression | ts.TypeQueryNode | ts.TypeReferenceNode;
-    [AST_NODE_TYPES$1.TSTypePredicate]: ts.TypePredicateNode;
-    [AST_NODE_TYPES$1.TSTypeQuery]: ts.ImportTypeNode | ts.TypeQueryNode;
-    [AST_NODE_TYPES$1.TSTypeReference]: ts.TypeReferenceNode;
-    [AST_NODE_TYPES$1.TSUnionType]: ts.UnionTypeNode;
-    [AST_NODE_TYPES$1.UnaryExpression]: ts.DeleteExpression | ts.PostfixUnaryExpression | ts.PrefixUnaryExpression | ts.TypeOfExpression | ts.VoidExpression;
-    [AST_NODE_TYPES$1.UpdateExpression]: ts.PostfixUnaryExpression | ts.PrefixUnaryExpression;
-    [AST_NODE_TYPES$1.VariableDeclaration]: ts.VariableDeclarationList | ts.VariableStatement;
-    [AST_NODE_TYPES$1.VariableDeclarator]: ts.VariableDeclaration;
-    [AST_NODE_TYPES$1.WhileStatement]: ts.WhileStatement;
-    [AST_NODE_TYPES$1.WithStatement]: ts.WithStatement;
-    [AST_NODE_TYPES$1.YieldExpression]: ts.YieldExpression;
-    [AST_NODE_TYPES$1.TSEmptyBodyFunctionExpression]: ts.ConstructorDeclaration | ts.FunctionExpression | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
-    [AST_NODE_TYPES$1.TSAbstractKeyword]: ts.Token<ts.SyntaxKind.AbstractKeyword>;
-    [AST_NODE_TYPES$1.TSAnyKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSBigIntKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSBooleanKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSIntrinsicKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSNeverKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSNullKeyword]: ts.KeywordTypeNode | ts.NullLiteral;
-    [AST_NODE_TYPES$1.TSNumberKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSObjectKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSStringKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSSymbolKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSUndefinedKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSUnknownKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSVoidKeyword]: ts.KeywordTypeNode;
-    [AST_NODE_TYPES$1.TSAsyncKeyword]: ts.Token<ts.SyntaxKind.AsyncKeyword>;
-    [AST_NODE_TYPES$1.TSDeclareKeyword]: ts.Token<ts.SyntaxKind.DeclareKeyword>;
-    [AST_NODE_TYPES$1.TSExportKeyword]: ts.Token<ts.SyntaxKind.ExportKeyword>;
-    [AST_NODE_TYPES$1.TSPrivateKeyword]: ts.Token<ts.SyntaxKind.PrivateKeyword>;
-    [AST_NODE_TYPES$1.TSProtectedKeyword]: ts.Token<ts.SyntaxKind.ProtectedKeyword>;
-    [AST_NODE_TYPES$1.TSPublicKeyword]: ts.Token<ts.SyntaxKind.PublicKeyword>;
-    [AST_NODE_TYPES$1.TSReadonlyKeyword]: ts.Token<ts.SyntaxKind.ReadonlyKeyword>;
-    [AST_NODE_TYPES$1.TSStaticKeyword]: ts.Token<ts.SyntaxKind.StaticKeyword>;
+    [AST_NODE_TYPES.AccessorProperty]: ts.PropertyDeclaration;
+    [AST_NODE_TYPES.ArrayExpression]: ts.ArrayLiteralExpression;
+    [AST_NODE_TYPES.ArrayPattern]: ts.ArrayBindingPattern | ts.ArrayLiteralExpression;
+    [AST_NODE_TYPES.ArrowFunctionExpression]: ts.ArrowFunction;
+    [AST_NODE_TYPES.AssignmentExpression]: ts.BinaryExpression;
+    [AST_NODE_TYPES.AssignmentPattern]: ts.BinaryExpression | ts.BindingElement | ts.ParameterDeclaration | ts.ShorthandPropertyAssignment;
+    [AST_NODE_TYPES.AwaitExpression]: ts.AwaitExpression;
+    [AST_NODE_TYPES.BinaryExpression]: ts.BinaryExpression;
+    [AST_NODE_TYPES.BlockStatement]: ts.Block;
+    [AST_NODE_TYPES.BreakStatement]: ts.BreakStatement;
+    [AST_NODE_TYPES.CallExpression]: ts.CallExpression;
+    [AST_NODE_TYPES.CatchClause]: ts.CatchClause;
+    [AST_NODE_TYPES.ChainExpression]: ts.CallExpression | ts.ElementAccessExpression | ts.NonNullExpression | ts.PropertyAccessExpression;
+    [AST_NODE_TYPES.ClassBody]: ts.ClassDeclaration | ts.ClassExpression;
+    [AST_NODE_TYPES.ClassDeclaration]: ts.ClassDeclaration;
+    [AST_NODE_TYPES.ClassExpression]: ts.ClassExpression;
+    [AST_NODE_TYPES.ConditionalExpression]: ts.ConditionalExpression;
+    [AST_NODE_TYPES.ContinueStatement]: ts.ContinueStatement;
+    [AST_NODE_TYPES.DebuggerStatement]: ts.DebuggerStatement;
+    [AST_NODE_TYPES.Decorator]: ts.Decorator;
+    [AST_NODE_TYPES.DoWhileStatement]: ts.DoStatement;
+    [AST_NODE_TYPES.EmptyStatement]: ts.EmptyStatement;
+    [AST_NODE_TYPES.ExportAllDeclaration]: ts.ExportDeclaration;
+    [AST_NODE_TYPES.ExportDefaultDeclaration]: ts.ClassDeclaration | ts.ClassExpression | ts.EnumDeclaration | ts.ExportAssignment | ts.FunctionDeclaration | ts.InterfaceDeclaration | ts.ModuleDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement;
+    [AST_NODE_TYPES.ExportNamedDeclaration]: ts.ClassDeclaration | ts.ClassExpression | ts.EnumDeclaration | ts.ExportDeclaration | ts.FunctionDeclaration | ts.ImportEqualsDeclaration | ts.InterfaceDeclaration | ts.ModuleDeclaration | ts.TypeAliasDeclaration | ts.VariableStatement;
+    [AST_NODE_TYPES.ExportSpecifier]: ts.ExportSpecifier;
+    [AST_NODE_TYPES.ExpressionStatement]: ts.ExpressionStatement;
+    [AST_NODE_TYPES.ForInStatement]: ts.ForInStatement;
+    [AST_NODE_TYPES.ForOfStatement]: ts.ForOfStatement;
+    [AST_NODE_TYPES.ForStatement]: ts.ForStatement;
+    [AST_NODE_TYPES.FunctionDeclaration]: ts.FunctionDeclaration;
+    [AST_NODE_TYPES.FunctionExpression]: ts.ConstructorDeclaration | ts.FunctionExpression | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
+    [AST_NODE_TYPES.Identifier]: ts.ConstructorDeclaration | ts.Identifier | ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword>;
+    [AST_NODE_TYPES.IfStatement]: ts.IfStatement;
+    [AST_NODE_TYPES.PrivateIdentifier]: ts.PrivateIdentifier;
+    [AST_NODE_TYPES.PropertyDefinition]: ts.PropertyDeclaration;
+    [AST_NODE_TYPES.ImportAttribute]: 'ImportAttribute' extends keyof typeof ts ? ts.ImportAttribute : ts.AssertEntry;
+    [AST_NODE_TYPES.ImportDeclaration]: ts.ImportDeclaration;
+    [AST_NODE_TYPES.ImportDefaultSpecifier]: ts.ImportClause;
+    [AST_NODE_TYPES.ImportExpression]: ts.CallExpression;
+    [AST_NODE_TYPES.ImportNamespaceSpecifier]: ts.NamespaceImport;
+    [AST_NODE_TYPES.ImportSpecifier]: ts.ImportSpecifier;
+    [AST_NODE_TYPES.JSXAttribute]: ts.JsxAttribute;
+    [AST_NODE_TYPES.JSXClosingElement]: ts.JsxClosingElement;
+    [AST_NODE_TYPES.JSXClosingFragment]: ts.JsxClosingFragment;
+    [AST_NODE_TYPES.JSXElement]: ts.JsxElement | ts.JsxSelfClosingElement;
+    [AST_NODE_TYPES.JSXEmptyExpression]: ts.JsxExpression;
+    [AST_NODE_TYPES.JSXExpressionContainer]: ts.JsxExpression;
+    [AST_NODE_TYPES.JSXFragment]: ts.JsxFragment;
+    [AST_NODE_TYPES.JSXIdentifier]: ts.Identifier | ts.ThisExpression;
+    [AST_NODE_TYPES.JSXMemberExpression]: ts.PropertyAccessExpression;
+    [AST_NODE_TYPES.JSXNamespacedName]: ts.JsxNamespacedName;
+    [AST_NODE_TYPES.JSXOpeningElement]: ts.JsxOpeningElement | ts.JsxSelfClosingElement;
+    [AST_NODE_TYPES.JSXOpeningFragment]: ts.JsxOpeningFragment;
+    [AST_NODE_TYPES.JSXSpreadAttribute]: ts.JsxSpreadAttribute;
+    [AST_NODE_TYPES.JSXSpreadChild]: ts.JsxExpression;
+    [AST_NODE_TYPES.JSXText]: ts.JsxText;
+    [AST_NODE_TYPES.LabeledStatement]: ts.LabeledStatement;
+    [AST_NODE_TYPES.Literal]: ts.BigIntLiteral | ts.BooleanLiteral | ts.NullLiteral | ts.NumericLiteral | ts.RegularExpressionLiteral | ts.StringLiteral;
+    [AST_NODE_TYPES.LogicalExpression]: ts.BinaryExpression;
+    [AST_NODE_TYPES.MemberExpression]: ts.ElementAccessExpression | ts.PropertyAccessExpression;
+    [AST_NODE_TYPES.MetaProperty]: ts.MetaProperty;
+    [AST_NODE_TYPES.MethodDefinition]: ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
+    [AST_NODE_TYPES.NewExpression]: ts.NewExpression;
+    [AST_NODE_TYPES.ObjectExpression]: ts.ObjectLiteralExpression;
+    [AST_NODE_TYPES.ObjectPattern]: ts.ObjectBindingPattern | ts.ObjectLiteralExpression;
+    [AST_NODE_TYPES.Program]: ts.SourceFile;
+    [AST_NODE_TYPES.Property]: ts.BindingElement | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.PropertyAssignment | ts.SetAccessorDeclaration | ts.ShorthandPropertyAssignment;
+    [AST_NODE_TYPES.RestElement]: ts.BindingElement | ts.ParameterDeclaration | ts.SpreadAssignment | ts.SpreadElement;
+    [AST_NODE_TYPES.ReturnStatement]: ts.ReturnStatement;
+    [AST_NODE_TYPES.SequenceExpression]: ts.BinaryExpression;
+    [AST_NODE_TYPES.SpreadElement]: ts.SpreadAssignment | ts.SpreadElement;
+    [AST_NODE_TYPES.StaticBlock]: ts.ClassStaticBlockDeclaration;
+    [AST_NODE_TYPES.Super]: ts.SuperExpression;
+    [AST_NODE_TYPES.SwitchCase]: ts.CaseClause | ts.DefaultClause;
+    [AST_NODE_TYPES.SwitchStatement]: ts.SwitchStatement;
+    [AST_NODE_TYPES.TaggedTemplateExpression]: ts.TaggedTemplateExpression;
+    [AST_NODE_TYPES.TemplateElement]: ts.NoSubstitutionTemplateLiteral | ts.TemplateHead | ts.TemplateMiddle | ts.TemplateTail;
+    [AST_NODE_TYPES.TemplateLiteral]: ts.NoSubstitutionTemplateLiteral | ts.TemplateExpression;
+    [AST_NODE_TYPES.ThisExpression]: ts.Identifier | ts.KeywordTypeNode | ts.ThisExpression;
+    [AST_NODE_TYPES.ThrowStatement]: ts.ThrowStatement;
+    [AST_NODE_TYPES.TryStatement]: ts.TryStatement;
+    [AST_NODE_TYPES.TSAbstractAccessorProperty]: ts.PropertyDeclaration;
+    [AST_NODE_TYPES.TSAbstractMethodDefinition]: ts.ConstructorDeclaration | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
+    [AST_NODE_TYPES.TSAbstractPropertyDefinition]: ts.PropertyDeclaration;
+    [AST_NODE_TYPES.TSArrayType]: ts.ArrayTypeNode;
+    [AST_NODE_TYPES.TSAsExpression]: ts.AsExpression;
+    [AST_NODE_TYPES.TSCallSignatureDeclaration]: ts.CallSignatureDeclaration;
+    [AST_NODE_TYPES.TSClassImplements]: ts.ExpressionWithTypeArguments;
+    [AST_NODE_TYPES.TSConditionalType]: ts.ConditionalTypeNode;
+    [AST_NODE_TYPES.TSConstructorType]: ts.ConstructorTypeNode;
+    [AST_NODE_TYPES.TSConstructSignatureDeclaration]: ts.ConstructSignatureDeclaration;
+    [AST_NODE_TYPES.TSDeclareFunction]: ts.FunctionDeclaration;
+    [AST_NODE_TYPES.TSEnumBody]: ts.EnumDeclaration;
+    [AST_NODE_TYPES.TSEnumDeclaration]: ts.EnumDeclaration;
+    [AST_NODE_TYPES.TSEnumMember]: ts.EnumMember;
+    [AST_NODE_TYPES.TSExportAssignment]: ts.ExportAssignment;
+    [AST_NODE_TYPES.TSExternalModuleReference]: ts.ExternalModuleReference;
+    [AST_NODE_TYPES.TSFunctionType]: ts.FunctionTypeNode;
+    [AST_NODE_TYPES.TSImportEqualsDeclaration]: ts.ImportEqualsDeclaration;
+    [AST_NODE_TYPES.TSImportType]: ts.ImportTypeNode;
+    [AST_NODE_TYPES.TSIndexedAccessType]: ts.IndexedAccessTypeNode;
+    [AST_NODE_TYPES.TSIndexSignature]: ts.IndexSignatureDeclaration;
+    [AST_NODE_TYPES.TSInferType]: ts.InferTypeNode;
+    [AST_NODE_TYPES.TSInstantiationExpression]: ts.ExpressionWithTypeArguments;
+    [AST_NODE_TYPES.TSInterfaceBody]: ts.InterfaceDeclaration;
+    [AST_NODE_TYPES.TSInterfaceDeclaration]: ts.InterfaceDeclaration;
+    [AST_NODE_TYPES.TSInterfaceHeritage]: ts.ExpressionWithTypeArguments;
+    [AST_NODE_TYPES.TSIntersectionType]: ts.IntersectionTypeNode;
+    [AST_NODE_TYPES.TSLiteralType]: ts.LiteralTypeNode;
+    [AST_NODE_TYPES.TSMappedType]: ts.MappedTypeNode;
+    [AST_NODE_TYPES.TSMethodSignature]: ts.GetAccessorDeclaration | ts.MethodSignature | ts.SetAccessorDeclaration;
+    [AST_NODE_TYPES.TSModuleBlock]: ts.ModuleBlock;
+    [AST_NODE_TYPES.TSModuleDeclaration]: ts.ModuleDeclaration;
+    [AST_NODE_TYPES.TSNamedTupleMember]: ts.NamedTupleMember;
+    [AST_NODE_TYPES.TSNamespaceExportDeclaration]: ts.NamespaceExportDeclaration;
+    [AST_NODE_TYPES.TSNonNullExpression]: ts.NonNullExpression;
+    [AST_NODE_TYPES.TSOptionalType]: ts.OptionalTypeNode;
+    [AST_NODE_TYPES.TSParameterProperty]: ts.ParameterDeclaration;
+    [AST_NODE_TYPES.TSPropertySignature]: ts.PropertySignature;
+    [AST_NODE_TYPES.TSQualifiedName]: ts.Identifier | ts.QualifiedName;
+    [AST_NODE_TYPES.TSRestType]: ts.NamedTupleMember | ts.RestTypeNode;
+    [AST_NODE_TYPES.TSSatisfiesExpression]: ts.SatisfiesExpression;
+    [AST_NODE_TYPES.TSTemplateLiteralType]: ts.TemplateLiteralTypeNode;
+    [AST_NODE_TYPES.TSThisType]: ts.ThisTypeNode;
+    [AST_NODE_TYPES.TSTupleType]: ts.TupleTypeNode;
+    [AST_NODE_TYPES.TSTypeAliasDeclaration]: ts.TypeAliasDeclaration;
+    [AST_NODE_TYPES.TSTypeAnnotation]: undefined;
+    [AST_NODE_TYPES.TSTypeAssertion]: ts.TypeAssertion;
+    [AST_NODE_TYPES.TSTypeLiteral]: ts.TypeLiteralNode;
+    [AST_NODE_TYPES.TSTypeOperator]: ts.TypeOperatorNode;
+    [AST_NODE_TYPES.TSTypeParameter]: ts.TypeParameterDeclaration;
+    [AST_NODE_TYPES.TSTypeParameterDeclaration]: undefined;
+    [AST_NODE_TYPES.TSTypeParameterInstantiation]: ts.CallExpression | ts.ExpressionWithTypeArguments | ts.ImportTypeNode | ts.JsxOpeningElement | ts.JsxSelfClosingElement | ts.NewExpression | ts.TaggedTemplateExpression | ts.TypeQueryNode | ts.TypeReferenceNode;
+    [AST_NODE_TYPES.TSTypePredicate]: ts.TypePredicateNode;
+    [AST_NODE_TYPES.TSTypeQuery]: ts.ImportTypeNode | ts.TypeQueryNode;
+    [AST_NODE_TYPES.TSTypeReference]: ts.TypeReferenceNode;
+    [AST_NODE_TYPES.TSUnionType]: ts.UnionTypeNode;
+    [AST_NODE_TYPES.UnaryExpression]: ts.DeleteExpression | ts.PostfixUnaryExpression | ts.PrefixUnaryExpression | ts.TypeOfExpression | ts.VoidExpression;
+    [AST_NODE_TYPES.UpdateExpression]: ts.PostfixUnaryExpression | ts.PrefixUnaryExpression;
+    [AST_NODE_TYPES.VariableDeclaration]: ts.VariableDeclarationList | ts.VariableStatement;
+    [AST_NODE_TYPES.VariableDeclarator]: ts.VariableDeclaration;
+    [AST_NODE_TYPES.WhileStatement]: ts.WhileStatement;
+    [AST_NODE_TYPES.WithStatement]: ts.WithStatement;
+    [AST_NODE_TYPES.YieldExpression]: ts.YieldExpression;
+    [AST_NODE_TYPES.TSEmptyBodyFunctionExpression]: ts.ConstructorDeclaration | ts.FunctionExpression | ts.GetAccessorDeclaration | ts.MethodDeclaration | ts.SetAccessorDeclaration;
+    [AST_NODE_TYPES.TSAbstractKeyword]: ts.Token<ts.SyntaxKind.AbstractKeyword>;
+    [AST_NODE_TYPES.TSAnyKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSBigIntKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSBooleanKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSIntrinsicKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSNeverKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSNullKeyword]: ts.KeywordTypeNode | ts.NullLiteral;
+    [AST_NODE_TYPES.TSNumberKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSObjectKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSStringKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSSymbolKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSUndefinedKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSUnknownKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSVoidKeyword]: ts.KeywordTypeNode;
+    [AST_NODE_TYPES.TSAsyncKeyword]: ts.Token<ts.SyntaxKind.AsyncKeyword>;
+    [AST_NODE_TYPES.TSDeclareKeyword]: ts.Token<ts.SyntaxKind.DeclareKeyword>;
+    [AST_NODE_TYPES.TSExportKeyword]: ts.Token<ts.SyntaxKind.ExportKeyword>;
+    [AST_NODE_TYPES.TSPrivateKeyword]: ts.Token<ts.SyntaxKind.PrivateKeyword>;
+    [AST_NODE_TYPES.TSProtectedKeyword]: ts.Token<ts.SyntaxKind.ProtectedKeyword>;
+    [AST_NODE_TYPES.TSPublicKeyword]: ts.Token<ts.SyntaxKind.PublicKeyword>;
+    [AST_NODE_TYPES.TSReadonlyKeyword]: ts.Token<ts.SyntaxKind.ReadonlyKeyword>;
+    [AST_NODE_TYPES.TSStaticKeyword]: ts.Token<ts.SyntaxKind.StaticKeyword>;
 }
 /**
  * Maps TSESTree AST Node type to the expected TypeScript AST Node type(s).
  * This mapping is based on the internal logic of the parser.
  */
-type TSESTreeToTSNode<T extends Node$1 = Node$1> = Extract<ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword> | TSNode, EstreeToTsNodeTypes[T['type']]>;
+type TSESTreeToTSNode<T extends Node = Node> = Extract<ts.Token<ts.SyntaxKind.ImportKeyword | ts.SyntaxKind.NewKeyword> | TSNode, EstreeToTsNodeTypes[T['type']]>;
 
 declare module 'typescript' {
     enum JSDocParsingMode {
@@ -4947,7 +2613,7 @@ interface ParserWeakMap<Key, ValueBase> {
     get<Value extends ValueBase>(key: Key): Value;
     has(key: unknown): boolean;
 }
-interface ParserWeakMapESTreeToTSNode<Key extends Node$1 = Node$1> {
+interface ParserWeakMapESTreeToTSNode<Key extends Node = Node> {
     get<KeyBase extends Key>(key: KeyBase): TSESTreeToTSNode<KeyBase>;
     has(key: unknown): boolean;
 }
@@ -4958,15 +2624,15 @@ interface ParserServicesBase {
 }
 interface ParserServicesNodeMaps {
     esTreeNodeToTSNodeMap: ParserWeakMapESTreeToTSNode;
-    tsNodeToESTreeNodeMap: ParserWeakMap<TSNode | TSToken, Node$1>;
+    tsNodeToESTreeNodeMap: ParserWeakMap<TSNode | TSToken, Node>;
 }
 interface ParserServicesWithTypeInformation extends ParserServicesNodeMaps, ParserServicesBase {
-    getSymbolAtLocation: (node: Node$1) => ts.Symbol | undefined;
-    getTypeAtLocation: (node: Node$1) => ts.Type;
-    getContextualType: (node: Expression$1) => ts.Type | undefined;
-    getResolvedSignature: (node: CallExpression$1 | NewExpression$1) => ts.Signature | undefined;
-    getTypeFromTypeNode: (node: TypeNode$1) => ts.Type;
-    getTypeOfSymbolAtLocation: (symbol: ts.Symbol, node: Node$1) => ts.Type;
+    getSymbolAtLocation: (node: Node) => ts.Symbol | undefined;
+    getTypeAtLocation: (node: Node) => ts.Type;
+    getContextualType: (node: Expression) => ts.Type | undefined;
+    getResolvedSignature: (node: CallExpression | NewExpression) => ts.Signature | undefined;
+    getTypeFromTypeNode: (node: TypeNode) => ts.Type;
+    getTypeOfSymbolAtLocation: (symbol: ts.Symbol, node: Node) => ts.Type;
     program: ts.Program;
 }
 interface ParserServicesWithoutTypeInformation extends ParserServicesNodeMaps, ParserServicesBase {
@@ -4975,10 +2641,10 @@ interface ParserServicesWithoutTypeInformation extends ParserServicesNodeMaps, P
 type ParserServices = ParserServicesWithoutTypeInformation | ParserServicesWithTypeInformation;
 
 declare namespace AST {
-    type TokenType = AST_TOKEN_TYPES$1;
-    type Token = Token$1;
-    type SourceLocation = SourceLocation$1;
-    type Range = Range$1;
+    type TokenType = AST_TOKEN_TYPES;
+    type Token = Token;
+    type SourceLocation = SourceLocation;
+    type Range = Range;
 }
 
 declare enum DefinitionType {
@@ -4995,7 +2661,7 @@ declare enum DefinitionType {
     Variable = "Variable"
 }
 
-declare abstract class DefinitionBase<Type extends DefinitionType, Node extends NodeWithParent, Parent extends Node$1 | null, Name extends Node$1> {
+declare abstract class DefinitionBase<Type extends DefinitionType, Node extends NodeWithParent, Parent extends Node | null, Name extends Node> {
     /**
      * A unique ID for this instance - primarily used to help debugging and testing
      */
@@ -5027,75 +2693,75 @@ declare abstract class DefinitionBase<Type extends DefinitionType, Node extends
     abstract readonly isVariableDefinition: boolean;
 }
 
-declare class CatchClauseDefinition extends DefinitionBase<DefinitionType.CatchClause, CatchClause$1, null, Identifier$1> {
+declare class CatchClauseDefinition extends DefinitionBase<DefinitionType.CatchClause, CatchClause, null, Identifier> {
     readonly isTypeDefinition = false;
     readonly isVariableDefinition = true;
-    constructor(name: Identifier$1, node: CatchClauseDefinition['node']);
+    constructor(name: Identifier, node: CatchClauseDefinition['node']);
 }
 
-declare class ClassNameDefinition extends DefinitionBase<DefinitionType.ClassName, ClassDeclaration$1 | ClassExpression$1, null, Identifier$1> {
+declare class ClassNameDefinition extends DefinitionBase<DefinitionType.ClassName, ClassDeclaration | ClassExpression, null, Identifier> {
     readonly isTypeDefinition = true;
     readonly isVariableDefinition = true;
-    constructor(name: Identifier$1, node: ClassNameDefinition['node']);
+    constructor(name: Identifier, node: ClassNameDefinition['node']);
 }
 
-declare class FunctionNameDefinition extends DefinitionBase<DefinitionType.FunctionName, FunctionDeclaration$1 | FunctionExpression$1 | TSDeclareFunction$1 | TSEmptyBodyFunctionExpression$1, null, Identifier$1> {
+declare class FunctionNameDefinition extends DefinitionBase<DefinitionType.FunctionName, FunctionDeclaration | FunctionExpression | TSDeclareFunction | TSEmptyBodyFunctionExpression, null, Identifier> {
     readonly isTypeDefinition = false;
     readonly isVariableDefinition = true;
-    constructor(name: Identifier$1, node: FunctionNameDefinition['node']);
+    constructor(name: Identifier, node: FunctionNameDefinition['node']);
 }
 
-declare class ImplicitGlobalVariableDefinition extends DefinitionBase<DefinitionType.ImplicitGlobalVariable, NodeWithParent, null, BindingName$1> {
+declare class ImplicitGlobalVariableDefinition extends DefinitionBase<DefinitionType.ImplicitGlobalVariable, NodeWithParent, null, BindingName> {
     readonly isTypeDefinition = false;
     readonly isVariableDefinition = true;
-    constructor(name: BindingName$1, node: ImplicitGlobalVariableDefinition['node']);
+    constructor(name: BindingName, node: ImplicitGlobalVariableDefinition['node']);
 }
 
-declare class ImportBindingDefinition extends DefinitionBase<DefinitionType.ImportBinding, ImportDefaultSpecifier$1 | ImportNamespaceSpecifier$1 | ImportSpecifier$1 | TSImportEqualsDeclaration$1, ImportDeclaration$1 | TSImportEqualsDeclaration$1, Identifier$1> {
+declare class ImportBindingDefinition extends DefinitionBase<DefinitionType.ImportBinding, ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier | TSImportEqualsDeclaration, ImportDeclaration | TSImportEqualsDeclaration, Identifier> {
     readonly isTypeDefinition = true;
     readonly isVariableDefinition = true;
-    constructor(name: Identifier$1, node: TSImportEqualsDeclaration$1, decl: TSImportEqualsDeclaration$1);
-    constructor(name: Identifier$1, node: Exclude<ImportBindingDefinition['node'], TSImportEqualsDeclaration$1>, decl: ImportDeclaration$1);
+    constructor(name: Identifier, node: TSImportEqualsDeclaration, decl: TSImportEqualsDeclaration);
+    constructor(name: Identifier, node: Exclude<ImportBindingDefinition['node'], TSImportEqualsDeclaration>, decl: ImportDeclaration);
 }
 
-declare class ParameterDefinition extends DefinitionBase<DefinitionType.Parameter, ArrowFunctionExpression$1 | FunctionDeclaration$1 | FunctionExpression$1 | TSCallSignatureDeclaration$1 | TSConstructorType$1 | TSConstructSignatureDeclaration$1 | TSDeclareFunction$1 | TSEmptyBodyFunctionExpression$1 | TSFunctionType$1 | TSMethodSignature$1, null, BindingName$1> {
+declare class ParameterDefinition extends DefinitionBase<DefinitionType.Parameter, ArrowFunctionExpression | FunctionDeclaration | FunctionExpression | TSCallSignatureDeclaration | TSConstructorType | TSConstructSignatureDeclaration | TSDeclareFunction | TSEmptyBodyFunctionExpression | TSFunctionType | TSMethodSignature, null, BindingName> {
     /**
      * Whether the parameter definition is a part of a rest parameter.
      */
     readonly isTypeDefinition = false;
     readonly isVariableDefinition = true;
     readonly rest: boolean;
-    constructor(name: BindingName$1, node: ParameterDefinition['node'], rest: boolean);
+    constructor(name: BindingName, node: ParameterDefinition['node'], rest: boolean);
 }
 
-declare class TSEnumMemberDefinition extends DefinitionBase<DefinitionType.TSEnumMember, TSEnumMember$1, null, Identifier$1 | StringLiteral$1> {
+declare class TSEnumMemberDefinition extends DefinitionBase<DefinitionType.TSEnumMember, TSEnumMember, null, Identifier | StringLiteral> {
     readonly isTypeDefinition = true;
     readonly isVariableDefinition = true;
-    constructor(name: Identifier$1 | StringLiteral$1, node: TSEnumMemberDefinition['node']);
+    constructor(name: Identifier | StringLiteral, node: TSEnumMemberDefinition['node']);
 }
 
-declare class TSEnumNameDefinition extends DefinitionBase<DefinitionType.TSEnumName, TSEnumDeclaration$1, null, Identifier$1> {
+declare class TSEnumNameDefinition extends DefinitionBase<DefinitionType.TSEnumName, TSEnumDeclaration, null, Identifier> {
     readonly isTypeDefinition = true;
     readonly isVariableDefinition = true;
-    constructor(name: Identifier$1, node: TSEnumNameDefinition['node']);
+    constructor(name: Identifier, node: TSEnumNameDefinition['node']);
 }
 
-declare class TSModuleNameDefinition extends DefinitionBase<DefinitionType.TSModuleName, TSModuleDeclaration$1, null, Identifier$1> {
+declare class TSModuleNameDefinition extends DefinitionBase<DefinitionType.TSModuleName, TSModuleDeclaration, null, Identifier> {
     readonly isTypeDefinition = true;
     readonly isVariableDefinition = true;
-    constructor(name: Identifier$1, node: TSModuleNameDefinition['node']);
+    constructor(name: Identifier, node: TSModuleNameDefinition['node']);
 }
 
-declare class TypeDefinition extends DefinitionBase<DefinitionType.Type, TSInterfaceDeclaration$1 | TSMappedType$1 | TSTypeAliasDeclaration$1 | TSTypeParameter$1, null, Identifier$1> {
+declare class TypeDefinition extends DefinitionBase<DefinitionType.Type, TSInterfaceDeclaration | TSMappedType | TSTypeAliasDeclaration | TSTypeParameter, null, Identifier> {
     readonly isTypeDefinition = true;
     readonly isVariableDefinition = false;
-    constructor(name: Identifier$1, node: TypeDefinition['node']);
+    constructor(name: Identifier, node: TypeDefinition['node']);
 }
 
-declare class VariableDefinition extends DefinitionBase<DefinitionType.Variable, VariableDeclarator$1, VariableDeclaration$1, Identifier$1> {
+declare class VariableDefinition extends DefinitionBase<DefinitionType.Variable, VariableDeclarator, VariableDeclaration, Identifier> {
     readonly isTypeDefinition = false;
     readonly isVariableDefinition = true;
-    constructor(name: Identifier$1, node: VariableDefinition['node'], decl: VariableDeclaration$1);
+    constructor(name: Identifier, node: VariableDefinition['node'], decl: VariableDeclaration);
 }
 
 type Definition = CatchClauseDefinition | ClassNameDefinition | FunctionNameDefinition | ImplicitGlobalVariableDefinition | ImportBindingDefinition | ParameterDefinition | TSEnumMemberDefinition | TSEnumNameDefinition | TSModuleNameDefinition | TypeDefinition | VariableDefinition;
@@ -5107,7 +2773,7 @@ declare enum ReferenceFlag {
 }
 interface ReferenceImplicitGlobal {
     node: NodeWithParent;
-    pattern: BindingName$1;
+    pattern: BindingName;
     ref?: Reference;
 }
 declare enum ReferenceTypeFlag {
@@ -5132,7 +2798,7 @@ declare class Reference {
      * Identifier syntax node.
      * @public
      */
-    readonly identifier: Identifier$1 | JSXIdentifier$1;
+    readonly identifier: Identifier | JSXIdentifier;
     /**
      * `true` if this writing reference is a variable initializer or a default value.
      * @public
@@ -5148,8 +2814,8 @@ declare class Reference {
      * If reference is writeable, this is the node being written to it.
      * @public
      */
-    readonly writeExpr?: Node$1 | null;
-    constructor(identifier: Identifier$1 | JSXIdentifier$1, scope: Scope$1, flag: ReferenceFlag, writeExpr?: Node$1 | null, maybeImplicitGlobal?: ReferenceImplicitGlobal | null, init?: boolean, referenceType?: ReferenceTypeFlag);
+    readonly writeExpr?: Node | null;
+    constructor(identifier: Identifier | JSXIdentifier, scope: Scope$1, flag: ReferenceFlag, writeExpr?: Node | null, maybeImplicitGlobal?: ReferenceImplicitGlobal | null, init?: boolean, referenceType?: ReferenceTypeFlag);
     /**
      * True if this reference can reference types
      */
@@ -5205,7 +2871,7 @@ declare class VariableBase {
      * If this variable is redeclared, this array includes two or more nodes.
      * @public
      */
-    readonly identifiers: Identifier$1[];
+    readonly identifiers: Identifier[];
     /**
      * The variable name, as given in the source code.
      * @public
@@ -5252,7 +2918,7 @@ declare class ESLintScopeVariable extends VariableBase {
      * If this key exists, it is a global variable added by ESLint.
      * If `true`, this global variable was defined by a globals comment directive in the source code file.
      */
-    eslintExplicitGlobalComments?: Comment$1[];
+    eslintExplicitGlobalComments?: Comment[];
 }
 
 /**
@@ -5301,12 +2967,12 @@ declare enum ScopeType {
     with = "with"
 }
 
-declare class FunctionScope extends ScopeBase<ScopeType.function, ArrowFunctionExpression$1 | FunctionDeclaration$1 | FunctionExpression$1 | Program$1 | TSDeclareFunction$1 | TSEmptyBodyFunctionExpression$1, Scope$1> {
+declare class FunctionScope extends ScopeBase<ScopeType.function, ArrowFunctionExpression | FunctionDeclaration | FunctionExpression | Program | TSDeclareFunction | TSEmptyBodyFunctionExpression, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: FunctionScope['upper'], block: FunctionScope['block'], isMethodDefinition: boolean);
     protected isValidResolution(ref: Reference, variable: Variable): boolean;
 }
 
-declare class GlobalScope extends ScopeBase<ScopeType.global, Program$1, 
+declare class GlobalScope extends ScopeBase<ScopeType.global, Program, 
 /**
  * The global scope has no parent.
  */
@@ -5318,16 +2984,16 @@ null> {
     defineImplicitVariable(name: string, options: ImplicitLibVariableOptions): void;
 }
 
-declare class ModuleScope extends ScopeBase<ScopeType.module, Program$1, Scope$1> {
+declare class ModuleScope extends ScopeBase<ScopeType.module, Program, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: ModuleScope['upper'], block: ModuleScope['block']);
 }
 
-declare class TSModuleScope extends ScopeBase<ScopeType.tsModule, TSModuleDeclaration$1, Scope$1> {
+declare class TSModuleScope extends ScopeBase<ScopeType.tsModule, TSModuleDeclaration, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: TSModuleScope['upper'], block: TSModuleScope['block']);
 }
 
 type VariableScope = FunctionScope | GlobalScope | ModuleScope | TSModuleScope;
-declare abstract class ScopeBase<Type extends ScopeType, Block extends Node$1, Upper extends Scope$1 | null> {
+declare abstract class ScopeBase<Type extends ScopeType, Block extends Node, Upper extends Scope$1 | null> {
     #private;
     /**
      * A unique ID for this instance - primarily used to help debugging and testing
@@ -5399,70 +3065,70 @@ declare abstract class ScopeBase<Type extends ScopeType, Block extends Node$1, U
      * To override by function scopes.
      * References in default parameters isn't resolved to variables which are in their function body.
      */
-    protected defineVariable(nameOrVariable: string | Variable, set: Map<string, Variable>, variables: Variable[], node: Identifier$1 | null, def: Definition | null): void;
+    protected defineVariable(nameOrVariable: string | Variable, set: Map<string, Variable>, variables: Variable[], node: Identifier | null, def: Definition | null): void;
     protected delegateToUpperScope(ref: Reference): void;
     protected isValidResolution(_ref: Reference, _variable: Variable): boolean;
     private addDeclaredVariablesOfNode;
-    defineIdentifier(node: Identifier$1, def: Definition): void;
-    defineLiteralIdentifier(node: StringLiteral$1, def: Definition): void;
-    referenceDualValueType(node: Identifier$1): void;
-    referenceType(node: Identifier$1): void;
-    referenceValue(node: Identifier$1 | JSXIdentifier$1, assign?: ReferenceFlag, writeExpr?: Expression$1 | null, maybeImplicitGlobal?: ReferenceImplicitGlobal | null, init?: boolean): void;
+    defineIdentifier(node: Identifier, def: Definition): void;
+    defineLiteralIdentifier(node: StringLiteral, def: Definition): void;
+    referenceDualValueType(node: Identifier): void;
+    referenceType(node: Identifier): void;
+    referenceValue(node: Identifier | JSXIdentifier, assign?: ReferenceFlag, writeExpr?: Expression | null, maybeImplicitGlobal?: ReferenceImplicitGlobal | null, init?: boolean): void;
 }
 
-declare class CatchScope extends ScopeBase<ScopeType.catch, CatchClause$1, Scope$1> {
+declare class CatchScope extends ScopeBase<ScopeType.catch, CatchClause, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: CatchScope['upper'], block: CatchScope['block']);
 }
 
-declare class ClassScope extends ScopeBase<ScopeType.class, ClassDeclaration$1 | ClassExpression$1, Scope$1> {
+declare class ClassScope extends ScopeBase<ScopeType.class, ClassDeclaration | ClassExpression, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: ClassScope['upper'], block: ClassScope['block']);
 }
 
-declare class ClassStaticBlockScope extends ScopeBase<ScopeType.classStaticBlock, StaticBlock$1, Scope$1> {
+declare class ClassStaticBlockScope extends ScopeBase<ScopeType.classStaticBlock, StaticBlock, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: ClassStaticBlockScope['upper'], block: ClassStaticBlockScope['block']);
 }
 
-declare class ConditionalTypeScope extends ScopeBase<ScopeType.conditionalType, TSConditionalType$1, Scope$1> {
+declare class ConditionalTypeScope extends ScopeBase<ScopeType.conditionalType, TSConditionalType, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: ConditionalTypeScope['upper'], block: ConditionalTypeScope['block']);
 }
 
-declare class ForScope extends ScopeBase<ScopeType.for, ForInStatement$1 | ForOfStatement$1 | ForStatement$1, Scope$1> {
+declare class ForScope extends ScopeBase<ScopeType.for, ForInStatement | ForOfStatement | ForStatement, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: ForScope['upper'], block: ForScope['block']);
 }
 
-declare class FunctionExpressionNameScope extends ScopeBase<ScopeType.functionExpressionName, FunctionExpression$1, Scope$1> {
+declare class FunctionExpressionNameScope extends ScopeBase<ScopeType.functionExpressionName, FunctionExpression, Scope$1> {
     readonly functionExpressionScope: true;
     constructor(scopeManager: ScopeManager, upperScope: FunctionExpressionNameScope['upper'], block: FunctionExpressionNameScope['block']);
 }
 
-declare class FunctionTypeScope extends ScopeBase<ScopeType.functionType, TSCallSignatureDeclaration$1 | TSConstructorType$1 | TSConstructSignatureDeclaration$1 | TSFunctionType$1 | TSMethodSignature$1, Scope$1> {
+declare class FunctionTypeScope extends ScopeBase<ScopeType.functionType, TSCallSignatureDeclaration | TSConstructorType | TSConstructSignatureDeclaration | TSFunctionType | TSMethodSignature, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: FunctionTypeScope['upper'], block: FunctionTypeScope['block']);
 }
 
-declare class MappedTypeScope extends ScopeBase<ScopeType.mappedType, TSMappedType$1, Scope$1> {
+declare class MappedTypeScope extends ScopeBase<ScopeType.mappedType, TSMappedType, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: MappedTypeScope['upper'], block: MappedTypeScope['block']);
 }
 
-declare class SwitchScope extends ScopeBase<ScopeType.switch, SwitchStatement$1, Scope$1> {
+declare class SwitchScope extends ScopeBase<ScopeType.switch, SwitchStatement, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: SwitchScope['upper'], block: SwitchScope['block']);
 }
 
-declare class TSEnumScope extends ScopeBase<ScopeType.tsEnum, TSEnumDeclaration$1, Scope$1> {
+declare class TSEnumScope extends ScopeBase<ScopeType.tsEnum, TSEnumDeclaration, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: TSEnumScope['upper'], block: TSEnumScope['block']);
 }
 
-declare class TypeScope extends ScopeBase<ScopeType.type, TSInterfaceDeclaration$1 | TSTypeAliasDeclaration$1, Scope$1> {
+declare class TypeScope extends ScopeBase<ScopeType.type, TSInterfaceDeclaration | TSTypeAliasDeclaration, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: TypeScope['upper'], block: TypeScope['block']);
 }
 
-declare class WithScope extends ScopeBase<ScopeType.with, WithStatement$1, Scope$1> {
+declare class WithScope extends ScopeBase<ScopeType.with, WithStatement, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: WithScope['upper'], block: WithScope['block']);
     close(scopeManager: ScopeManager): Scope$1 | null;
 }
 
 type Scope$1 = BlockScope | CatchScope | ClassFieldInitializerScope | ClassScope | ClassStaticBlockScope | ConditionalTypeScope | ForScope | FunctionExpressionNameScope | FunctionScope | FunctionTypeScope | GlobalScope | MappedTypeScope | ModuleScope | SwitchScope | TSEnumScope | TSModuleScope | TypeScope | WithScope;
 
-declare class ClassFieldInitializerScope extends ScopeBase<ScopeType.classFieldInitializer, Expression$1, Scope$1> {
+declare class ClassFieldInitializerScope extends ScopeBase<ScopeType.classFieldInitializer, Expression, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: ClassFieldInitializerScope['upper'], block: ClassFieldInitializerScope['block']);
 }
 
@@ -5477,12 +3143,12 @@ interface ScopeManagerOptions {
 declare class ScopeManager {
     #private;
     currentScope: Scope$1 | null;
-    readonly declaredVariables: WeakMap<Node$1, Variable[]>;
+    readonly declaredVariables: WeakMap<Node, Variable[]>;
     /**
      * The root scope
      */
     globalScope: GlobalScope | null;
-    readonly nodeToScope: WeakMap<Node$1, Scope$1[]>;
+    readonly nodeToScope: WeakMap<Node, Scope$1[]>;
     /**
      * All scopes
      * @public
@@ -5500,7 +3166,7 @@ declare class ScopeManager {
      * If the node does not define any variable, this returns an empty array.
      * @param node An AST node to get their variables.
      */
-    getDeclaredVariables(node: Node$1): Variable[];
+    getDeclaredVariables(node: Node): Variable[];
     /**
      * Get the scope of a given AST node. The gotten scope's `block` property is the node.
      * This method never returns `function-expression-name` scope. If the node does not have their scope, this returns `null`.
@@ -5509,7 +3175,7 @@ declare class ScopeManager {
      * @param inner If the node has multiple scopes, this returns the outermost scope normally.
      *                If `inner` is `true` then this returns the innermost scope.
      */
-    acquire(node: Node$1, inner?: boolean): Scope$1 | null;
+    acquire(node: Node, inner?: boolean): Scope$1 | null;
     /**
      * Adds dynamically created globals to the global scope and resolve their references.
      * This method is called by ESLint.
@@ -5537,7 +3203,7 @@ declare class ScopeManager {
     protected nestScope<T extends Scope$1>(scope: T): T;
 }
 
-declare class BlockScope extends ScopeBase<ScopeType.block, BlockStatement$1, Scope$1> {
+declare class BlockScope extends ScopeBase<ScopeType.block, BlockStatement, Scope$1> {
     constructor(scopeManager: ScopeManager, upperScope: BlockScope['upper'], block: BlockScope['block']);
 }
 
@@ -5643,13 +3309,13 @@ declare namespace Parser {
         /**
          * Parses the given text into an ESTree AST
          */
-        parse(text: string, options?: ParserOptions): Program$1;
+        parse(text: string, options?: ParserOptions): Program;
     };
     interface ParseResult {
         /**
          * The ESTree AST
          */
-        ast: Program$1;
+        ast: Program;
         /**
          * A `ScopeManager` object.
          * Custom parsers can use customized scope analysis for experimental/enhancement syntaxes.
@@ -6069,32 +3735,32 @@ declare class TokenStore {
      * @param right The node to check.
      * @returns `true` if one or more comments exist.
      */
-    commentsExistBetween(left: Node$1 | Token$1, right: Node$1 | Token$1): boolean;
+    commentsExistBetween(left: Node | Token, right: Node | Token): boolean;
     /**
      * Gets all comment tokens directly after the given node or token.
      * @param nodeOrToken The AST node or token to check for adjacent comment tokens.
      * @returns An array of comments in occurrence order.
      */
-    getCommentsAfter(nodeOrToken: Node$1 | Token$1): Comment$1[];
+    getCommentsAfter(nodeOrToken: Node | Token): Comment[];
     /**
      * Gets all comment tokens directly before the given node or token.
      * @param nodeOrToken The AST node or token to check for adjacent comment tokens.
      * @returns An array of comments in occurrence order.
      */
-    getCommentsBefore(nodeOrToken: Node$1 | Token$1): Comment$1[];
+    getCommentsBefore(nodeOrToken: Node | Token): Comment[];
     /**
      * Gets all comment tokens inside the given node.
      * @param node The AST node to get the comments for.
      * @returns An array of comments in occurrence order.
      */
-    getCommentsInside(node: Node$1): Comment$1[];
+    getCommentsInside(node: Node): Comment[];
     /**
      * Gets the first token of the given node.
      * @param node The AST node.
      * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
      * @returns An object representing the token.
      */
-    getFirstToken<T extends SourceCode.CursorWithSkipOptions>(node: Node$1, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    getFirstToken<T extends SourceCode.CursorWithSkipOptions>(node: Node, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
     /**
      * Gets the first token between two non-overlapping nodes.
      * @param left Node before the desired token range.
@@ -6102,13 +3768,13 @@ declare class TokenStore {
      * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
      * @returns An object representing the token.
      */
-    getFirstTokenBetween<T extends SourceCode.CursorWithSkipOptions>(left: Node$1 | Token$1, right: Node$1 | Token$1, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    getFirstTokenBetween<T extends SourceCode.CursorWithSkipOptions>(left: Node | Token, right: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
     /**
      * Gets the first `count` tokens of the given node.
      * @param node The AST node.
      * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
      */
-    getFirstTokens<T extends SourceCode.CursorWithCountOptions>(node: Node$1, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    getFirstTokens<T extends SourceCode.CursorWithCountOptions>(node: Node, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
     /**
      * Gets the first `count` tokens between two non-overlapping nodes.
      * @param left Node before the desired token range.
@@ -6116,14 +3782,14 @@ declare class TokenStore {
      * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
      * @returns Tokens between left and right.
      */
-    getFirstTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: Node$1 | Token$1, right: Node$1 | Token$1, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    getFirstTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: Node | Token, right: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
     /**
      * Gets the last token of the given node.
      * @param node The AST node.
      * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
      * @returns An object representing the token.
      */
-    getLastToken<T extends SourceCode.CursorWithSkipOptions>(node: Node$1, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    getLastToken<T extends SourceCode.CursorWithSkipOptions>(node: Node, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
     /**
      * Gets the last token between two non-overlapping nodes.
      * @param left Node before the desired token range.
@@ -6131,13 +3797,13 @@ declare class TokenStore {
      * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
      * @returns An object representing the token.
      */
-    getLastTokenBetween<T extends SourceCode.CursorWithSkipOptions>(left: Node$1 | Token$1, right: Node$1 | Token$1, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    getLastTokenBetween<T extends SourceCode.CursorWithSkipOptions>(left: Node | Token, right: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
     /**
      * Gets the last `count` tokens of the given node.
      * @param node The AST node.
      * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
      */
-    getLastTokens<T extends SourceCode.CursorWithCountOptions>(node: Node$1, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    getLastTokens<T extends SourceCode.CursorWithCountOptions>(node: Node, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
     /**
      * Gets the last `count` tokens between two non-overlapping nodes.
      * @param left Node before the desired token range.
@@ -6145,21 +3811,21 @@ declare class TokenStore {
      * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
      * @returns Tokens between left and right.
      */
-    getLastTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: Node$1 | Token$1, right: Node$1 | Token$1, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
+    getLastTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: Node | Token, right: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions<T>[];
     /**
      * Gets the token that follows a given node or token.
      * @param node The AST node or token.
      * @param options The option object. If this is a number then it's `options.skip`. If this is a function then it's `options.filter`.
      * @returns An object representing the token.
      */
-    getTokenAfter<T extends SourceCode.CursorWithSkipOptions>(node: Node$1 | Token$1, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    getTokenAfter<T extends SourceCode.CursorWithSkipOptions>(node: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
     /**
      * Gets the token that precedes a given node or token.
      * @param node The AST node or token.
      * @param options The option object
      * @returns An object representing the token.
      */
-    getTokenBefore<T extends SourceCode.CursorWithSkipOptions>(node: Node$1 | Token$1, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
+    getTokenBefore<T extends SourceCode.CursorWithSkipOptions>(node: Node | Token, options?: T): SourceCode.ReturnTypeFromOptions<T> | null;
     /**
      * Gets the token starting at the specified index.
      * @param offset Index of the start of the token's range.
@@ -6176,26 +3842,26 @@ declare class TokenStore {
      * @param afterCount The number of tokens after the node to retrieve.
      * @returns Array of objects representing tokens.
      */
-    getTokens(node: Node$1, beforeCount?: number, afterCount?: number): Token$1[];
+    getTokens(node: Node, beforeCount?: number, afterCount?: number): Token[];
     /**
      * Gets all tokens that are related to the given node.
      * @param node The AST node.
      * @param options The option object. If this is a function then it's `options.filter`.
      * @returns Array of objects representing tokens.
      */
-    getTokens<T extends SourceCode.CursorWithCountOptions>(node: Node$1, options: T): SourceCode.ReturnTypeFromOptions<T>[];
+    getTokens<T extends SourceCode.CursorWithCountOptions>(node: Node, options: T): SourceCode.ReturnTypeFromOptions<T>[];
     /**
      * Gets the `count` tokens that follows a given node or token.
      * @param node The AST node.
      * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
      */
-    getTokensAfter<T extends SourceCode.CursorWithCountOptions>(node: Node$1 | Token$1, options?: number | T): SourceCode.ReturnTypeFromOptions<T>[];
+    getTokensAfter<T extends SourceCode.CursorWithCountOptions>(node: Node | Token, options?: number | T): SourceCode.ReturnTypeFromOptions<T>[];
     /**
      * Gets the `count` tokens that precedes a given node or token.
      * @param node The AST node.
      * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
      */
-    getTokensBefore<T extends SourceCode.CursorWithCountOptions>(node: Node$1 | Token$1, options?: number | T): SourceCode.ReturnTypeFromOptions<T>[];
+    getTokensBefore<T extends SourceCode.CursorWithCountOptions>(node: Node | Token, options?: number | T): SourceCode.ReturnTypeFromOptions<T>[];
     /**
      * Gets all of the tokens between two non-overlapping nodes.
      * @param left Node before the desired token range.
@@ -6203,7 +3869,7 @@ declare class TokenStore {
      * @param options The option object. If this is a number then it's `options.count`. If this is a function then it's `options.filter`.
      * @returns Tokens between left and right.
      */
-    getTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: Node$1 | Token$1, right: Node$1 | Token$1, options?: number | T): SourceCode.ReturnTypeFromOptions<T>[];
+    getTokensBetween<T extends SourceCode.CursorWithCountOptions>(left: Node | Token, right: Node | Token, options?: number | T): SourceCode.ReturnTypeFromOptions<T>[];
 }
 declare class SourceCodeBase extends TokenStore {
     /**
@@ -6227,13 +3893,13 @@ declare class SourceCodeBase extends TokenStore {
      * Retrieves an array containing all comments in the source code.
      * @returns An array of comment nodes.
      */
-    getAllComments(): Comment$1[];
+    getAllComments(): Comment[];
     /**
      * Converts a (line, column) pair into a range index.
      * @param location A line/column location
      * @returns The range index of the location in the file.
      */
-    getIndexFromLoc(location: Position$1): number;
+    getIndexFromLoc(location: Position): number;
     /**
      * Gets the entire source text split into an array of lines.
      * @returns The source text as an array of lines.
@@ -6244,13 +3910,13 @@ declare class SourceCodeBase extends TokenStore {
      * @param index The index of a character in a file
      * @returns A {line, column} location object with a 0-indexed column
      */
-    getLocFromIndex(index: number): Position$1;
+    getLocFromIndex(index: number): Position;
     /**
      * Gets the deepest node containing a range index.
      * @param index Range index of the desired node.
      * @returns The node if found or `null` if not found.
      */
-    getNodeByRangeIndex(index: number): Node$1 | null;
+    getNodeByRangeIndex(index: number): Node | null;
     /**
      * Gets the source code for the given node.
      * @param node The AST node to get the text for.
@@ -6258,7 +3924,7 @@ declare class SourceCodeBase extends TokenStore {
      * @param afterCount The number of characters after the node to retrieve.
      * @returns The text representing the AST node.
      */
-    getText(node?: Node$1 | Token$1, beforeCount?: number, afterCount?: number): string;
+    getText(node?: Node | Token, beforeCount?: number, afterCount?: number): string;
     /**
      * The flag to indicate that the source code has Unicode BOM.
      */
@@ -6271,7 +3937,7 @@ declare class SourceCodeBase extends TokenStore {
      * @param second The second node or token to check between.
      * @returns True if there is a whitespace character between any of the tokens found between the two given nodes or tokens.
      */
-    isSpaceBetween(first: Node$1 | Token$1, second: Node$1 | Token$1): boolean;
+    isSpaceBetween(first: Node | Token, second: Node | Token): boolean;
     /**
      * Determines if two nodes or tokens have at least one whitespace character
      * between them. Order does not matter. Returns false if the given nodes or
@@ -6284,28 +3950,28 @@ declare class SourceCodeBase extends TokenStore {
      * any of the tokens found between the two given nodes or tokens.
      * @deprecated in favor of isSpaceBetween
      */
-    isSpaceBetweenTokens(first: Token$1, second: Token$1): boolean;
+    isSpaceBetweenTokens(first: Token, second: Token): boolean;
     /**
      * Returns the scope of the given node.
      * This information can be used track references to variables.
      */
-    getScope(node: Node$1): Scope.Scope;
+    getScope(node: Node): Scope.Scope;
     /**
      * Returns an array of the ancestors of the given node, starting at
      * the root of the AST and continuing through the direct parent of the current node.
      * This array does not include the currently-traversed node itself.
      */
-    getAncestors(node: Node$1): Node$1[];
+    getAncestors(node: Node): Node[];
     /**
      * Returns a list of variables declared by the given node.
      * This information can be used to track references to variables.
      */
-    getDeclaredVariables(node: Node$1): readonly Scope.Variable[];
+    getDeclaredVariables(node: Node): readonly Scope.Variable[];
     /**
      * Marks a variable with the given name in the current scope as used.
      * This affects the no-unused-vars rule.
      */
-    markVariableAsUsed(name: string, node: Node$1): boolean;
+    markVariableAsUsed(name: string, node: Node): boolean;
     /**
      * The source code split into lines according to ECMA-262 specification.
      * This is done to avoid each rule needing to do so separately.
@@ -6332,7 +3998,7 @@ declare class SourceCodeBase extends TokenStore {
      *
      * TODO: rename to 'tokens'
      */
-    tokensAndComments: Token$1[];
+    tokensAndComments: Token[];
     /**
      * The visitor keys to traverse AST.
      */
@@ -6346,9 +4012,9 @@ declare class SourceCodeBase extends TokenStore {
 }
 declare const SourceCode_base: typeof SourceCodeBase;
 declare namespace SourceCode {
-    interface Program extends Program$1 {
-        comments: Comment$1[];
-        tokens: Token$1[];
+    interface Program extends Program {
+        comments: Comment[];
+        tokens: Token[];
     }
     interface SourceCodeConfig {
         /**
@@ -6373,14 +4039,14 @@ declare namespace SourceCode {
         visitorKeys: VisitorKeys | null;
     }
     type VisitorKeys = Parser.VisitorKeys;
-    type FilterPredicate = (token: Token$1) => boolean;
-    type GetFilterPredicate<Filter, Default> = Filter extends ((token: Token$1) => token is infer U extends Token$1) ? U : Default;
+    type FilterPredicate = (token: Token) => boolean;
+    type GetFilterPredicate<Filter, Default> = Filter extends ((token: Token) => token is infer U extends Token) ? U : Default;
     type GetFilterPredicateFromOptions<Options, Default> = Options extends {
         filter?: FilterPredicate;
     } ? GetFilterPredicate<Options['filter'], Default> : GetFilterPredicate<Options, Default>;
     type ReturnTypeFromOptions<T> = T extends {
         includeComments: true;
-    } ? GetFilterPredicateFromOptions<T, Token$1> : GetFilterPredicateFromOptions<T, Exclude<Token$1, Comment$1>>;
+    } ? GetFilterPredicateFromOptions<T, Token> : GetFilterPredicateFromOptions<T, Exclude<Token, Comment>>;
     type CursorWithSkipOptions = number | FilterPredicate | {
         /**
          * The predicate function to choose tokens.
@@ -6536,13 +4202,13 @@ interface RuleFix {
     text: string;
 }
 interface RuleFixer {
-    insertTextAfter(nodeOrToken: Node$1 | Token$1, text: string): RuleFix;
+    insertTextAfter(nodeOrToken: Node | Token, text: string): RuleFix;
     insertTextAfterRange(range: Readonly<AST.Range>, text: string): RuleFix;
-    insertTextBefore(nodeOrToken: Node$1 | Token$1, text: string): RuleFix;
+    insertTextBefore(nodeOrToken: Node | Token, text: string): RuleFix;
     insertTextBeforeRange(range: Readonly<AST.Range>, text: string): RuleFix;
-    remove(nodeOrToken: Node$1 | Token$1): RuleFix;
+    remove(nodeOrToken: Node | Token): RuleFix;
     removeRange(range: Readonly<AST.Range>): RuleFix;
-    replaceText(nodeOrToken: Node$1 | Token$1, text: string): RuleFix;
+    replaceText(nodeOrToken: Node | Token, text: string): RuleFix;
     replaceTextRange(range: Readonly<AST.Range>, text: string): RuleFix;
 }
 interface SuggestionReportDescriptor<MessageIds extends string> extends Omit<ReportDescriptorBase<MessageIds>, 'fix'> {
@@ -6575,17 +4241,17 @@ interface ReportDescriptorNodeOptionalLoc {
     /**
      * An override of the location of the report
      */
-    readonly loc?: Readonly<Position$1> | Readonly<SourceLocation$1>;
+    readonly loc?: Readonly<Position> | Readonly<SourceLocation>;
     /**
      * The Node or AST Token which the report is being attached to
      */
-    readonly node: Node$1 | Token$1;
+    readonly node: Node | Token;
 }
 interface ReportDescriptorLocOnly {
     /**
      * An override of the location of the report
      */
-    loc: Readonly<Position$1> | Readonly<SourceLocation$1>;
+    loc: Readonly<Position> | Readonly<SourceLocation>;
 }
 type ReportDescriptor<MessageIds extends string> = (ReportDescriptorLocOnly | ReportDescriptorNodeOptionalLoc) & ReportDescriptorWithSuggestion<MessageIds>;
 /**
@@ -6603,7 +4269,9 @@ interface RuleContext<MessageIds extends string, Options extends readonly unknow
     /**
      * The language options configured for this run
      */
-    languageOptions: FlatConfig.LanguageOptions;
+    languageOptions: FlatConfig.LanguageOptions & {
+        parserOptions: FlatConfig.ParserOptions;
+    };
     /**
      * An array of the configured options for this rule.
      * This array does not include the rule severity.
@@ -6611,10 +4279,12 @@ interface RuleContext<MessageIds extends string, Options extends readonly unknow
     options: Options;
     /**
      * The parser options configured for this run
+     * @deprecated This was deprecated in ESLint 9 and removed in ESLint 10.
      */
     parserOptions: Linter.ParserOptions;
     /**
      * The name of the parser from configuration, if in eslintrc (legacy) config.
+     * @deprecated This was deprecated in ESLint 9 and removed in ESLint 10.
      */
     parserPath: string | undefined;
     /**
@@ -6635,14 +4305,14 @@ interface RuleContext<MessageIds extends string, Options extends readonly unknow
      *
      * @deprecated in favor of `SourceCode#getAncestors`
      */
-    getAncestors(): Node$1[];
+    getAncestors(): Node[];
     /**
      * Returns a list of variables declared by the given node.
      * This information can be used to track references to variables.
      *
      * @deprecated in favor of `SourceCode#getDeclaredVariables`
      */
-    getDeclaredVariables(node: Node$1): readonly Scope.Variable[];
+    getDeclaredVariables(node: Node): readonly Scope.Variable[];
     /**
      * Returns the current working directory passed to Linter.
      * It is a path to a directory that should be considered as the current working directory.
@@ -6704,176 +4374,176 @@ interface RuleContext<MessageIds extends string, Options extends readonly unknow
      */
     report(descriptor: ReportDescriptor<MessageIds>): void;
 }
-type RuleFunction<T extends NodeOrTokenData$1 = never> = (node: T) => void;
+type RuleFunction<T extends NodeOrTokenData = never> = (node: T) => void;
 interface RuleListenerBaseSelectors {
-    AccessorProperty?: RuleFunction<AccessorProperty$1>;
-    ArrayExpression?: RuleFunction<ArrayExpression$1>;
-    ArrayPattern?: RuleFunction<ArrayPattern$1>;
-    ArrowFunctionExpression?: RuleFunction<ArrowFunctionExpression$1>;
-    AssignmentExpression?: RuleFunction<AssignmentExpression$1>;
-    AssignmentPattern?: RuleFunction<AssignmentPattern$1>;
-    AwaitExpression?: RuleFunction<AwaitExpression$1>;
-    BinaryExpression?: RuleFunction<BinaryExpression$1>;
-    BlockStatement?: RuleFunction<BlockStatement$1>;
-    BreakStatement?: RuleFunction<BreakStatement$1>;
-    CallExpression?: RuleFunction<CallExpression$1>;
-    CatchClause?: RuleFunction<CatchClause$1>;
-    ChainExpression?: RuleFunction<ChainExpression$1>;
-    ClassBody?: RuleFunction<ClassBody$1>;
-    ClassDeclaration?: RuleFunction<ClassDeclaration$1>;
-    ClassExpression?: RuleFunction<ClassExpression$1>;
-    ConditionalExpression?: RuleFunction<ConditionalExpression$1>;
-    ContinueStatement?: RuleFunction<ContinueStatement$1>;
-    DebuggerStatement?: RuleFunction<DebuggerStatement$1>;
-    Decorator?: RuleFunction<Decorator$1>;
-    DoWhileStatement?: RuleFunction<DoWhileStatement$1>;
-    EmptyStatement?: RuleFunction<EmptyStatement$1>;
-    ExportAllDeclaration?: RuleFunction<ExportAllDeclaration$1>;
-    ExportDefaultDeclaration?: RuleFunction<ExportDefaultDeclaration$1>;
-    ExportNamedDeclaration?: RuleFunction<ExportNamedDeclaration$1>;
-    ExportSpecifier?: RuleFunction<ExportSpecifier$1>;
-    ExpressionStatement?: RuleFunction<ExpressionStatement$1>;
-    ForInStatement?: RuleFunction<ForInStatement$1>;
-    ForOfStatement?: RuleFunction<ForOfStatement$1>;
-    ForStatement?: RuleFunction<ForStatement$1>;
-    FunctionDeclaration?: RuleFunction<FunctionDeclaration$1>;
-    FunctionExpression?: RuleFunction<FunctionExpression$1>;
-    Identifier?: RuleFunction<Identifier$1>;
-    IfStatement?: RuleFunction<IfStatement$1>;
-    ImportAttribute?: RuleFunction<ImportAttribute$1>;
-    ImportDeclaration?: RuleFunction<ImportDeclaration$1>;
-    ImportDefaultSpecifier?: RuleFunction<ImportDefaultSpecifier$1>;
-    ImportExpression?: RuleFunction<ImportExpression$1>;
-    ImportNamespaceSpecifier?: RuleFunction<ImportNamespaceSpecifier$1>;
-    ImportSpecifier?: RuleFunction<ImportSpecifier$1>;
-    JSXAttribute?: RuleFunction<JSXAttribute$1>;
-    JSXClosingElement?: RuleFunction<JSXClosingElement$1>;
-    JSXClosingFragment?: RuleFunction<JSXClosingFragment$1>;
-    JSXElement?: RuleFunction<JSXElement$1>;
-    JSXEmptyExpression?: RuleFunction<JSXEmptyExpression$1>;
-    JSXExpressionContainer?: RuleFunction<JSXExpressionContainer$1>;
-    JSXFragment?: RuleFunction<JSXFragment$1>;
-    JSXIdentifier?: RuleFunction<JSXIdentifier$1>;
-    JSXMemberExpression?: RuleFunction<JSXMemberExpression$1>;
-    JSXNamespacedName?: RuleFunction<JSXNamespacedName$1>;
-    JSXOpeningElement?: RuleFunction<JSXOpeningElement$1>;
-    JSXOpeningFragment?: RuleFunction<JSXOpeningFragment$1>;
-    JSXSpreadAttribute?: RuleFunction<JSXSpreadAttribute$1>;
-    JSXSpreadChild?: RuleFunction<JSXSpreadChild$1>;
-    JSXText?: RuleFunction<JSXText$1>;
-    LabeledStatement?: RuleFunction<LabeledStatement$1>;
-    Literal?: RuleFunction<Literal$1>;
-    LogicalExpression?: RuleFunction<LogicalExpression$1>;
-    MemberExpression?: RuleFunction<MemberExpression$1>;
-    MetaProperty?: RuleFunction<MetaProperty$1>;
-    MethodDefinition?: RuleFunction<MethodDefinition$1>;
-    NewExpression?: RuleFunction<NewExpression$1>;
-    ObjectExpression?: RuleFunction<ObjectExpression$1>;
-    ObjectPattern?: RuleFunction<ObjectPattern$1>;
-    PrivateIdentifier?: RuleFunction<PrivateIdentifier$1>;
-    Program?: RuleFunction<Program$1>;
-    Property?: RuleFunction<Property$1>;
-    PropertyDefinition?: RuleFunction<PropertyDefinition$1>;
-    RestElement?: RuleFunction<RestElement$1>;
-    ReturnStatement?: RuleFunction<ReturnStatement$1>;
-    SequenceExpression?: RuleFunction<SequenceExpression$1>;
-    SpreadElement?: RuleFunction<SpreadElement$1>;
-    StaticBlock?: RuleFunction<StaticBlock$1>;
-    Super?: RuleFunction<Super$1>;
-    SwitchCase?: RuleFunction<SwitchCase$1>;
-    SwitchStatement?: RuleFunction<SwitchStatement$1>;
-    TaggedTemplateExpression?: RuleFunction<TaggedTemplateExpression$1>;
-    TemplateElement?: RuleFunction<TemplateElement$1>;
-    TemplateLiteral?: RuleFunction<TemplateLiteral$1>;
-    ThisExpression?: RuleFunction<ThisExpression$1>;
-    ThrowStatement?: RuleFunction<ThrowStatement$1>;
-    TryStatement?: RuleFunction<TryStatement$1>;
-    TSAbstractAccessorProperty?: RuleFunction<TSAbstractAccessorProperty$1>;
-    TSAbstractKeyword?: RuleFunction<TSAbstractKeyword$1>;
-    TSAbstractMethodDefinition?: RuleFunction<TSAbstractMethodDefinition$1>;
-    TSAbstractPropertyDefinition?: RuleFunction<TSAbstractPropertyDefinition$1>;
-    TSAnyKeyword?: RuleFunction<TSAnyKeyword$1>;
-    TSArrayType?: RuleFunction<TSArrayType$1>;
-    TSAsExpression?: RuleFunction<TSAsExpression$1>;
-    TSAsyncKeyword?: RuleFunction<TSAsyncKeyword$1>;
-    TSBigIntKeyword?: RuleFunction<TSBigIntKeyword$1>;
-    TSBooleanKeyword?: RuleFunction<TSBooleanKeyword$1>;
-    TSCallSignatureDeclaration?: RuleFunction<TSCallSignatureDeclaration$1>;
-    TSClassImplements?: RuleFunction<TSClassImplements$1>;
-    TSConditionalType?: RuleFunction<TSConditionalType$1>;
-    TSConstructorType?: RuleFunction<TSConstructorType$1>;
-    TSConstructSignatureDeclaration?: RuleFunction<TSConstructSignatureDeclaration$1>;
-    TSDeclareFunction?: RuleFunction<TSDeclareFunction$1>;
-    TSDeclareKeyword?: RuleFunction<TSDeclareKeyword$1>;
-    TSEmptyBodyFunctionExpression?: RuleFunction<TSEmptyBodyFunctionExpression$1>;
-    TSEnumBody?: RuleFunction<TSEnumBody$1>;
-    TSEnumDeclaration?: RuleFunction<TSEnumDeclaration$1>;
-    TSEnumMember?: RuleFunction<TSEnumMember$1>;
-    TSExportAssignment?: RuleFunction<TSExportAssignment$1>;
-    TSExportKeyword?: RuleFunction<TSExportKeyword$1>;
-    TSExternalModuleReference?: RuleFunction<TSExternalModuleReference$1>;
-    TSFunctionType?: RuleFunction<TSFunctionType$1>;
-    TSImportEqualsDeclaration?: RuleFunction<TSImportEqualsDeclaration$1>;
-    TSImportType?: RuleFunction<TSImportType$1>;
-    TSIndexedAccessType?: RuleFunction<TSIndexedAccessType$1>;
-    TSIndexSignature?: RuleFunction<TSIndexSignature$1>;
-    TSInferType?: RuleFunction<TSInferType$1>;
-    TSInstantiationExpression?: RuleFunction<TSInstantiationExpression$1>;
-    TSInterfaceBody?: RuleFunction<TSInterfaceBody$1>;
-    TSInterfaceDeclaration?: RuleFunction<TSInterfaceDeclaration$1>;
-    TSInterfaceHeritage?: RuleFunction<TSInterfaceHeritage$1>;
-    TSIntersectionType?: RuleFunction<TSIntersectionType$1>;
-    TSIntrinsicKeyword?: RuleFunction<TSIntrinsicKeyword$1>;
-    TSLiteralType?: RuleFunction<TSLiteralType$1>;
-    TSMappedType?: RuleFunction<TSMappedType$1>;
-    TSMethodSignature?: RuleFunction<TSMethodSignature$1>;
-    TSModuleBlock?: RuleFunction<TSModuleBlock$1>;
-    TSModuleDeclaration?: RuleFunction<TSModuleDeclaration$1>;
-    TSNamedTupleMember?: RuleFunction<TSNamedTupleMember$1>;
-    TSNamespaceExportDeclaration?: RuleFunction<TSNamespaceExportDeclaration$1>;
-    TSNeverKeyword?: RuleFunction<TSNeverKeyword$1>;
-    TSNonNullExpression?: RuleFunction<TSNonNullExpression$1>;
-    TSNullKeyword?: RuleFunction<TSNullKeyword$1>;
-    TSNumberKeyword?: RuleFunction<TSNumberKeyword$1>;
-    TSObjectKeyword?: RuleFunction<TSObjectKeyword$1>;
-    TSOptionalType?: RuleFunction<TSOptionalType$1>;
-    TSParameterProperty?: RuleFunction<TSParameterProperty$1>;
-    TSPrivateKeyword?: RuleFunction<TSPrivateKeyword$1>;
-    TSPropertySignature?: RuleFunction<TSPropertySignature$1>;
-    TSProtectedKeyword?: RuleFunction<TSProtectedKeyword$1>;
-    TSPublicKeyword?: RuleFunction<TSPublicKeyword$1>;
-    TSQualifiedName?: RuleFunction<TSQualifiedName$1>;
-    TSReadonlyKeyword?: RuleFunction<TSReadonlyKeyword$1>;
-    TSRestType?: RuleFunction<TSRestType$1>;
-    TSSatisfiesExpression?: RuleFunction<TSSatisfiesExpression$1>;
-    TSStaticKeyword?: RuleFunction<TSStaticKeyword$1>;
-    TSStringKeyword?: RuleFunction<TSStringKeyword$1>;
-    TSSymbolKeyword?: RuleFunction<TSSymbolKeyword$1>;
-    TSTemplateLiteralType?: RuleFunction<TSTemplateLiteralType$1>;
-    TSThisType?: RuleFunction<TSThisType$1>;
-    TSTupleType?: RuleFunction<TSTupleType$1>;
-    TSTypeAliasDeclaration?: RuleFunction<TSTypeAliasDeclaration$1>;
-    TSTypeAnnotation?: RuleFunction<TSTypeAnnotation$1>;
-    TSTypeAssertion?: RuleFunction<TSTypeAssertion$1>;
-    TSTypeLiteral?: RuleFunction<TSTypeLiteral$1>;
-    TSTypeOperator?: RuleFunction<TSTypeOperator$1>;
-    TSTypeParameter?: RuleFunction<TSTypeParameter$1>;
-    TSTypeParameterDeclaration?: RuleFunction<TSTypeParameterDeclaration$1>;
-    TSTypeParameterInstantiation?: RuleFunction<TSTypeParameterInstantiation$1>;
-    TSTypePredicate?: RuleFunction<TSTypePredicate$1>;
-    TSTypeQuery?: RuleFunction<TSTypeQuery$1>;
-    TSTypeReference?: RuleFunction<TSTypeReference$1>;
-    TSUndefinedKeyword?: RuleFunction<TSUndefinedKeyword$1>;
-    TSUnionType?: RuleFunction<TSUnionType$1>;
-    TSUnknownKeyword?: RuleFunction<TSUnknownKeyword$1>;
-    TSVoidKeyword?: RuleFunction<TSVoidKeyword$1>;
-    UnaryExpression?: RuleFunction<UnaryExpression$1>;
-    UpdateExpression?: RuleFunction<UpdateExpression$1>;
-    VariableDeclaration?: RuleFunction<VariableDeclaration$1>;
-    VariableDeclarator?: RuleFunction<VariableDeclarator$1>;
-    WhileStatement?: RuleFunction<WhileStatement$1>;
-    WithStatement?: RuleFunction<WithStatement$1>;
-    YieldExpression?: RuleFunction<YieldExpression$1>;
+    AccessorProperty?: RuleFunction<AccessorProperty>;
+    ArrayExpression?: RuleFunction<ArrayExpression>;
+    ArrayPattern?: RuleFunction<ArrayPattern>;
+    ArrowFunctionExpression?: RuleFunction<ArrowFunctionExpression>;
+    AssignmentExpression?: RuleFunction<AssignmentExpression>;
+    AssignmentPattern?: RuleFunction<AssignmentPattern>;
+    AwaitExpression?: RuleFunction<AwaitExpression>;
+    BinaryExpression?: RuleFunction<BinaryExpression>;
+    BlockStatement?: RuleFunction<BlockStatement>;
+    BreakStatement?: RuleFunction<BreakStatement>;
+    CallExpression?: RuleFunction<CallExpression>;
+    CatchClause?: RuleFunction<CatchClause>;
+    ChainExpression?: RuleFunction<ChainExpression>;
+    ClassBody?: RuleFunction<ClassBody>;
+    ClassDeclaration?: RuleFunction<ClassDeclaration>;
+    ClassExpression?: RuleFunction<ClassExpression>;
+    ConditionalExpression?: RuleFunction<ConditionalExpression>;
+    ContinueStatement?: RuleFunction<ContinueStatement>;
+    DebuggerStatement?: RuleFunction<DebuggerStatement>;
+    Decorator?: RuleFunction<Decorator>;
+    DoWhileStatement?: RuleFunction<DoWhileStatement>;
+    EmptyStatement?: RuleFunction<EmptyStatement>;
+    ExportAllDeclaration?: RuleFunction<ExportAllDeclaration>;
+    ExportDefaultDeclaration?: RuleFunction<ExportDefaultDeclaration>;
+    ExportNamedDeclaration?: RuleFunction<ExportNamedDeclaration>;
+    ExportSpecifier?: RuleFunction<ExportSpecifier>;
+    ExpressionStatement?: RuleFunction<ExpressionStatement>;
+    ForInStatement?: RuleFunction<ForInStatement>;
+    ForOfStatement?: RuleFunction<ForOfStatement>;
+    ForStatement?: RuleFunction<ForStatement>;
+    FunctionDeclaration?: RuleFunction<FunctionDeclaration>;
+    FunctionExpression?: RuleFunction<FunctionExpression>;
+    Identifier?: RuleFunction<Identifier>;
+    IfStatement?: RuleFunction<IfStatement>;
+    ImportAttribute?: RuleFunction<ImportAttribute>;
+    ImportDeclaration?: RuleFunction<ImportDeclaration>;
+    ImportDefaultSpecifier?: RuleFunction<ImportDefaultSpecifier>;
+    ImportExpression?: RuleFunction<ImportExpression>;
+    ImportNamespaceSpecifier?: RuleFunction<ImportNamespaceSpecifier>;
+    ImportSpecifier?: RuleFunction<ImportSpecifier>;
+    JSXAttribute?: RuleFunction<JSXAttribute>;
+    JSXClosingElement?: RuleFunction<JSXClosingElement>;
+    JSXClosingFragment?: RuleFunction<JSXClosingFragment>;
+    JSXElement?: RuleFunction<JSXElement>;
+    JSXEmptyExpression?: RuleFunction<JSXEmptyExpression>;
+    JSXExpressionContainer?: RuleFunction<JSXExpressionContainer>;
+    JSXFragment?: RuleFunction<JSXFragment>;
+    JSXIdentifier?: RuleFunction<JSXIdentifier>;
+    JSXMemberExpression?: RuleFunction<JSXMemberExpression>;
+    JSXNamespacedName?: RuleFunction<JSXNamespacedName>;
+    JSXOpeningElement?: RuleFunction<JSXOpeningElement>;
+    JSXOpeningFragment?: RuleFunction<JSXOpeningFragment>;
+    JSXSpreadAttribute?: RuleFunction<JSXSpreadAttribute>;
+    JSXSpreadChild?: RuleFunction<JSXSpreadChild>;
+    JSXText?: RuleFunction<JSXText>;
+    LabeledStatement?: RuleFunction<LabeledStatement>;
+    Literal?: RuleFunction<Literal>;
+    LogicalExpression?: RuleFunction<LogicalExpression>;
+    MemberExpression?: RuleFunction<MemberExpression>;
+    MetaProperty?: RuleFunction<MetaProperty>;
+    MethodDefinition?: RuleFunction<MethodDefinition>;
+    NewExpression?: RuleFunction<NewExpression>;
+    ObjectExpression?: RuleFunction<ObjectExpression>;
+    ObjectPattern?: RuleFunction<ObjectPattern>;
+    PrivateIdentifier?: RuleFunction<PrivateIdentifier>;
+    Program?: RuleFunction<Program>;
+    Property?: RuleFunction<Property>;
+    PropertyDefinition?: RuleFunction<PropertyDefinition>;
+    RestElement?: RuleFunction<RestElement>;
+    ReturnStatement?: RuleFunction<ReturnStatement>;
+    SequenceExpression?: RuleFunction<SequenceExpression>;
+    SpreadElement?: RuleFunction<SpreadElement>;
+    StaticBlock?: RuleFunction<StaticBlock>;
+    Super?: RuleFunction<Super>;
+    SwitchCase?: RuleFunction<SwitchCase>;
+    SwitchStatement?: RuleFunction<SwitchStatement>;
+    TaggedTemplateExpression?: RuleFunction<TaggedTemplateExpression>;
+    TemplateElement?: RuleFunction<TemplateElement>;
+    TemplateLiteral?: RuleFunction<TemplateLiteral>;
+    ThisExpression?: RuleFunction<ThisExpression>;
+    ThrowStatement?: RuleFunction<ThrowStatement>;
+    TryStatement?: RuleFunction<TryStatement>;
+    TSAbstractAccessorProperty?: RuleFunction<TSAbstractAccessorProperty>;
+    TSAbstractKeyword?: RuleFunction<TSAbstractKeyword>;
+    TSAbstractMethodDefinition?: RuleFunction<TSAbstractMethodDefinition>;
+    TSAbstractPropertyDefinition?: RuleFunction<TSAbstractPropertyDefinition>;
+    TSAnyKeyword?: RuleFunction<TSAnyKeyword>;
+    TSArrayType?: RuleFunction<TSArrayType>;
+    TSAsExpression?: RuleFunction<TSAsExpression>;
+    TSAsyncKeyword?: RuleFunction<TSAsyncKeyword>;
+    TSBigIntKeyword?: RuleFunction<TSBigIntKeyword>;
+    TSBooleanKeyword?: RuleFunction<TSBooleanKeyword>;
+    TSCallSignatureDeclaration?: RuleFunction<TSCallSignatureDeclaration>;
+    TSClassImplements?: RuleFunction<TSClassImplements>;
+    TSConditionalType?: RuleFunction<TSConditionalType>;
+    TSConstructorType?: RuleFunction<TSConstructorType>;
+    TSConstructSignatureDeclaration?: RuleFunction<TSConstructSignatureDeclaration>;
+    TSDeclareFunction?: RuleFunction<TSDeclareFunction>;
+    TSDeclareKeyword?: RuleFunction<TSDeclareKeyword>;
+    TSEmptyBodyFunctionExpression?: RuleFunction<TSEmptyBodyFunctionExpression>;
+    TSEnumBody?: RuleFunction<TSEnumBody>;
+    TSEnumDeclaration?: RuleFunction<TSEnumDeclaration>;
+    TSEnumMember?: RuleFunction<TSEnumMember>;
+    TSExportAssignment?: RuleFunction<TSExportAssignment>;
+    TSExportKeyword?: RuleFunction<TSExportKeyword>;
+    TSExternalModuleReference?: RuleFunction<TSExternalModuleReference>;
+    TSFunctionType?: RuleFunction<TSFunctionType>;
+    TSImportEqualsDeclaration?: RuleFunction<TSImportEqualsDeclaration>;
+    TSImportType?: RuleFunction<TSImportType>;
+    TSIndexedAccessType?: RuleFunction<TSIndexedAccessType>;
+    TSIndexSignature?: RuleFunction<TSIndexSignature>;
+    TSInferType?: RuleFunction<TSInferType>;
+    TSInstantiationExpression?: RuleFunction<TSInstantiationExpression>;
+    TSInterfaceBody?: RuleFunction<TSInterfaceBody>;
+    TSInterfaceDeclaration?: RuleFunction<TSInterfaceDeclaration>;
+    TSInterfaceHeritage?: RuleFunction<TSInterfaceHeritage>;
+    TSIntersectionType?: RuleFunction<TSIntersectionType>;
+    TSIntrinsicKeyword?: RuleFunction<TSIntrinsicKeyword>;
+    TSLiteralType?: RuleFunction<TSLiteralType>;
+    TSMappedType?: RuleFunction<TSMappedType>;
+    TSMethodSignature?: RuleFunction<TSMethodSignature>;
+    TSModuleBlock?: RuleFunction<TSModuleBlock>;
+    TSModuleDeclaration?: RuleFunction<TSModuleDeclaration>;
+    TSNamedTupleMember?: RuleFunction<TSNamedTupleMember>;
+    TSNamespaceExportDeclaration?: RuleFunction<TSNamespaceExportDeclaration>;
+    TSNeverKeyword?: RuleFunction<TSNeverKeyword>;
+    TSNonNullExpression?: RuleFunction<TSNonNullExpression>;
+    TSNullKeyword?: RuleFunction<TSNullKeyword>;
+    TSNumberKeyword?: RuleFunction<TSNumberKeyword>;
+    TSObjectKeyword?: RuleFunction<TSObjectKeyword>;
+    TSOptionalType?: RuleFunction<TSOptionalType>;
+    TSParameterProperty?: RuleFunction<TSParameterProperty>;
+    TSPrivateKeyword?: RuleFunction<TSPrivateKeyword>;
+    TSPropertySignature?: RuleFunction<TSPropertySignature>;
+    TSProtectedKeyword?: RuleFunction<TSProtectedKeyword>;
+    TSPublicKeyword?: RuleFunction<TSPublicKeyword>;
+    TSQualifiedName?: RuleFunction<TSQualifiedName>;
+    TSReadonlyKeyword?: RuleFunction<TSReadonlyKeyword>;
+    TSRestType?: RuleFunction<TSRestType>;
+    TSSatisfiesExpression?: RuleFunction<TSSatisfiesExpression>;
+    TSStaticKeyword?: RuleFunction<TSStaticKeyword>;
+    TSStringKeyword?: RuleFunction<TSStringKeyword>;
+    TSSymbolKeyword?: RuleFunction<TSSymbolKeyword>;
+    TSTemplateLiteralType?: RuleFunction<TSTemplateLiteralType>;
+    TSThisType?: RuleFunction<TSThisType>;
+    TSTupleType?: RuleFunction<TSTupleType>;
+    TSTypeAliasDeclaration?: RuleFunction<TSTypeAliasDeclaration>;
+    TSTypeAnnotation?: RuleFunction<TSTypeAnnotation>;
+    TSTypeAssertion?: RuleFunction<TSTypeAssertion>;
+    TSTypeLiteral?: RuleFunction<TSTypeLiteral>;
+    TSTypeOperator?: RuleFunction<TSTypeOperator>;
+    TSTypeParameter?: RuleFunction<TSTypeParameter>;
+    TSTypeParameterDeclaration?: RuleFunction<TSTypeParameterDeclaration>;
+    TSTypeParameterInstantiation?: RuleFunction<TSTypeParameterInstantiation>;
+    TSTypePredicate?: RuleFunction<TSTypePredicate>;
+    TSTypeQuery?: RuleFunction<TSTypeQuery>;
+    TSTypeReference?: RuleFunction<TSTypeReference>;
+    TSUndefinedKeyword?: RuleFunction<TSUndefinedKeyword>;
+    TSUnionType?: RuleFunction<TSUnionType>;
+    TSUnknownKeyword?: RuleFunction<TSUnknownKeyword>;
+    TSVoidKeyword?: RuleFunction<TSVoidKeyword>;
+    UnaryExpression?: RuleFunction<UnaryExpression>;
+    UpdateExpression?: RuleFunction<UpdateExpression>;
+    VariableDeclaration?: RuleFunction<VariableDeclaration>;
+    VariableDeclarator?: RuleFunction<VariableDeclarator>;
+    WhileStatement?: RuleFunction<WhileStatement>;
+    WithStatement?: RuleFunction<WithStatement>;
+    YieldExpression?: RuleFunction<YieldExpression>;
 }
 type RuleListenerExitSelectors = {
     [K in keyof RuleListenerBaseSelectors as `${K}:exit`]: RuleListenerBaseSelectors[K];
@@ -7527,7 +5197,7 @@ declare const _default: {
         'ts-multiline-ternary': eslint.Rule.RuleModule;
         'ts-multiline-union': eslint.Rule.RuleModule;
         'ts-padding-statements': RuleModule<"expectedBlankLine" | "expectedBlankLineBeforeComment" | "unexpectedBlankLine", [], unknown, RuleListener>;
-        'ts-sort-tests': eslint.Rule.RuleModule;
+        'ts-sort-tests': RuleModule<"sortError", [], unknown, RuleListener>;
         'vue-i18n-consistent-locales': eslint.Rule.RuleModule;
         'vue-i18n-consistent-t': eslint.Rule.RuleModule;
         'vue-i18n-sort-keys': eslint.Rule.RuleModule;