@eslint-react/ast 1.15.0 → 1.15.1-beta.10

package/dist/index.d.mts

@@ -130,7 +130,7 @@ declare function getClassIdentifier(node: TSESTreeClass): O.Option<TSESTree$1.Id
  * same AST nodes with some exceptions to better fit our use case.
  */
 
-declare function getFunctionIdentifier(node: TSESTreeFunction): O.Option<TSESTree$1.Identifier>;
+declare function getFunctionIdentifier(node: TSESTree$1.Expression | TSESTreeFunction): O.Option<TSESTree$1.Identifier>;
 
 declare function getIdentifiersFromBinaryExpression(side: TSESTree$1.BinaryExpression | TSESTree$1.BinaryExpression["left"] | TSESTree$1.BinaryExpression["right"]): TSESTree$1.Identifier[];
 
@@ -155,20 +155,21 @@ declare interface AccessorPropertyNonComputedName extends PropertyDefinitionNonC
     type: AST_NODE_TYPES.AccessorProperty;
 }
 declare interface ArrayExpression extends BaseNode {
+    type: AST_NODE_TYPES.ArrayExpression;
     /**
      * an element will be `null` in the case of a sparse array: `[1, ,3]`
      */
     elements: (Expression | SpreadElement | null)[];
-    type: AST_NODE_TYPES.ArrayExpression;
 }
 declare interface ArrayPattern extends BaseNode {
+    type: AST_NODE_TYPES.ArrayPattern;
     decorators: Decorator[];
     elements: (DestructuringPattern | null)[];
     optional: boolean;
-    type: AST_NODE_TYPES.ArrayPattern;
     typeAnnotation: TSTypeAnnotation | undefined;
 }
 declare interface ArrowFunctionExpression extends BaseNode {
+    type: AST_NODE_TYPES.ArrowFunctionExpression;
     async: boolean;
     body: BlockStatement | Expression;
     expression: boolean;
@@ -176,14 +177,13 @@ declare interface ArrowFunctionExpression extends BaseNode {
     id: null;
     params: Parameter[];
     returnType: TSTypeAnnotation | undefined;
-    type: AST_NODE_TYPES.ArrowFunctionExpression;
     typeParameters: TSTypeParameterDeclaration | undefined;
 }
 declare interface AssignmentExpression extends BaseNode {
+    type: AST_NODE_TYPES.AssignmentExpression;
     left: Expression;
     operator: ValueOf<AssignmentOperatorToText>;
     right: Expression;
-    type: AST_NODE_TYPES.AssignmentExpression;
 }
 declare interface AssignmentOperatorToText {
     [SyntaxKind.AmpersandAmpersandEqualsToken]: '&&=';
@@ -204,11 +204,11 @@ declare interface AssignmentOperatorToText {
     [SyntaxKind.SlashEqualsToken]: '/=';
 }
 declare interface AssignmentPattern extends BaseNode {
+    type: AST_NODE_TYPES.AssignmentPattern;
     decorators: Decorator[];
     left: BindingName;
     optional: boolean;
     right: Expression;
-    type: AST_NODE_TYPES.AssignmentPattern;
     typeAnnotation: TSTypeAnnotation | undefined;
 }
 declare enum AST_NODE_TYPES {
@@ -397,8 +397,8 @@ declare enum AST_TOKEN_TYPES {
     Line = "Line"
 }
 declare interface AwaitExpression extends BaseNode {
-    argument: Expression;
     type: AST_NODE_TYPES.AwaitExpression;
+    argument: Expression;
 }
 declare interface BaseNode extends NodeOrTokenData {
     type: AST_NODE_TYPES;
@@ -412,10 +412,10 @@ declare interface BigIntLiteral extends LiteralBase {
     value: bigint | null;
 }
 declare interface BinaryExpression extends BaseNode {
+    type: AST_NODE_TYPES.BinaryExpression;
     left: Expression | PrivateIdentifier;
     operator: ValueOf<BinaryOperatorToText>;
     right: Expression;
-    type: AST_NODE_TYPES.BinaryExpression;
 }
 declare interface BinaryOperatorToText {
     [SyntaxKind.AmpersandAmpersandToken]: '&&';
@@ -449,8 +449,8 @@ declare interface BlockComment extends BaseToken {
     type: AST_TOKEN_TYPES.Block;
 }
 declare interface BlockStatement extends BaseNode {
-    body: Statement[];
     type: AST_NODE_TYPES.BlockStatement;
+    body: Statement[];
 }
 declare interface BooleanLiteral extends LiteralBase {
     raw: 'false' | 'true';
@@ -460,26 +460,26 @@ declare interface BooleanToken extends BaseToken {
     type: AST_TOKEN_TYPES.Boolean;
 }
 declare interface BreakStatement extends BaseNode {
-    label: Identifier | null;
     type: AST_NODE_TYPES.BreakStatement;
+    label: Identifier | null;
 }
 declare interface CallExpression extends BaseNode {
+    type: AST_NODE_TYPES.CallExpression;
     arguments: CallExpressionArgument[];
     callee: Expression;
     optional: boolean;
-    type: AST_NODE_TYPES.CallExpression;
     typeArguments: TSTypeParameterInstantiation | undefined;
 }
 declare type CallExpressionArgument = Expression | SpreadElement;
 declare interface CatchClause extends BaseNode {
+    type: AST_NODE_TYPES.CatchClause;
     body: BlockStatement;
     param: BindingName | null;
-    type: AST_NODE_TYPES.CatchClause;
 }
 declare type ChainElement = CallExpression | MemberExpression | TSNonNullExpression;
 declare interface ChainExpression extends BaseNode {
-    expression: ChainElement;
     type: AST_NODE_TYPES.ChainExpression;
+    expression: ChainElement;
 }
 declare interface ClassBase extends BaseNode {
     /**
@@ -536,8 +536,8 @@ declare interface ClassBase extends BaseNode {
     typeParameters: TSTypeParameterDeclaration | undefined;
 }
 declare interface ClassBody extends BaseNode {
-    body: ClassElement[];
     type: AST_NODE_TYPES.ClassBody;
+    body: ClassElement[];
 }
 declare type ClassDeclaration = ClassDeclarationWithName | ClassDeclarationWithOptionalName;
 declare interface ClassDeclarationBase extends ClassBase {
@@ -563,9 +563,9 @@ declare interface ClassDeclarationWithOptionalName extends ClassDeclarationBase
 }
 declare type ClassElement = AccessorProperty | MethodDefinition | PropertyDefinition | StaticBlock | TSAbstractAccessorProperty | TSAbstractMethodDefinition | TSAbstractPropertyDefinition | TSIndexSignature;
 declare interface ClassExpression extends ClassBase {
+    type: AST_NODE_TYPES.ClassExpression;
     abstract: false;
     declare: false;
-    type: AST_NODE_TYPES.ClassExpression;
 }
 declare interface ClassMethodDefinitionNonComputedNameBase extends MethodDefinitionBase {
     computed: false;
@@ -578,10 +578,10 @@ declare interface ClassPropertyDefinitionNonComputedNameBase extends PropertyDef
 declare type ClassPropertyNameNonComputed = PrivateIdentifier | PropertyNameNonComputed;
 declare type Comment = BlockComment | LineComment;
 declare interface ConditionalExpression extends BaseNode {
+    type: AST_NODE_TYPES.ConditionalExpression;
     alternate: Expression;
     consequent: Expression;
     test: Expression;
-    type: AST_NODE_TYPES.ConditionalExpression;
 }
 declare interface ConstDeclaration extends LetOrConstOrVarDeclarationBase {
     /**
@@ -596,28 +596,29 @@ declare interface ConstDeclaration extends LetOrConstOrVarDeclarationBase {
     kind: 'const';
 }
 declare interface ContinueStatement extends BaseNode {
-    label: Identifier | null;
     type: AST_NODE_TYPES.ContinueStatement;
+    label: Identifier | null;
 }
 declare interface DebuggerStatement extends BaseNode {
     type: AST_NODE_TYPES.DebuggerStatement;
 }
 declare interface Decorator extends BaseNode {
-    expression: LeftHandSideExpression;
     type: AST_NODE_TYPES.Decorator;
+    expression: LeftHandSideExpression;
 }
 declare type DefaultExportDeclarations = ClassDeclarationWithOptionalName | Expression | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration;
 declare type DestructuringPattern = ArrayPattern | AssignmentPattern | Identifier | MemberExpression | ObjectPattern | RestElement;
 declare interface DoWhileStatement extends BaseNode {
+    type: AST_NODE_TYPES.DoWhileStatement;
     body: Statement;
     test: Expression;
-    type: AST_NODE_TYPES.DoWhileStatement;
 }
 declare interface EmptyStatement extends BaseNode {
     type: AST_NODE_TYPES.EmptyStatement;
 }
 declare type EntityName = Identifier | ThisExpression | TSQualifiedName;
 declare interface ExportAllDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.ExportAllDeclaration;
     /**
      * The assertions declared for the export.
      * @example
@@ -647,10 +648,10 @@ declare interface ExportAllDeclaration extends BaseNode {
      * The source module being exported from.
      */
     source: StringLiteral;
-    type: AST_NODE_TYPES.ExportAllDeclaration;
 }
 declare type ExportAndImportKind = 'type' | 'value';
 declare interface ExportDefaultDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.ExportDefaultDeclaration;
     /**
      * The declaration being exported.
      */
@@ -659,11 +660,11 @@ declare interface ExportDefaultDeclaration extends BaseNode {
      * The kind of the export. Always `value` for default exports.
      */
     exportKind: 'value';
-    type: AST_NODE_TYPES.ExportDefaultDeclaration;
 }
 declare type ExportKind = ExportAndImportKind;
 declare type ExportNamedDeclaration = ExportNamedDeclarationWithoutSourceWithMultiple | ExportNamedDeclarationWithoutSourceWithSingle | ExportNamedDeclarationWithSource;
 declare interface ExportNamedDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.ExportNamedDeclaration;
     /**
      * The assertions declared for the export.
      * @example
@@ -709,7 +710,6 @@ declare interface ExportNamedDeclarationBase extends BaseNode {
      * This will be an empty array if `declaration` is not `null`
      */
     specifiers: ExportSpecifier[];
-    type: AST_NODE_TYPES.ExportNamedDeclaration;
 }
 /**
  * Exporting names from the current module.
@@ -730,6 +730,7 @@ declare interface ExportNamedDeclarationWithoutSourceWithMultiple extends Export
     attributes: ImportAttribute[];
     declaration: null;
     source: null;
+    specifiers: ExportSpecifierWithIdentifierLocal[];
 }
 /**
  * Exporting a single named declaration.
@@ -752,7 +753,7 @@ declare interface ExportNamedDeclarationWithoutSourceWithSingle extends ExportNa
     /**
      * This will always be an empty array.
      */
-    specifiers: ExportSpecifier[];
+    specifiers: ExportSpecifierWithIdentifierLocal[];
 }
 /**
  * Export names from another module.
@@ -764,38 +765,45 @@ declare interface ExportNamedDeclarationWithSource extends ExportNamedDeclaratio
     declaration: null;
     source: StringLiteral;
 }
-declare interface ExportSpecifier extends BaseNode {
-    exported: Identifier;
+declare type ExportSpecifier = ExportSpecifierWithIdentifierLocal | ExportSpecifierWithStringOrLiteralLocal;
+declare interface ExportSpecifierBase extends BaseNode {
+    type: AST_NODE_TYPES.ExportSpecifier;
+    exported: Identifier | StringLiteral;
     exportKind: ExportKind;
+    local: Identifier | StringLiteral;
+}
+declare interface ExportSpecifierWithIdentifierLocal extends ExportSpecifierBase {
     local: Identifier;
-    type: AST_NODE_TYPES.ExportSpecifier;
+}
+declare interface ExportSpecifierWithStringOrLiteralLocal extends ExportSpecifierBase {
+    local: Identifier | StringLiteral;
 }
 declare type Expression = ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AwaitExpression | BinaryExpression | CallExpression | ChainExpression | ClassExpression | ConditionalExpression | FunctionExpression | Identifier | ImportExpression | JSXElement | JSXFragment | LiteralExpression | LogicalExpression | MemberExpression | MetaProperty | NewExpression | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | TemplateLiteral | ThisExpression | TSAsExpression | TSInstantiationExpression | TSNonNullExpression | TSSatisfiesExpression | TSTypeAssertion | UnaryExpression | UpdateExpression | YieldExpression;
 declare interface ExpressionStatement extends BaseNode {
+    type: AST_NODE_TYPES.ExpressionStatement;
     directive: string | undefined;
     expression: Expression;
-    type: AST_NODE_TYPES.ExpressionStatement;
 }
 declare type ForInitialiser = Expression | LetOrConstOrVarDeclaration;
 declare interface ForInStatement extends BaseNode {
+    type: AST_NODE_TYPES.ForInStatement;
     body: Statement;
     left: ForInitialiser;
     right: Expression;
-    type: AST_NODE_TYPES.ForInStatement;
 }
 declare type ForOfInitialiser = Expression | LetOrConstOrVarDeclaration | UsingInForOfDeclaration;
 declare interface ForOfStatement extends BaseNode {
+    type: AST_NODE_TYPES.ForOfStatement;
     await: boolean;
     body: Statement;
     left: ForOfInitialiser;
     right: Expression;
-    type: AST_NODE_TYPES.ForOfStatement;
 }
 declare interface ForStatement extends BaseNode {
+    type: AST_NODE_TYPES.ForStatement;
     body: Statement;
     init: Expression | ForInitialiser | null;
     test: Expression | null;
-    type: AST_NODE_TYPES.ForStatement;
     update: Expression | null;
 }
 declare interface FunctionBase extends BaseNode {
@@ -863,10 +871,10 @@ declare interface FunctionBase extends BaseNode {
 }
 declare type FunctionDeclaration = FunctionDeclarationWithName | FunctionDeclarationWithOptionalName;
 declare interface FunctionDeclarationBase extends FunctionBase {
+    type: AST_NODE_TYPES.FunctionDeclaration;
     body: BlockStatement;
     declare: false;
     expression: false;
-    type: AST_NODE_TYPES.FunctionDeclaration;
 }
 /**
  * A normal function declaration:
@@ -887,33 +895,34 @@ declare interface FunctionDeclarationWithOptionalName extends FunctionDeclaratio
     id: Identifier | null;
 }
 declare interface FunctionExpression extends FunctionBase {
+    type: AST_NODE_TYPES.FunctionExpression;
     body: BlockStatement;
     expression: false;
-    type: AST_NODE_TYPES.FunctionExpression;
 }
 declare interface Identifier extends BaseNode {
+    type: AST_NODE_TYPES.Identifier;
     decorators: Decorator[];
     name: string;
     optional: boolean;
-    type: AST_NODE_TYPES.Identifier;
     typeAnnotation: TSTypeAnnotation | undefined;
 }
 declare interface IdentifierToken extends BaseToken {
     type: AST_TOKEN_TYPES.Identifier;
 }
 declare interface IfStatement extends BaseNode {
+    type: AST_NODE_TYPES.IfStatement;
     alternate: Statement | null;
     consequent: Statement;
     test: Expression;
-    type: AST_NODE_TYPES.IfStatement;
 }
 declare interface ImportAttribute extends BaseNode {
-    key: Identifier | Literal;
     type: AST_NODE_TYPES.ImportAttribute;
+    key: Identifier | Literal;
     value: Literal;
 }
 declare type ImportClause = ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier;
 declare interface ImportDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.ImportDeclaration;
     /**
      * The assertions declared for the export.
      * @example
@@ -951,100 +960,99 @@ declare interface ImportDeclaration extends BaseNode {
      * ```
      */
     specifiers: ImportClause[];
-    type: AST_NODE_TYPES.ImportDeclaration;
 }
 declare interface ImportDefaultSpecifier extends BaseNode {
-    local: Identifier;
     type: AST_NODE_TYPES.ImportDefaultSpecifier;
+    local: Identifier;
 }
 declare interface ImportExpression extends BaseNode {
+    type: AST_NODE_TYPES.ImportExpression;
     attributes: Expression | null;
     source: Expression;
-    type: AST_NODE_TYPES.ImportExpression;
 }
 declare type ImportKind = ExportAndImportKind;
 declare interface ImportNamespaceSpecifier extends BaseNode {
-    local: Identifier;
     type: AST_NODE_TYPES.ImportNamespaceSpecifier;
+    local: Identifier;
 }
 declare interface ImportSpecifier extends BaseNode {
-    imported: Identifier;
+    type: AST_NODE_TYPES.ImportSpecifier;
+    imported: Identifier | StringLiteral;
     importKind: ImportKind;
     local: Identifier;
-    type: AST_NODE_TYPES.ImportSpecifier;
 }
 declare interface JSXAttribute extends BaseNode {
-    name: JSXIdentifier | JSXNamespacedName;
     type: AST_NODE_TYPES.JSXAttribute;
+    name: JSXIdentifier | JSXNamespacedName;
     value: JSXElement | JSXExpression | Literal | null;
 }
 declare type JSXChild = JSXElement | JSXExpression | JSXFragment | JSXText;
 declare interface JSXClosingElement extends BaseNode {
-    name: JSXTagNameExpression;
     type: AST_NODE_TYPES.JSXClosingElement;
+    name: JSXTagNameExpression;
 }
 declare interface JSXClosingFragment extends BaseNode {
     type: AST_NODE_TYPES.JSXClosingFragment;
 }
 declare interface JSXElement extends BaseNode {
+    type: AST_NODE_TYPES.JSXElement;
     children: JSXChild[];
     closingElement: JSXClosingElement | null;
     openingElement: JSXOpeningElement;
-    type: AST_NODE_TYPES.JSXElement;
 }
 declare interface JSXEmptyExpression extends BaseNode {
     type: AST_NODE_TYPES.JSXEmptyExpression;
 }
 declare type JSXExpression = JSXExpressionContainer | JSXSpreadChild;
 declare interface JSXExpressionContainer extends BaseNode {
-    expression: Expression | JSXEmptyExpression;
     type: AST_NODE_TYPES.JSXExpressionContainer;
+    expression: Expression | JSXEmptyExpression;
 }
 declare interface JSXFragment extends BaseNode {
+    type: AST_NODE_TYPES.JSXFragment;
     children: JSXChild[];
     closingFragment: JSXClosingFragment;
     openingFragment: JSXOpeningFragment;
-    type: AST_NODE_TYPES.JSXFragment;
 }
 declare interface JSXIdentifier extends BaseNode {
-    name: string;
     type: AST_NODE_TYPES.JSXIdentifier;
+    name: string;
 }
 declare interface JSXIdentifierToken extends BaseToken {
     type: AST_TOKEN_TYPES.JSXIdentifier;
 }
 declare interface JSXMemberExpression extends BaseNode {
+    type: AST_NODE_TYPES.JSXMemberExpression;
     object: JSXTagNameExpression;
     property: JSXIdentifier;
-    type: AST_NODE_TYPES.JSXMemberExpression;
 }
 declare interface JSXNamespacedName extends BaseNode {
+    type: AST_NODE_TYPES.JSXNamespacedName;
     name: JSXIdentifier;
     namespace: JSXIdentifier;
-    type: AST_NODE_TYPES.JSXNamespacedName;
 }
 declare interface JSXOpeningElement extends BaseNode {
+    type: AST_NODE_TYPES.JSXOpeningElement;
     attributes: (JSXAttribute | JSXSpreadAttribute)[];
     name: JSXTagNameExpression;
     selfClosing: boolean;
-    type: AST_NODE_TYPES.JSXOpeningElement;
     typeArguments: TSTypeParameterInstantiation | undefined;
 }
 declare interface JSXOpeningFragment extends BaseNode {
     type: AST_NODE_TYPES.JSXOpeningFragment;
 }
 declare interface JSXSpreadAttribute extends BaseNode {
-    argument: Expression;
     type: AST_NODE_TYPES.JSXSpreadAttribute;
+    argument: Expression;
 }
 declare interface JSXSpreadChild extends BaseNode {
-    expression: Expression | JSXEmptyExpression;
     type: AST_NODE_TYPES.JSXSpreadChild;
+    expression: Expression | JSXEmptyExpression;
 }
 declare type JSXTagNameExpression = JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
 declare interface JSXText extends BaseNode {
-    raw: string;
     type: AST_NODE_TYPES.JSXText;
+    raw: string;
     value: string;
 }
 declare interface JSXTextToken extends BaseToken {
@@ -1054,13 +1062,14 @@ declare interface KeywordToken extends BaseToken {
     type: AST_TOKEN_TYPES.Keyword;
 }
 declare interface LabeledStatement extends BaseNode {
+    type: AST_NODE_TYPES.LabeledStatement;
     body: Statement;
     label: Identifier;
-    type: AST_NODE_TYPES.LabeledStatement;
 }
 declare type LeftHandSideExpression = ArrayExpression | ArrayPattern | ArrowFunctionExpression | CallExpression | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | LiteralExpression | MemberExpression | MetaProperty | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | ThisExpression | TSAsExpression | TSNonNullExpression | TSTypeAssertion;
 declare type LetOrConstOrVarDeclaration = ConstDeclaration | LetOrVarDeclaredDeclaration | LetOrVarNonDeclaredDeclaration;
 declare interface LetOrConstOrVarDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.VariableDeclaration;
     /**
      * The variables declared by this declaration.
      * Always non-empty.
@@ -1089,7 +1098,6 @@ declare interface LetOrConstOrVarDeclarationBase extends BaseNode {
      * ```
      */
     kind: 'const' | 'let' | 'var';
-    type: AST_NODE_TYPES.VariableDeclaration;
 }
 declare type LetOrConstOrVarDeclarator = VariableDeclaratorDefiniteAssignment | VariableDeclaratorMaybeInit | VariableDeclaratorNoInit;
 declare interface LetOrVarDeclaredDeclaration extends LetOrConstOrVarDeclarationBase {
@@ -1121,16 +1129,16 @@ declare interface LineComment extends BaseToken {
 }
 declare type Literal = BigIntLiteral | BooleanLiteral | NullLiteral | NumberLiteral | RegExpLiteral | StringLiteral;
 declare interface LiteralBase extends BaseNode {
-    raw: string;
     type: AST_NODE_TYPES.Literal;
+    raw: string;
     value: RegExp | bigint | boolean | number | string | null;
 }
 declare type LiteralExpression = Literal | TemplateLiteral;
 declare interface LogicalExpression extends BaseNode {
+    type: AST_NODE_TYPES.LogicalExpression;
     left: Expression;
     operator: '&&' | '??' | '||';
     right: Expression;
-    type: AST_NODE_TYPES.LogicalExpression;
 }
 declare type MemberExpression = MemberExpressionComputedName | MemberExpressionNonComputedName;
 declare interface MemberExpressionBase extends BaseNode {
@@ -1140,19 +1148,19 @@ declare interface MemberExpressionBase extends BaseNode {
     property: Expression | Identifier | PrivateIdentifier;
 }
 declare interface MemberExpressionComputedName extends MemberExpressionBase {
+    type: AST_NODE_TYPES.MemberExpression;
     computed: true;
     property: Expression;
-    type: AST_NODE_TYPES.MemberExpression;
 }
 declare interface MemberExpressionNonComputedName extends MemberExpressionBase {
+    type: AST_NODE_TYPES.MemberExpression;
     computed: false;
     property: Identifier | PrivateIdentifier;
-    type: AST_NODE_TYPES.MemberExpression;
 }
 declare interface MetaProperty extends BaseNode {
+    type: AST_NODE_TYPES.MetaProperty;
     meta: Identifier;
     property: Identifier;
-    type: AST_NODE_TYPES.MetaProperty;
 }
 declare type MethodDefinition = MethodDefinitionComputedName | MethodDefinitionNonComputedName;
 /** this should not be directly used - instead use MethodDefinitionComputedNameBase or MethodDefinitionNonComputedNameBase */
@@ -1183,13 +1191,14 @@ declare interface MethodDefinitionNonComputedNameBase extends MethodDefinitionBa
 }
 declare type NamedExportDeclarations = ClassDeclarationWithName | ClassDeclarationWithOptionalName | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration;
 declare interface NewExpression extends BaseNode {
+    type: AST_NODE_TYPES.NewExpression;
     arguments: CallExpressionArgument[];
     callee: Expression;
-    type: AST_NODE_TYPES.NewExpression;
     typeArguments: TSTypeParameterInstantiation | undefined;
 }
 declare type Node = AccessorProperty | ArrayExpression | ArrayPattern | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BinaryExpression | BlockStatement | BreakStatement | CallExpression | CatchClause | ChainExpression | ClassBody | ClassDeclaration | ClassExpression | ConditionalExpression | ContinueStatement | DebuggerStatement | Decorator | DoWhileStatement | EmptyStatement | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExportSpecifier | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | Identifier | IfStatement | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportSpecifier | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LabeledStatement | Literal | LogicalExpression | MemberExpression | MetaProperty | MethodDefinition | NewExpression | ObjectExpression | ObjectPattern | PrivateIdentifier | Program | Property | PropertyDefinition | RestElement | ReturnStatement | SequenceExpression | SpreadElement | StaticBlock | Super | SwitchCase | SwitchStatement | TaggedTemplateExpression | TemplateElement | TemplateLiteral | ThisExpression | ThrowStatement | TryStatement | TSAbstractAccessorProperty | TSAbstractKeyword | TSAbstractMethodDefinition | TSAbstractPropertyDefinition | TSAnyKeyword | TSArrayType | TSAsExpression | TSAsyncKeyword | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSClassImplements | TSConditionalType | TSConstructorType | TSConstructSignatureDeclaration | TSDeclareFunction | TSDeclareKeyword | TSEmptyBodyFunctionExpression | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExportKeyword | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexedAccessType | TSIndexSignature | TSInferType | TSInstantiationExpression | TSInterfaceBody | TSInterfaceDeclaration | TSInterfaceHeritage | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSPrivateKeyword | TSPropertySignature | TSProtectedKeyword | TSPublicKeyword | TSQualifiedName | TSReadonlyKeyword | TSRestType | TSSatisfiesExpression | TSStaticKeyword | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | UnaryExpression | UpdateExpression | VariableDeclaration | VariableDeclarator | WhileStatement | WithStatement | YieldExpression;
 declare interface NodeOrTokenData {
+    type: string;
     /**
      * The source location information of the node.
      *
@@ -1197,7 +1206,6 @@ declare interface NodeOrTokenData {
      */
     loc: SourceLocation;
     range: Range;
-    type: string;
 }
 declare interface NullLiteral extends LiteralBase {
     raw: 'null';
@@ -1213,15 +1221,15 @@ declare interface NumericToken extends BaseToken {
     type: AST_TOKEN_TYPES.Numeric;
 }
 declare interface ObjectExpression extends BaseNode {
-    properties: ObjectLiteralElement[];
     type: AST_NODE_TYPES.ObjectExpression;
+    properties: ObjectLiteralElement[];
 }
 declare type ObjectLiteralElement = Property | SpreadElement;
 declare interface ObjectPattern extends BaseNode {
+    type: AST_NODE_TYPES.ObjectPattern;
     decorators: Decorator[];
     optional: boolean;
     properties: (Property | RestElement)[];
-    type: AST_NODE_TYPES.ObjectPattern;
     typeAnnotation: TSTypeAnnotation | undefined;
 }
 declare type Parameter = ArrayPattern | AssignmentPattern | Identifier | ObjectPattern | RestElement | TSParameterProperty;
@@ -1236,26 +1244,26 @@ declare interface Position {
     line: number;
 }
 declare interface PrivateIdentifier extends BaseNode {
-    name: string;
     type: AST_NODE_TYPES.PrivateIdentifier;
+    name: string;
 }
 declare interface Program extends NodeOrTokenData {
+    type: AST_NODE_TYPES.Program;
     body: ProgramStatement[];
     comments: Comment[] | undefined;
     sourceType: 'module' | 'script';
     tokens: Token[] | undefined;
-    type: AST_NODE_TYPES.Program;
 }
 declare type ProgramStatement = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | Statement | TSImportEqualsDeclaration | TSNamespaceExportDeclaration;
 declare type Property = PropertyComputedName | PropertyNonComputedName;
 declare interface PropertyBase extends BaseNode {
+    type: AST_NODE_TYPES.Property;
     computed: boolean;
     key: PropertyName;
     kind: 'get' | 'init' | 'set';
     method: boolean;
     optional: boolean;
     shorthand: boolean;
-    type: AST_NODE_TYPES.Property;
     value: AssignmentPattern | BindingName | Expression | TSEmptyBodyFunctionExpression;
 }
 declare interface PropertyComputedName extends PropertyBase {
@@ -1363,27 +1371,27 @@ declare interface RegExpLiteral extends LiteralBase {
     value: RegExp | null;
 }
 declare interface RegularExpressionToken extends BaseToken {
+    type: AST_TOKEN_TYPES.RegularExpression;
     regex: {
         flags: string;
         pattern: string;
     };
-    type: AST_TOKEN_TYPES.RegularExpression;
 }
 declare interface RestElement extends BaseNode {
+    type: AST_NODE_TYPES.RestElement;
     argument: DestructuringPattern;
     decorators: Decorator[];
     optional: boolean;
-    type: AST_NODE_TYPES.RestElement;
     typeAnnotation: TSTypeAnnotation | undefined;
     value: AssignmentPattern | undefined;
 }
 declare interface ReturnStatement extends BaseNode {
-    argument: Expression | null;
     type: AST_NODE_TYPES.ReturnStatement;
+    argument: Expression | null;
 }
 declare interface SequenceExpression extends BaseNode {
-    expressions: Expression[];
     type: AST_NODE_TYPES.SequenceExpression;
+    expressions: Expression[];
 }
 declare interface SourceLocation {
     /**
@@ -1396,13 +1404,13 @@ declare interface SourceLocation {
     start: Position;
 }
 declare interface SpreadElement extends BaseNode {
-    argument: Expression;
     type: AST_NODE_TYPES.SpreadElement;
+    argument: Expression;
 }
 declare type Statement = BlockStatement | BreakStatement | ClassDeclarationWithName | ContinueStatement | DebuggerStatement | DoWhileStatement | EmptyStatement | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ExpressionStatement | ForInStatement | ForOfStatement | ForStatement | FunctionDeclarationWithName | IfStatement | ImportDeclaration | LabeledStatement | ReturnStatement | SwitchStatement | ThrowStatement | TryStatement | TSDeclareFunction | TSEnumDeclaration | TSExportAssignment | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSNamespaceExportDeclaration | TSTypeAliasDeclaration | VariableDeclaration | WhileStatement | WithStatement;
 declare interface StaticBlock extends BaseNode {
-    body: Statement[];
     type: AST_NODE_TYPES.StaticBlock;
+    body: Statement[];
 }
 declare interface StringLiteral extends LiteralBase {
     value: string;
@@ -1414,33 +1422,33 @@ declare interface Super extends BaseNode {
     type: AST_NODE_TYPES.Super;
 }
 declare interface SwitchCase extends BaseNode {
+    type: AST_NODE_TYPES.SwitchCase;
     consequent: Statement[];
     test: Expression | null;
-    type: AST_NODE_TYPES.SwitchCase;
 }
 declare interface SwitchStatement extends BaseNode {
+    type: AST_NODE_TYPES.SwitchStatement;
     cases: SwitchCase[];
     discriminant: Expression;
-    type: AST_NODE_TYPES.SwitchStatement;
 }
 declare interface TaggedTemplateExpression extends BaseNode {
+    type: AST_NODE_TYPES.TaggedTemplateExpression;
     quasi: TemplateLiteral;
     tag: Expression;
-    type: AST_NODE_TYPES.TaggedTemplateExpression;
     typeArguments: TSTypeParameterInstantiation | undefined;
 }
 declare interface TemplateElement extends BaseNode {
-    tail: boolean;
     type: AST_NODE_TYPES.TemplateElement;
+    tail: boolean;
     value: {
         cooked: string;
         raw: string;
     };
 }
 declare interface TemplateLiteral extends BaseNode {
+    type: AST_NODE_TYPES.TemplateLiteral;
     expressions: Expression[];
     quasis: TemplateElement[];
-    type: AST_NODE_TYPES.TemplateLiteral;
 }
 declare interface TemplateToken extends BaseToken {
     type: AST_TOKEN_TYPES.Template;
@@ -1449,15 +1457,15 @@ declare interface ThisExpression extends BaseNode {
     type: AST_NODE_TYPES.ThisExpression;
 }
 declare interface ThrowStatement extends BaseNode {
-    argument: Expression;
     type: AST_NODE_TYPES.ThrowStatement;
+    argument: Expression;
 }
 declare type Token = BooleanToken | Comment | IdentifierToken | JSXIdentifierToken | JSXTextToken | KeywordToken | NullToken | NumericToken | PunctuatorToken | RegularExpressionToken | StringToken | TemplateToken;
 declare interface TryStatement extends BaseNode {
+    type: AST_NODE_TYPES.TryStatement;
     block: BlockStatement;
     finalizer: BlockStatement | null;
     handler: CatchClause | null;
-    type: AST_NODE_TYPES.TryStatement;
 }
 declare type TSAbstractAccessorProperty = TSAbstractAccessorPropertyComputedName | TSAbstractAccessorPropertyNonComputedName;
 declare interface TSAbstractAccessorPropertyComputedName extends PropertyDefinitionComputedNameBase {
@@ -1491,12 +1499,12 @@ declare interface TSAnyKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSAnyKeyword;
 }
 declare interface TSArrayType extends BaseNode {
-    elementType: TypeNode;
     type: AST_NODE_TYPES.TSArrayType;
+    elementType: TypeNode;
 }
 declare interface TSAsExpression extends BaseNode {
-    expression: Expression;
     type: AST_NODE_TYPES.TSAsExpression;
+    expression: Expression;
     typeAnnotation: TypeNode;
 }
 declare interface TSAsyncKeyword extends BaseNode {
@@ -1515,21 +1523,22 @@ declare interface TSClassImplements extends TSHeritageBase {
     type: AST_NODE_TYPES.TSClassImplements;
 }
 declare interface TSConditionalType extends BaseNode {
+    type: AST_NODE_TYPES.TSConditionalType;
     checkType: TypeNode;
     extendsType: TypeNode;
     falseType: TypeNode;
     trueType: TypeNode;
-    type: AST_NODE_TYPES.TSConditionalType;
 }
 declare interface TSConstructorType extends TSFunctionSignatureBase {
-    abstract: boolean;
     type: AST_NODE_TYPES.TSConstructorType;
+    abstract: boolean;
 }
 declare interface TSConstructSignatureDeclaration extends TSFunctionSignatureBase {
     type: AST_NODE_TYPES.TSConstructSignatureDeclaration;
 }
 declare type TSDeclareFunction = TSDeclareFunctionNoDeclare | TSDeclareFunctionWithDeclare;
 declare interface TSDeclareFunctionBase extends FunctionBase {
+    type: AST_NODE_TYPES.TSDeclareFunction;
     /**
      * TS1183: An implementation cannot be declared in ambient contexts.
      */
@@ -1539,7 +1548,6 @@ declare interface TSDeclareFunctionBase extends FunctionBase {
      */
     declare: boolean;
     expression: false;
-    type: AST_NODE_TYPES.TSDeclareFunction;
 }
 /**
  * Function declaration without the `declare` keyword:
@@ -1578,15 +1586,16 @@ declare interface TSDeclareKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSDeclareKeyword;
 }
 declare interface TSEmptyBodyFunctionExpression extends FunctionBase {
+    type: AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
     body: null;
     id: null;
-    type: AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
 }
 declare interface TSEnumBody extends BaseNode {
-    members: TSEnumMember[];
     type: AST_NODE_TYPES.TSEnumBody;
+    members: TSEnumMember[];
 }
 declare interface TSEnumDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSEnumDeclaration;
     /**
      * The body of the enum.
      */
@@ -1616,14 +1625,13 @@ declare interface TSEnumDeclaration extends BaseNode {
      * @deprecated Use {@link body} instead.
      */
     members: TSEnumMember[];
-    type: AST_NODE_TYPES.TSEnumDeclaration;
 }
 declare type TSEnumMember = TSEnumMemberComputedName | TSEnumMemberNonComputedName;
 declare interface TSEnumMemberBase extends BaseNode {
+    type: AST_NODE_TYPES.TSEnumMember;
     computed: boolean;
     id: PropertyNameComputed | PropertyNameNonComputed;
     initializer: Expression | undefined;
-    type: AST_NODE_TYPES.TSEnumMember;
 }
 /**
  * this should only really happen in semantically invalid code (errors 1164 and 2452)
@@ -1648,15 +1656,15 @@ declare interface TSEnumMemberNonComputedName extends TSEnumMemberBase {
     id: PropertyNameNonComputed;
 }
 declare interface TSExportAssignment extends BaseNode {
-    expression: Expression;
     type: AST_NODE_TYPES.TSExportAssignment;
+    expression: Expression;
 }
 declare interface TSExportKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSExportKeyword;
 }
 declare interface TSExternalModuleReference extends BaseNode {
-    expression: StringLiteral;
     type: AST_NODE_TYPES.TSExternalModuleReference;
+    expression: StringLiteral;
 }
 declare interface TSFunctionSignatureBase extends BaseNode {
     params: Parameter[];
@@ -1672,6 +1680,7 @@ declare interface TSHeritageBase extends BaseNode {
 }
 declare type TSImportEqualsDeclaration = TSImportEqualsNamespaceDeclaration | TSImportEqualsRequireDeclaration;
 declare interface TSImportEqualsDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.TSImportEqualsDeclaration;
     /**
      * The locally imported name.
      */
@@ -1691,7 +1700,6 @@ declare interface TSImportEqualsDeclarationBase extends BaseNode {
      * ```
      */
     moduleReference: Identifier | TSExternalModuleReference | TSQualifiedName;
-    type: AST_NODE_TYPES.TSImportEqualsDeclaration;
 }
 declare interface TSImportEqualsNamespaceDeclaration extends TSImportEqualsDeclarationBase {
     /**
@@ -1721,22 +1729,22 @@ declare interface TSImportEqualsRequireDeclaration extends TSImportEqualsDeclara
     moduleReference: TSExternalModuleReference;
 }
 declare interface TSImportType extends BaseNode {
+    type: AST_NODE_TYPES.TSImportType;
     argument: TypeNode;
     qualifier: EntityName | null;
-    type: AST_NODE_TYPES.TSImportType;
     typeArguments: TSTypeParameterInstantiation | null;
 }
 declare interface TSIndexedAccessType extends BaseNode {
+    type: AST_NODE_TYPES.TSIndexedAccessType;
     indexType: TypeNode;
     objectType: TypeNode;
-    type: AST_NODE_TYPES.TSIndexedAccessType;
 }
 declare interface TSIndexSignature extends BaseNode {
+    type: AST_NODE_TYPES.TSIndexSignature;
     accessibility: Accessibility | undefined;
     parameters: Parameter[];
     readonly: boolean;
     static: boolean;
-    type: AST_NODE_TYPES.TSIndexSignature;
     typeAnnotation: TSTypeAnnotation | undefined;
 }
 declare interface TSInferType extends BaseNode {
@@ -1744,15 +1752,16 @@ declare interface TSInferType extends BaseNode {
     typeParameter: TSTypeParameter;
 }
 declare interface TSInstantiationExpression extends BaseNode {
-    expression: Expression;
     type: AST_NODE_TYPES.TSInstantiationExpression;
+    expression: Expression;
     typeArguments: TSTypeParameterInstantiation;
 }
 declare interface TSInterfaceBody extends BaseNode {
-    body: TypeElement[];
     type: AST_NODE_TYPES.TSInterfaceBody;
+    body: TypeElement[];
 }
 declare interface TSInterfaceDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSInterfaceDeclaration;
     /**
      * The body of the interface
      */
@@ -1769,7 +1778,6 @@ declare interface TSInterfaceDeclaration extends BaseNode {
      * The name of this interface
      */
     id: Identifier;
-    type: AST_NODE_TYPES.TSInterfaceDeclaration;
     /**
      * The generic type parameters declared for the interface. Empty declaration
      * (`<>`) is different from no declaration.
@@ -1787,22 +1795,23 @@ declare interface TSIntrinsicKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSIntrinsicKeyword;
 }
 declare interface TSLiteralType extends BaseNode {
-    literal: LiteralExpression | UnaryExpression | UpdateExpression;
     type: AST_NODE_TYPES.TSLiteralType;
+    literal: LiteralExpression | UnaryExpression | UpdateExpression;
 }
 declare interface TSMappedType extends BaseNode {
+    type: AST_NODE_TYPES.TSMappedType;
     constraint: TypeNode;
     key: Identifier;
     nameType: TypeNode | null;
     optional: '+' | '-' | boolean | undefined;
     readonly: '+' | '-' | boolean | undefined;
-    type: AST_NODE_TYPES.TSMappedType;
     typeAnnotation: TypeNode | undefined;
     /** @deprecated Use {@link `constraint`} and {@link `key`} instead. */
     typeParameter: TSTypeParameter;
 }
 declare type TSMethodSignature = TSMethodSignatureComputedName | TSMethodSignatureNonComputedName;
 declare interface TSMethodSignatureBase extends BaseNode {
+    type: AST_NODE_TYPES.TSMethodSignature;
     accessibility: Accessibility | undefined;
     computed: boolean;
     key: PropertyName;
@@ -1812,7 +1821,6 @@ declare interface TSMethodSignatureBase extends BaseNode {
     readonly: boolean;
     returnType: TSTypeAnnotation | undefined;
     static: boolean;
-    type: AST_NODE_TYPES.TSMethodSignature;
     typeParameters: TSTypeParameterDeclaration | undefined;
 }
 declare interface TSMethodSignatureComputedName extends TSMethodSignatureBase {
@@ -1824,11 +1832,12 @@ declare interface TSMethodSignatureNonComputedName extends TSMethodSignatureBase
     key: PropertyNameNonComputed;
 }
 declare interface TSModuleBlock extends BaseNode {
-    body: ProgramStatement[];
     type: AST_NODE_TYPES.TSModuleBlock;
+    body: ProgramStatement[];
 }
 declare type TSModuleDeclaration = TSModuleDeclarationGlobal | TSModuleDeclarationModule | TSModuleDeclarationNamespace;
 declare interface TSModuleDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.TSModuleDeclaration;
     /**
      * The body of the module.
      * This can only be `undefined` for the code `declare module 'mod';`
@@ -1876,7 +1885,6 @@ declare interface TSModuleDeclarationBase extends BaseNode {
      * ```
      */
     kind: TSModuleDeclarationKind;
-    type: AST_NODE_TYPES.TSModuleDeclaration;
 }
 declare interface TSModuleDeclarationGlobal extends TSModuleDeclarationBase {
     body: TSModuleBlock;
@@ -1934,10 +1942,10 @@ declare interface TSModuleDeclarationNamespace extends TSModuleDeclarationBase {
     kind: 'namespace';
 }
 declare interface TSNamedTupleMember extends BaseNode {
+    type: AST_NODE_TYPES.TSNamedTupleMember;
     elementType: TypeNode;
     label: Identifier;
     optional: boolean;
-    type: AST_NODE_TYPES.TSNamedTupleMember;
 }
 /**
  * For the following declaration:
@@ -1946,18 +1954,18 @@ declare interface TSNamedTupleMember extends BaseNode {
  * ```
  */
 declare interface TSNamespaceExportDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSNamespaceExportDeclaration;
     /**
      * The name of the global variable that's exported as namespace
      */
     id: Identifier;
-    type: AST_NODE_TYPES.TSNamespaceExportDeclaration;
 }
 declare interface TSNeverKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSNeverKeyword;
 }
 declare interface TSNonNullExpression extends BaseNode {
-    expression: Expression;
     type: AST_NODE_TYPES.TSNonNullExpression;
+    expression: Expression;
 }
 declare interface TSNullKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSNullKeyword;
@@ -1973,26 +1981,26 @@ declare interface TSOptionalType extends BaseNode {
     typeAnnotation: TypeNode;
 }
 declare interface TSParameterProperty extends BaseNode {
+    type: AST_NODE_TYPES.TSParameterProperty;
     accessibility: Accessibility | undefined;
     decorators: Decorator[];
     override: boolean;
     parameter: AssignmentPattern | BindingName | RestElement;
     readonly: boolean;
     static: boolean;
-    type: AST_NODE_TYPES.TSParameterProperty;
 }
 declare interface TSPrivateKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSPrivateKeyword;
 }
 declare type TSPropertySignature = TSPropertySignatureComputedName | TSPropertySignatureNonComputedName;
 declare interface TSPropertySignatureBase extends BaseNode {
+    type: AST_NODE_TYPES.TSPropertySignature;
     accessibility: Accessibility | undefined;
     computed: boolean;
     key: PropertyName;
     optional: boolean;
     readonly: boolean;
     static: boolean;
-    type: AST_NODE_TYPES.TSPropertySignature;
     typeAnnotation: TSTypeAnnotation | undefined;
 }
 declare interface TSPropertySignatureComputedName extends TSPropertySignatureBase {
@@ -2010,9 +2018,9 @@ declare interface TSPublicKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSPublicKeyword;
 }
 declare interface TSQualifiedName extends BaseNode {
+    type: AST_NODE_TYPES.TSQualifiedName;
     left: EntityName;
     right: Identifier;
-    type: AST_NODE_TYPES.TSQualifiedName;
 }
 declare interface TSReadonlyKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSReadonlyKeyword;
@@ -2022,8 +2030,8 @@ declare interface TSRestType extends BaseNode {
     typeAnnotation: TypeNode;
 }
 declare interface TSSatisfiesExpression extends BaseNode {
-    expression: Expression;
     type: AST_NODE_TYPES.TSSatisfiesExpression;
+    expression: Expression;
     typeAnnotation: TypeNode;
 }
 declare interface TSStaticKeyword extends BaseNode {
@@ -2036,18 +2044,19 @@ declare interface TSSymbolKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSSymbolKeyword;
 }
 declare interface TSTemplateLiteralType extends BaseNode {
-    quasis: TemplateElement[];
     type: AST_NODE_TYPES.TSTemplateLiteralType;
+    quasis: TemplateElement[];
     types: TypeNode[];
 }
 declare interface TSThisType extends BaseNode {
     type: AST_NODE_TYPES.TSThisType;
 }
 declare interface TSTupleType extends BaseNode {
-    elementTypes: TypeNode[];
     type: AST_NODE_TYPES.TSTupleType;
+    elementTypes: TypeNode[];
 }
 declare interface TSTypeAliasDeclaration extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeAliasDeclaration;
     /**
      * Whether the type was `declare`d.
      * @example
@@ -2060,7 +2069,6 @@ declare interface TSTypeAliasDeclaration extends BaseNode {
      * The name of the type.
      */
     id: Identifier;
-    type: AST_NODE_TYPES.TSTypeAliasDeclaration;
     /**
      * The "value" (type) of the declaration
      */
@@ -2076,45 +2084,45 @@ declare interface TSTypeAnnotation extends BaseNode {
     typeAnnotation: TypeNode;
 }
 declare interface TSTypeAssertion extends BaseNode {
-    expression: Expression;
     type: AST_NODE_TYPES.TSTypeAssertion;
+    expression: Expression;
     typeAnnotation: TypeNode;
 }
 declare interface TSTypeLiteral extends BaseNode {
-    members: TypeElement[];
     type: AST_NODE_TYPES.TSTypeLiteral;
+    members: TypeElement[];
 }
 declare interface TSTypeOperator extends BaseNode {
-    operator: 'keyof' | 'readonly' | 'unique';
     type: AST_NODE_TYPES.TSTypeOperator;
+    operator: 'keyof' | 'readonly' | 'unique';
     typeAnnotation: TypeNode | undefined;
 }
 declare interface TSTypeParameter extends BaseNode {
+    type: AST_NODE_TYPES.TSTypeParameter;
     const: boolean;
     constraint: TypeNode | undefined;
     default: TypeNode | undefined;
     in: boolean;
     name: Identifier;
     out: boolean;
-    type: AST_NODE_TYPES.TSTypeParameter;
 }
 declare interface TSTypeParameterDeclaration extends BaseNode {
-    params: TSTypeParameter[];
     type: AST_NODE_TYPES.TSTypeParameterDeclaration;
+    params: TSTypeParameter[];
 }
 declare interface TSTypeParameterInstantiation extends BaseNode {
-    params: TypeNode[];
     type: AST_NODE_TYPES.TSTypeParameterInstantiation;
+    params: TypeNode[];
 }
 declare interface TSTypePredicate extends BaseNode {
+    type: AST_NODE_TYPES.TSTypePredicate;
     asserts: boolean;
     parameterName: Identifier | TSThisType;
-    type: AST_NODE_TYPES.TSTypePredicate;
     typeAnnotation: TSTypeAnnotation | null;
 }
 declare interface TSTypeQuery extends BaseNode {
-    exprName: EntityName | TSImportType;
     type: AST_NODE_TYPES.TSTypeQuery;
+    exprName: EntityName | TSImportType;
     typeArguments: TSTypeParameterInstantiation | undefined;
 }
 declare interface TSTypeReference extends BaseNode {
@@ -2138,8 +2146,8 @@ declare interface TSVoidKeyword extends BaseNode {
 declare type TypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSIndexSignature | TSMethodSignature | TSPropertySignature;
 declare type TypeNode = TSAbstractKeyword | TSAnyKeyword | TSArrayType | TSAsyncKeyword | TSBigIntKeyword | TSBooleanKeyword | TSConditionalType | TSConstructorType | TSDeclareKeyword | TSExportKeyword | TSFunctionType | TSImportType | TSIndexedAccessType | TSInferType | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSNamedTupleMember | TSNeverKeyword | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSPrivateKeyword | TSProtectedKeyword | TSPublicKeyword | TSQualifiedName | TSReadonlyKeyword | TSRestType | TSStaticKeyword | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeLiteral | TSTypeOperator | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword;
 declare interface UnaryExpression extends UnaryExpressionBase {
-    operator: '!' | '+' | '~' | '-' | 'delete' | 'typeof' | 'void';
     type: AST_NODE_TYPES.UnaryExpression;
+    operator: '!' | '+' | '~' | '-' | 'delete' | 'typeof' | 'void';
 }
 declare interface UnaryExpressionBase extends BaseNode {
     argument: Expression;
@@ -2147,11 +2155,12 @@ declare interface UnaryExpressionBase extends BaseNode {
     prefix: boolean;
 }
 declare interface UpdateExpression extends UnaryExpressionBase {
-    operator: '++' | '--';
     type: AST_NODE_TYPES.UpdateExpression;
+    operator: '++' | '--';
 }
 declare type UsingDeclaration = UsingInForOfDeclaration | UsingInNormalContextDeclaration;
 declare interface UsingDeclarationBase extends BaseNode {
+    type: AST_NODE_TYPES.VariableDeclaration;
     /**
      * This value will always be `false`
      * because 'declare' modifier cannot appear on a 'using' declaration.
@@ -2166,7 +2175,6 @@ declare interface UsingDeclarationBase extends BaseNode {
      * ```
      */
     kind: 'await using' | 'using';
-    type: AST_NODE_TYPES.VariableDeclaration;
 }
 declare type UsingDeclarator = UsingInForOfDeclarator | UsingInNormalContextDeclarator;
 declare interface UsingInForOfDeclaration extends UsingDeclarationBase {
@@ -2206,6 +2214,7 @@ declare type ValueOf<T> = T[keyof T];
 declare type VariableDeclaration = LetOrConstOrVarDeclaration | UsingDeclaration;
 declare type VariableDeclarator = LetOrConstOrVarDeclarator | UsingDeclarator;
 declare interface VariableDeclaratorBase extends BaseNode {
+    type: AST_NODE_TYPES.VariableDeclarator;
     /**
      * Whether there's definite assignment assertion (`let x!: number`).
      * If `true`, then: `id` must be an identifier with a type annotation,
@@ -2221,7 +2230,6 @@ declare interface VariableDeclaratorBase extends BaseNode {
      * in a `declare const`.
      */
     init: Expression | null;
-    type: AST_NODE_TYPES.VariableDeclarator;
 }
 declare interface VariableDeclaratorDefiniteAssignment extends VariableDeclaratorBase {
     definite: true;
@@ -2239,19 +2247,19 @@ declare interface VariableDeclaratorNoInit extends VariableDeclaratorBase {
     init: null;
 }
 declare interface WhileStatement extends BaseNode {
+    type: AST_NODE_TYPES.WhileStatement;
     body: Statement;
     test: Expression;
-    type: AST_NODE_TYPES.WhileStatement;
 }
 declare interface WithStatement extends BaseNode {
+    type: AST_NODE_TYPES.WithStatement;
     body: Statement;
     object: Expression;
-    type: AST_NODE_TYPES.WithStatement;
 }
 declare interface YieldExpression extends BaseNode {
+    type: AST_NODE_TYPES.YieldExpression;
     argument: Expression | undefined;
     delegate: boolean;
-    type: AST_NODE_TYPES.YieldExpression;
 }
 
 /**