@typescript-eslint/types 8.2.1-alpha.2 → 8.2.1-alpha.21

package/dist/generated/ast-spec.d.ts

@@ -17,61 +17,61 @@ export declare interface AccessorPropertyNonComputedName extends PropertyDefinit
     type: AST_NODE_TYPES.AccessorProperty;
 }
 export 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;
 }
 export declare interface ArrayPattern extends BaseNode {
-    type: AST_NODE_TYPES.ArrayPattern;
+    decorators: Decorator[];
     elements: (DestructuringPattern | null)[];
-    typeAnnotation: TSTypeAnnotation | undefined;
     optional: boolean;
-    decorators: Decorator[];
+    type: AST_NODE_TYPES.ArrayPattern;
+    typeAnnotation: TSTypeAnnotation | undefined;
 }
 export declare interface ArrowFunctionExpression extends BaseNode {
-    type: AST_NODE_TYPES.ArrowFunctionExpression;
+    async: boolean;
+    body: BlockStatement | Expression;
+    expression: boolean;
     generator: boolean;
     id: null;
     params: Parameter[];
-    body: BlockStatement | Expression;
-    async: boolean;
-    expression: boolean;
     returnType: TSTypeAnnotation | undefined;
+    type: AST_NODE_TYPES.ArrowFunctionExpression;
     typeParameters: TSTypeParameterDeclaration | undefined;
 }
 export declare interface AssignmentExpression extends BaseNode {
-    type: AST_NODE_TYPES.AssignmentExpression;
-    operator: ValueOf<AssignmentOperatorToText>;
     left: Expression;
+    operator: ValueOf<AssignmentOperatorToText>;
     right: Expression;
+    type: AST_NODE_TYPES.AssignmentExpression;
 }
 export declare interface AssignmentOperatorToText {
-    [SyntaxKind.EqualsToken]: '=';
-    [SyntaxKind.PlusEqualsToken]: '+=';
-    [SyntaxKind.MinusEqualsToken]: '-=';
-    [SyntaxKind.AsteriskEqualsToken]: '*=';
+    [SyntaxKind.AmpersandAmpersandEqualsToken]: '&&=';
+    [SyntaxKind.AmpersandEqualsToken]: '&=';
     [SyntaxKind.AsteriskAsteriskEqualsToken]: '**=';
-    [SyntaxKind.SlashEqualsToken]: '/=';
-    [SyntaxKind.PercentEqualsToken]: '%=';
-    [SyntaxKind.LessThanLessThanEqualsToken]: '<<=';
+    [SyntaxKind.AsteriskEqualsToken]: '*=';
+    [SyntaxKind.BarBarEqualsToken]: '||=';
+    [SyntaxKind.BarEqualsToken]: '|=';
+    [SyntaxKind.CaretEqualsToken]: '^=';
+    [SyntaxKind.EqualsToken]: '=';
     [SyntaxKind.GreaterThanGreaterThanEqualsToken]: '>>=';
     [SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken]: '>>>=';
-    [SyntaxKind.AmpersandEqualsToken]: '&=';
-    [SyntaxKind.BarEqualsToken]: '|=';
-    [SyntaxKind.BarBarEqualsToken]: '||=';
-    [SyntaxKind.AmpersandAmpersandEqualsToken]: '&&=';
+    [SyntaxKind.LessThanLessThanEqualsToken]: '<<=';
+    [SyntaxKind.MinusEqualsToken]: '-=';
+    [SyntaxKind.PercentEqualsToken]: '%=';
+    [SyntaxKind.PlusEqualsToken]: '+=';
     [SyntaxKind.QuestionQuestionEqualsToken]: '??=';
-    [SyntaxKind.CaretEqualsToken]: '^=';
+    [SyntaxKind.SlashEqualsToken]: '/=';
 }
 export 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;
-    optional: boolean;
-    decorators: Decorator[];
 }
 export declare enum AST_NODE_TYPES {
     AccessorProperty = "AccessorProperty",
@@ -181,19 +181,19 @@ export declare enum AST_NODE_TYPES {
     TSDeclareFunction = "TSDeclareFunction",
     TSDeclareKeyword = "TSDeclareKeyword",
     TSEmptyBodyFunctionExpression = "TSEmptyBodyFunctionExpression",
-    TSEnumDeclaration = "TSEnumDeclaration",
     TSEnumBody = "TSEnumBody",
+    TSEnumDeclaration = "TSEnumDeclaration",
     TSEnumMember = "TSEnumMember",
     TSExportAssignment = "TSExportAssignment",
     TSExportKeyword = "TSExportKeyword",
     TSExternalModuleReference = "TSExternalModuleReference",
     TSFunctionType = "TSFunctionType",
-    TSInstantiationExpression = "TSInstantiationExpression",
     TSImportEqualsDeclaration = "TSImportEqualsDeclaration",
     TSImportType = "TSImportType",
     TSIndexedAccessType = "TSIndexedAccessType",
     TSIndexSignature = "TSIndexSignature",
     TSInferType = "TSInferType",
+    TSInstantiationExpression = "TSInstantiationExpression",
     TSInterfaceBody = "TSInterfaceBody",
     TSInterfaceDeclaration = "TSInterfaceDeclaration",
     TSInterfaceHeritage = "TSInterfaceHeritage",
@@ -259,8 +259,8 @@ export declare enum AST_TOKEN_TYPES {
     Line = "Line"
 }
 export declare interface AwaitExpression extends BaseNode {
-    type: AST_NODE_TYPES.AwaitExpression;
     argument: Expression;
+    type: AST_NODE_TYPES.AwaitExpression;
 }
 export declare interface BaseNode extends NodeOrTokenData {
     type: AST_NODE_TYPES;
@@ -270,40 +270,40 @@ declare interface BaseToken extends NodeOrTokenData {
     value: string;
 }
 export declare interface BigIntLiteral extends LiteralBase {
-    value: bigint | null;
     bigint: string;
+    value: bigint | null;
 }
 export declare interface BinaryExpression extends BaseNode {
-    type: AST_NODE_TYPES.BinaryExpression;
-    operator: ValueOf<BinaryOperatorToText>;
     left: Expression | PrivateIdentifier;
+    operator: ValueOf<BinaryOperatorToText>;
     right: Expression;
+    type: AST_NODE_TYPES.BinaryExpression;
 }
 export declare interface BinaryOperatorToText {
-    [SyntaxKind.InstanceOfKeyword]: 'instanceof';
-    [SyntaxKind.InKeyword]: 'in';
+    [SyntaxKind.AmpersandAmpersandToken]: '&&';
+    [SyntaxKind.AmpersandToken]: '&';
     [SyntaxKind.AsteriskAsteriskToken]: '**';
     [SyntaxKind.AsteriskToken]: '*';
-    [SyntaxKind.SlashToken]: '/';
-    [SyntaxKind.PercentToken]: '%';
-    [SyntaxKind.PlusToken]: '+';
-    [SyntaxKind.MinusToken]: '-';
-    [SyntaxKind.AmpersandToken]: '&';
+    [SyntaxKind.BarBarToken]: '||';
     [SyntaxKind.BarToken]: '|';
     [SyntaxKind.CaretToken]: '^';
-    [SyntaxKind.LessThanLessThanToken]: '<<';
-    [SyntaxKind.GreaterThanGreaterThanToken]: '>>';
-    [SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: '>>>';
-    [SyntaxKind.AmpersandAmpersandToken]: '&&';
-    [SyntaxKind.BarBarToken]: '||';
-    [SyntaxKind.LessThanToken]: '<';
-    [SyntaxKind.LessThanEqualsToken]: '<=';
-    [SyntaxKind.GreaterThanToken]: '>';
-    [SyntaxKind.GreaterThanEqualsToken]: '>=';
-    [SyntaxKind.EqualsEqualsToken]: '==';
     [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]: '/';
 }
 export declare type BindingName = BindingPattern | Identifier;
 export declare type BindingPattern = ArrayPattern | ObjectPattern;
@@ -311,37 +311,37 @@ export declare interface BlockComment extends BaseToken {
     type: AST_TOKEN_TYPES.Block;
 }
 export declare interface BlockStatement extends BaseNode {
-    type: AST_NODE_TYPES.BlockStatement;
     body: Statement[];
+    type: AST_NODE_TYPES.BlockStatement;
 }
 export declare interface BooleanLiteral extends LiteralBase {
-    value: boolean;
     raw: 'false' | 'true';
+    value: boolean;
 }
 export declare interface BooleanToken extends BaseToken {
     type: AST_TOKEN_TYPES.Boolean;
 }
 export declare interface BreakStatement extends BaseNode {
-    type: AST_NODE_TYPES.BreakStatement;
     label: Identifier | null;
+    type: AST_NODE_TYPES.BreakStatement;
 }
 export declare interface CallExpression extends BaseNode {
-    type: AST_NODE_TYPES.CallExpression;
-    callee: Expression;
     arguments: CallExpressionArgument[];
-    typeArguments: TSTypeParameterInstantiation | undefined;
+    callee: Expression;
     optional: boolean;
+    type: AST_NODE_TYPES.CallExpression;
+    typeArguments: TSTypeParameterInstantiation | undefined;
 }
 export declare type CallExpressionArgument = Expression | SpreadElement;
 export declare interface CatchClause extends BaseNode {
-    type: AST_NODE_TYPES.CatchClause;
-    param: BindingName | null;
     body: BlockStatement;
+    param: BindingName | null;
+    type: AST_NODE_TYPES.CatchClause;
 }
 export declare type ChainElement = CallExpression | MemberExpression | TSNonNullExpression;
 export declare interface ChainExpression extends BaseNode {
-    type: AST_NODE_TYPES.ChainExpression;
     expression: ChainElement;
+    type: AST_NODE_TYPES.ChainExpression;
 }
 declare interface ClassBase extends BaseNode {
     /**
@@ -398,8 +398,8 @@ declare interface ClassBase extends BaseNode {
     typeParameters: TSTypeParameterDeclaration | undefined;
 }
 export declare interface ClassBody extends BaseNode {
-    type: AST_NODE_TYPES.ClassBody;
     body: ClassElement[];
+    type: AST_NODE_TYPES.ClassBody;
 }
 export declare type ClassDeclaration = ClassDeclarationWithName | ClassDeclarationWithOptionalName;
 declare interface ClassDeclarationBase extends ClassBase {
@@ -425,28 +425,27 @@ export declare interface ClassDeclarationWithOptionalName extends ClassDeclarati
 }
 export declare type ClassElement = AccessorProperty | MethodDefinition | PropertyDefinition | StaticBlock | TSAbstractAccessorProperty | TSAbstractMethodDefinition | TSAbstractPropertyDefinition | TSIndexSignature;
 export declare interface ClassExpression extends ClassBase {
-    type: AST_NODE_TYPES.ClassExpression;
     abstract: false;
     declare: false;
+    type: AST_NODE_TYPES.ClassExpression;
 }
 declare interface ClassMethodDefinitionNonComputedNameBase extends MethodDefinitionBase {
-    key: ClassPropertyNameNonComputed;
     computed: false;
+    key: ClassPropertyNameNonComputed;
 }
 declare interface ClassPropertyDefinitionNonComputedNameBase extends PropertyDefinitionBase {
-    key: ClassPropertyNameNonComputed;
     computed: false;
+    key: ClassPropertyNameNonComputed;
 }
 export declare type ClassPropertyNameNonComputed = PrivateIdentifier | PropertyNameNonComputed;
 export declare type Comment = BlockComment | LineComment;
 export declare interface ConditionalExpression extends BaseNode {
-    type: AST_NODE_TYPES.ConditionalExpression;
-    test: Expression;
-    consequent: Expression;
     alternate: Expression;
+    consequent: Expression;
+    test: Expression;
+    type: AST_NODE_TYPES.ConditionalExpression;
 }
 export declare interface ConstDeclaration extends LetOrConstOrVarDeclarationBase {
-    kind: 'const';
     /**
      * In a `declare const` declaration, the declarators may have initializers, but
      * not definite assignment assertions. Each declarator cannot have both an
@@ -456,10 +455,11 @@ export declare interface ConstDeclaration extends LetOrConstOrVarDeclarationBase
      * no initializer.
      */
     declarations: VariableDeclaratorMaybeInit[];
+    kind: 'const';
 }
 export declare interface ContinueStatement extends BaseNode {
-    type: AST_NODE_TYPES.ContinueStatement;
     label: Identifier | null;
+    type: AST_NODE_TYPES.ContinueStatement;
 }
 export declare interface DebuggerStatement extends BaseNode {
     type: AST_NODE_TYPES.DebuggerStatement;
@@ -470,22 +470,21 @@ export declare interface DebuggerStatement extends BaseNode {
  */
 export declare type DeclarationStatement = ClassDeclaration | ClassExpression | ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | FunctionDeclaration | TSDeclareFunction | TSEnumDeclaration | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSNamespaceExportDeclaration | TSTypeAliasDeclaration;
 export declare interface Decorator extends BaseNode {
-    type: AST_NODE_TYPES.Decorator;
     expression: LeftHandSideExpression;
+    type: AST_NODE_TYPES.Decorator;
 }
 export declare type DefaultExportDeclarations = ClassDeclarationWithOptionalName | Expression | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration;
 export declare type DestructuringPattern = ArrayPattern | AssignmentPattern | Identifier | MemberExpression | ObjectPattern | RestElement;
 export declare interface DoWhileStatement extends BaseNode {
-    type: AST_NODE_TYPES.DoWhileStatement;
-    test: Expression;
     body: Statement;
+    test: Expression;
+    type: AST_NODE_TYPES.DoWhileStatement;
 }
 export declare interface EmptyStatement extends BaseNode {
     type: AST_NODE_TYPES.EmptyStatement;
 }
 export declare type EntityName = Identifier | ThisExpression | TSQualifiedName;
 export declare interface ExportAllDeclaration extends BaseNode {
-    type: AST_NODE_TYPES.ExportAllDeclaration;
     /**
      * The assertions declared for the export.
      * @example
@@ -515,11 +514,11 @@ export declare interface ExportAllDeclaration extends BaseNode {
      * The source module being exported from.
      */
     source: StringLiteral;
+    type: AST_NODE_TYPES.ExportAllDeclaration;
 }
 declare type ExportAndImportKind = 'type' | 'value';
 export declare type ExportDeclaration = DefaultExportDeclarations | NamedExportDeclarations;
 export declare interface ExportDefaultDeclaration extends BaseNode {
-    type: AST_NODE_TYPES.ExportDefaultDeclaration;
     /**
      * The declaration being exported.
      */
@@ -528,11 +527,11 @@ export 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;
 export declare type ExportNamedDeclaration = ExportNamedDeclarationWithoutSourceWithMultiple | ExportNamedDeclarationWithoutSourceWithSingle | ExportNamedDeclarationWithSource;
 declare interface ExportNamedDeclarationBase extends BaseNode {
-    type: AST_NODE_TYPES.ExportNamedDeclaration;
     /**
      * The assertions declared for the export.
      * @example
@@ -578,6 +577,7 @@ 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.
@@ -633,38 +633,38 @@ export declare interface ExportNamedDeclarationWithSource extends ExportNamedDec
     source: StringLiteral;
 }
 export declare interface ExportSpecifier extends BaseNode {
-    type: AST_NODE_TYPES.ExportSpecifier;
-    local: Identifier;
     exported: Identifier;
     exportKind: ExportKind;
+    local: Identifier;
+    type: AST_NODE_TYPES.ExportSpecifier;
 }
 export 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;
 export declare interface ExpressionStatement extends BaseNode {
-    type: AST_NODE_TYPES.ExpressionStatement;
-    expression: Expression;
     directive: string | undefined;
+    expression: Expression;
+    type: AST_NODE_TYPES.ExpressionStatement;
 }
 export declare type ForInitialiser = Expression | LetOrConstOrVarDeclaration;
 export declare interface ForInStatement extends BaseNode {
-    type: AST_NODE_TYPES.ForInStatement;
+    body: Statement;
     left: ForInitialiser;
     right: Expression;
-    body: Statement;
+    type: AST_NODE_TYPES.ForInStatement;
 }
 declare type ForOfInitialiser = Expression | LetOrConstOrVarDeclaration | UsingInForOfDeclaration;
 export declare interface ForOfStatement extends BaseNode {
-    type: AST_NODE_TYPES.ForOfStatement;
+    await: boolean;
+    body: Statement;
     left: ForOfInitialiser;
     right: Expression;
-    body: Statement;
-    await: boolean;
+    type: AST_NODE_TYPES.ForOfStatement;
 }
 export 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;
-    body: Statement;
 }
 declare interface FunctionBase extends BaseNode {
     /**
@@ -731,10 +731,10 @@ declare interface FunctionBase extends BaseNode {
 }
 export 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:
@@ -755,35 +755,34 @@ export declare interface FunctionDeclarationWithOptionalName extends FunctionDec
     id: Identifier | null;
 }
 export declare interface FunctionExpression extends FunctionBase {
-    type: AST_NODE_TYPES.FunctionExpression;
     body: BlockStatement;
     expression: false;
+    type: AST_NODE_TYPES.FunctionExpression;
 }
 export declare type FunctionLike = ArrowFunctionExpression | FunctionDeclaration | FunctionExpression | TSDeclareFunction | TSEmptyBodyFunctionExpression;
 export declare interface Identifier extends BaseNode {
-    type: AST_NODE_TYPES.Identifier;
+    decorators: Decorator[];
     name: string;
-    typeAnnotation: TSTypeAnnotation | undefined;
     optional: boolean;
-    decorators: Decorator[];
+    type: AST_NODE_TYPES.Identifier;
+    typeAnnotation: TSTypeAnnotation | undefined;
 }
 export declare interface IdentifierToken extends BaseToken {
     type: AST_TOKEN_TYPES.Identifier;
 }
 export declare interface IfStatement extends BaseNode {
-    type: AST_NODE_TYPES.IfStatement;
-    test: Expression;
-    consequent: Statement;
     alternate: Statement | null;
+    consequent: Statement;
+    test: Expression;
+    type: AST_NODE_TYPES.IfStatement;
 }
 export declare interface ImportAttribute extends BaseNode {
-    type: AST_NODE_TYPES.ImportAttribute;
     key: Identifier | Literal;
+    type: AST_NODE_TYPES.ImportAttribute;
     value: Literal;
 }
 export declare type ImportClause = ImportDefaultSpecifier | ImportNamespaceSpecifier | ImportSpecifier;
 export declare interface ImportDeclaration extends BaseNode {
-    type: AST_NODE_TYPES.ImportDeclaration;
     /**
      * The assertions declared for the export.
      * @example
@@ -821,101 +820,102 @@ export declare interface ImportDeclaration extends BaseNode {
      * ```
      */
     specifiers: ImportClause[];
+    type: AST_NODE_TYPES.ImportDeclaration;
 }
 export declare interface ImportDefaultSpecifier extends BaseNode {
-    type: AST_NODE_TYPES.ImportDefaultSpecifier;
     local: Identifier;
+    type: AST_NODE_TYPES.ImportDefaultSpecifier;
 }
 export declare interface ImportExpression extends BaseNode {
-    type: AST_NODE_TYPES.ImportExpression;
-    source: Expression;
     attributes: Expression | null;
+    source: Expression;
+    type: AST_NODE_TYPES.ImportExpression;
 }
 declare type ImportKind = ExportAndImportKind;
 export declare interface ImportNamespaceSpecifier extends BaseNode {
-    type: AST_NODE_TYPES.ImportNamespaceSpecifier;
     local: Identifier;
+    type: AST_NODE_TYPES.ImportNamespaceSpecifier;
 }
 export declare interface ImportSpecifier extends BaseNode {
-    type: AST_NODE_TYPES.ImportSpecifier;
-    local: Identifier;
     imported: Identifier;
     importKind: ImportKind;
+    local: Identifier;
+    type: AST_NODE_TYPES.ImportSpecifier;
 }
 export declare type IterationStatement = DoWhileStatement | ForInStatement | ForOfStatement | ForStatement | WhileStatement;
 export declare interface JSXAttribute extends BaseNode {
-    type: AST_NODE_TYPES.JSXAttribute;
     name: JSXIdentifier | JSXNamespacedName;
+    type: AST_NODE_TYPES.JSXAttribute;
     value: JSXElement | JSXExpression | Literal | null;
 }
 export declare type JSXChild = JSXElement | JSXExpression | JSXFragment | JSXText;
 export declare interface JSXClosingElement extends BaseNode {
-    type: AST_NODE_TYPES.JSXClosingElement;
     name: JSXTagNameExpression;
+    type: AST_NODE_TYPES.JSXClosingElement;
 }
 export declare interface JSXClosingFragment extends BaseNode {
     type: AST_NODE_TYPES.JSXClosingFragment;
 }
 export declare interface JSXElement extends BaseNode {
-    type: AST_NODE_TYPES.JSXElement;
-    openingElement: JSXOpeningElement;
-    closingElement: JSXClosingElement | null;
     children: JSXChild[];
+    closingElement: JSXClosingElement | null;
+    openingElement: JSXOpeningElement;
+    type: AST_NODE_TYPES.JSXElement;
 }
 export declare interface JSXEmptyExpression extends BaseNode {
     type: AST_NODE_TYPES.JSXEmptyExpression;
 }
 export declare type JSXExpression = JSXExpressionContainer | JSXSpreadChild;
 export declare interface JSXExpressionContainer extends BaseNode {
-    type: AST_NODE_TYPES.JSXExpressionContainer;
     expression: Expression | JSXEmptyExpression;
+    type: AST_NODE_TYPES.JSXExpressionContainer;
 }
 export declare interface JSXFragment extends BaseNode {
-    type: AST_NODE_TYPES.JSXFragment;
-    openingFragment: JSXOpeningFragment;
-    closingFragment: JSXClosingFragment;
     children: JSXChild[];
+    closingFragment: JSXClosingFragment;
+    openingFragment: JSXOpeningFragment;
+    type: AST_NODE_TYPES.JSXFragment;
 }
 export declare interface JSXIdentifier extends BaseNode {
-    type: AST_NODE_TYPES.JSXIdentifier;
     name: string;
+    type: AST_NODE_TYPES.JSXIdentifier;
 }
 export declare interface JSXIdentifierToken extends BaseToken {
     type: AST_TOKEN_TYPES.JSXIdentifier;
 }
 export declare interface JSXMemberExpression extends BaseNode {
-    type: AST_NODE_TYPES.JSXMemberExpression;
     object: JSXTagNameExpression;
     property: JSXIdentifier;
+    type: AST_NODE_TYPES.JSXMemberExpression;
 }
 export declare interface JSXNamespacedName extends BaseNode {
-    type: AST_NODE_TYPES.JSXNamespacedName;
-    namespace: JSXIdentifier;
     name: JSXIdentifier;
+    namespace: JSXIdentifier;
+    type: AST_NODE_TYPES.JSXNamespacedName;
 }
 export declare interface JSXOpeningElement extends BaseNode {
+    attributes: (JSXAttribute | JSXSpreadAttribute)[];
+    name: JSXTagNameExpression;
+    selfClosing: boolean;
     type: AST_NODE_TYPES.JSXOpeningElement;
     typeArguments: TSTypeParameterInstantiation | undefined;
-    selfClosing: boolean;
-    name: JSXTagNameExpression;
-    attributes: (JSXAttribute | JSXSpreadAttribute)[];
 }
 export declare interface JSXOpeningFragment extends BaseNode {
     type: AST_NODE_TYPES.JSXOpeningFragment;
 }
 export declare interface JSXSpreadAttribute extends BaseNode {
-    type: AST_NODE_TYPES.JSXSpreadAttribute;
     argument: Expression;
+    type: AST_NODE_TYPES.JSXSpreadAttribute;
 }
 export declare interface JSXSpreadChild extends BaseNode {
-    type: AST_NODE_TYPES.JSXSpreadChild;
     expression: Expression | JSXEmptyExpression;
+    type: AST_NODE_TYPES.JSXSpreadChild;
 }
 export declare type JSXTagNameExpression = JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
 export declare interface JSXText extends BaseNode {
+    raw: string;
     type: AST_NODE_TYPES.JSXText;
     value: string;
-    raw: string;
 }
 export declare interface JSXTextToken extends BaseToken {
     type: AST_TOKEN_TYPES.JSXText;
@@ -924,14 +924,13 @@ export declare interface KeywordToken extends BaseToken {
     type: AST_TOKEN_TYPES.Keyword;
 }
 export declare interface LabeledStatement extends BaseNode {
-    type: AST_NODE_TYPES.LabeledStatement;
-    label: Identifier;
     body: Statement;
+    label: Identifier;
+    type: AST_NODE_TYPES.LabeledStatement;
 }
 export declare type LeftHandSideExpression = ArrayExpression | ArrayPattern | ArrowFunctionExpression | CallExpression | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | LiteralExpression | MemberExpression | MetaProperty | ObjectExpression | ObjectPattern | SequenceExpression | Super | TaggedTemplateExpression | ThisExpression | TSAsExpression | TSNonNullExpression | TSTypeAssertion;
 export 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.
@@ -960,11 +959,10 @@ declare interface LetOrConstOrVarDeclarationBase extends BaseNode {
      * ```
      */
     kind: 'const' | 'let' | 'var';
+    type: AST_NODE_TYPES.VariableDeclaration;
 }
 export declare type LetOrConstOrVarDeclarator = VariableDeclaratorDefiniteAssignment | VariableDeclaratorMaybeInit | VariableDeclaratorNoInit;
 export declare interface LetOrVarDeclaredDeclaration extends LetOrConstOrVarDeclarationBase {
-    kind: 'let' | 'var';
-    declare: true;
     /**
      * In a `declare let` declaration, the declarators must not have definite assignment
      * assertions or initializers.
@@ -976,86 +974,88 @@ export declare interface LetOrVarDeclaredDeclaration extends LetOrConstOrVarDecl
      * ```
      */
     declarations: VariableDeclaratorNoInit[];
+    declare: true;
+    kind: 'let' | 'var';
 }
 export declare interface LetOrVarNonDeclaredDeclaration extends LetOrConstOrVarDeclarationBase {
-    kind: 'let' | 'var';
-    declare: false;
     /**
      * In a `let`/`var` declaration, the declarators may have definite assignment
      * assertions or initializers, but not both.
      */
     declarations: (VariableDeclaratorDefiniteAssignment | VariableDeclaratorMaybeInit)[];
+    declare: false;
+    kind: 'let' | 'var';
 }
 export declare interface LineComment extends BaseToken {
     type: AST_TOKEN_TYPES.Line;
 }
 export declare type Literal = BigIntLiteral | BooleanLiteral | NullLiteral | NumberLiteral | RegExpLiteral | StringLiteral;
 declare interface LiteralBase extends BaseNode {
-    type: AST_NODE_TYPES.Literal;
     raw: string;
+    type: AST_NODE_TYPES.Literal;
     value: RegExp | bigint | boolean | number | string | null;
 }
 export declare type LiteralExpression = Literal | TemplateLiteral;
 export declare interface LogicalExpression extends BaseNode {
-    type: AST_NODE_TYPES.LogicalExpression;
-    operator: '??' | '&&' | '||';
     left: Expression;
+    operator: '&&' | '??' | '||';
     right: Expression;
+    type: AST_NODE_TYPES.LogicalExpression;
 }
 export declare type MemberExpression = MemberExpressionComputedName | MemberExpressionNonComputedName;
 declare interface MemberExpressionBase extends BaseNode {
+    computed: boolean;
     object: Expression;
+    optional: boolean;
     property: Expression | Identifier | PrivateIdentifier;
-    computed: boolean;
-    optional: boolean;
 }
 export declare interface MemberExpressionComputedName extends MemberExpressionBase {
-    type: AST_NODE_TYPES.MemberExpression;
-    property: Expression;
     computed: true;
+    property: Expression;
+    type: AST_NODE_TYPES.MemberExpression;
 }
 export declare interface MemberExpressionNonComputedName extends MemberExpressionBase {
-    type: AST_NODE_TYPES.MemberExpression;
-    property: Identifier | PrivateIdentifier;
     computed: false;
+    property: Identifier | PrivateIdentifier;
+    type: AST_NODE_TYPES.MemberExpression;
 }
 export declare interface MetaProperty extends BaseNode {
-    type: AST_NODE_TYPES.MetaProperty;
     meta: Identifier;
     property: Identifier;
+    type: AST_NODE_TYPES.MetaProperty;
 }
 export declare type MethodDefinition = MethodDefinitionComputedName | MethodDefinitionNonComputedName;
 /** this should not be directly used - instead use MethodDefinitionComputedNameBase or MethodDefinitionNonComputedNameBase */
 declare interface MethodDefinitionBase extends BaseNode {
-    key: PropertyName;
-    value: FunctionExpression | TSEmptyBodyFunctionExpression;
+    accessibility: Accessibility | undefined;
     computed: boolean;
-    static: boolean;
+    decorators: Decorator[];
+    key: PropertyName;
     kind: 'constructor' | 'get' | 'method' | 'set';
     optional: boolean;
-    decorators: Decorator[];
-    accessibility: Accessibility | undefined;
     override: boolean;
+    static: boolean;
+    value: FunctionExpression | TSEmptyBodyFunctionExpression;
 }
 export declare interface MethodDefinitionComputedName extends MethodDefinitionComputedNameBase {
     type: AST_NODE_TYPES.MethodDefinition;
 }
 declare interface MethodDefinitionComputedNameBase extends MethodDefinitionBase {
-    key: PropertyNameComputed;
     computed: true;
+    key: PropertyNameComputed;
 }
 export declare interface MethodDefinitionNonComputedName extends ClassMethodDefinitionNonComputedNameBase {
     type: AST_NODE_TYPES.MethodDefinition;
 }
 declare interface MethodDefinitionNonComputedNameBase extends MethodDefinitionBase {
-    key: PropertyNameNonComputed;
     computed: false;
+    key: PropertyNameNonComputed;
 }
 export declare type NamedExportDeclarations = ClassDeclarationWithName | ClassDeclarationWithOptionalName | FunctionDeclarationWithName | FunctionDeclarationWithOptionalName | TSDeclareFunction | TSEnumDeclaration | TSImportEqualsDeclaration | TSInterfaceDeclaration | TSModuleDeclaration | TSTypeAliasDeclaration | VariableDeclaration;
 export declare interface NewExpression extends BaseNode {
-    type: AST_NODE_TYPES.NewExpression;
-    callee: Expression;
     arguments: CallExpressionArgument[];
+    callee: Expression;
+    type: AST_NODE_TYPES.NewExpression;
     typeArguments: TSTypeParameterInstantiation | undefined;
 }
 export 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;
@@ -1070,8 +1070,8 @@ export declare interface NodeOrTokenData {
     type: string;
 }
 export declare interface NullLiteral extends LiteralBase {
-    value: null;
     raw: 'null';
+    value: null;
 }
 export declare interface NullToken extends BaseToken {
     type: AST_TOKEN_TYPES.Null;
@@ -1083,147 +1083,147 @@ export declare interface NumericToken extends BaseToken {
     type: AST_TOKEN_TYPES.Numeric;
 }
 export declare interface ObjectExpression extends BaseNode {
-    type: AST_NODE_TYPES.ObjectExpression;
     properties: ObjectLiteralElement[];
+    type: AST_NODE_TYPES.ObjectExpression;
 }
 export declare type ObjectLiteralElement = Property | SpreadElement;
 export declare type ObjectLiteralElementLike = ObjectLiteralElement;
 export 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;
-    optional: boolean;
-    decorators: Decorator[];
 }
-export declare type OptionalRangeAndLoc<T> = Pick<T, Exclude<keyof T, 'loc' | 'range'>> & {
-    range?: Range;
+export declare type OptionalRangeAndLoc<T> = {
     loc?: SourceLocation;
-};
+    range?: Range;
+} & Pick<T, Exclude<keyof T, 'loc' | 'range'>>;
 export declare type Parameter = ArrayPattern | AssignmentPattern | Identifier | ObjectPattern | RestElement | TSParameterProperty;
 export declare interface Position {
-    /**
-     * Line number (1-indexed)
-     */
-    line: number;
     /**
      * Column number on the line (0-indexed)
      */
     column: number;
+    /**
+     * Line number (1-indexed)
+     */
+    line: number;
 }
 export declare type PrimaryExpression = ArrayExpression | ArrayPattern | ClassExpression | FunctionExpression | Identifier | JSXElement | JSXFragment | JSXOpeningElement | LiteralExpression | MetaProperty | ObjectExpression | ObjectPattern | Super | TemplateLiteral | ThisExpression | TSNullKeyword;
 export declare interface PrivateIdentifier extends BaseNode {
-    type: AST_NODE_TYPES.PrivateIdentifier;
     name: string;
+    type: AST_NODE_TYPES.PrivateIdentifier;
 }
 export declare interface Program extends NodeOrTokenData {
-    type: AST_NODE_TYPES.Program;
     body: ProgramStatement[];
-    sourceType: 'module' | 'script';
     comments: Comment[] | undefined;
+    sourceType: 'module' | 'script';
     tokens: Token[] | undefined;
+    type: AST_NODE_TYPES.Program;
 }
 export declare type ProgramStatement = ExportAllDeclaration | ExportDefaultDeclaration | ExportNamedDeclaration | ImportDeclaration | Statement | TSImportEqualsDeclaration | TSNamespaceExportDeclaration;
 export declare type Property = PropertyComputedName | PropertyNonComputedName;
 declare interface PropertyBase extends BaseNode {
-    type: AST_NODE_TYPES.Property;
-    key: PropertyName;
-    value: AssignmentPattern | BindingName | Expression | TSEmptyBodyFunctionExpression;
     computed: boolean;
+    key: PropertyName;
+    kind: 'get' | 'init' | 'set';
     method: boolean;
-    shorthand: boolean;
     optional: boolean;
-    kind: 'get' | 'init' | 'set';
+    shorthand: boolean;
+    type: AST_NODE_TYPES.Property;
+    value: AssignmentPattern | BindingName | Expression | TSEmptyBodyFunctionExpression;
 }
 export declare interface PropertyComputedName extends PropertyBase {
-    key: PropertyNameComputed;
     computed: true;
+    key: PropertyNameComputed;
 }
 export declare type PropertyDefinition = PropertyDefinitionComputedName | PropertyDefinitionNonComputedName;
 declare interface PropertyDefinitionBase extends BaseNode {
-    key: PropertyName;
-    value: Expression | null;
+    accessibility: Accessibility | undefined;
     computed: boolean;
-    static: boolean;
     declare: boolean;
-    readonly: boolean;
     decorators: Decorator[];
-    accessibility: Accessibility | undefined;
-    optional: boolean;
     definite: boolean;
-    typeAnnotation: TSTypeAnnotation | undefined;
+    key: PropertyName;
+    optional: boolean;
     override: boolean;
+    readonly: boolean;
+    static: boolean;
+    typeAnnotation: TSTypeAnnotation | undefined;
+    value: Expression | null;
 }
 export declare interface PropertyDefinitionComputedName extends PropertyDefinitionComputedNameBase {
     type: AST_NODE_TYPES.PropertyDefinition;
 }
 declare interface PropertyDefinitionComputedNameBase extends PropertyDefinitionBase {
-    key: PropertyNameComputed;
     computed: true;
+    key: PropertyNameComputed;
 }
 export declare interface PropertyDefinitionNonComputedName extends ClassPropertyDefinitionNonComputedNameBase {
     type: AST_NODE_TYPES.PropertyDefinition;
 }
 declare interface PropertyDefinitionNonComputedNameBase extends PropertyDefinitionBase {
-    key: PropertyNameNonComputed;
     computed: false;
+    key: PropertyNameNonComputed;
 }
 export declare type PropertyName = ClassPropertyNameNonComputed | PropertyNameComputed | PropertyNameNonComputed;
 export declare type PropertyNameComputed = Expression;
 export declare type PropertyNameNonComputed = Identifier | NumberLiteral | StringLiteral;
 export declare interface PropertyNonComputedName extends PropertyBase {
-    key: PropertyNameNonComputed;
     computed: false;
+    key: PropertyNameNonComputed;
 }
 export declare interface PunctuatorToken extends BaseToken {
     type: AST_TOKEN_TYPES.Punctuator;
     value: ValueOf<PunctuatorTokenToText>;
 }
 export declare interface PunctuatorTokenToText extends AssignmentOperatorToText {
-    [SyntaxKind.OpenBraceToken]: '{';
+    [SyntaxKind.AmpersandAmpersandToken]: '&&';
+    [SyntaxKind.AmpersandToken]: '&';
+    [SyntaxKind.AsteriskAsteriskToken]: '**';
+    [SyntaxKind.AsteriskToken]: '*';
+    [SyntaxKind.AtToken]: '@';
+    [SyntaxKind.BacktickToken]: '`';
+    [SyntaxKind.BarBarToken]: '||';
+    [SyntaxKind.BarToken]: '|';
+    [SyntaxKind.CaretToken]: '^';
     [SyntaxKind.CloseBraceToken]: '}';
-    [SyntaxKind.OpenParenToken]: '(';
-    [SyntaxKind.CloseParenToken]: ')';
-    [SyntaxKind.OpenBracketToken]: '[';
     [SyntaxKind.CloseBracketToken]: ']';
-    [SyntaxKind.DotToken]: '.';
-    [SyntaxKind.DotDotDotToken]: '...';
-    [SyntaxKind.SemicolonToken]: ';';
+    [SyntaxKind.CloseParenToken]: ')';
+    [SyntaxKind.ColonToken]: ':';
     [SyntaxKind.CommaToken]: ',';
-    [SyntaxKind.QuestionDotToken]: '?.';
-    [SyntaxKind.LessThanToken]: '<';
-    [SyntaxKind.LessThanSlashToken]: '</';
-    [SyntaxKind.GreaterThanToken]: '>';
-    [SyntaxKind.LessThanEqualsToken]: '<=';
-    [SyntaxKind.GreaterThanEqualsToken]: '>=';
-    [SyntaxKind.EqualsEqualsToken]: '==';
-    [SyntaxKind.ExclamationEqualsToken]: '!=';
+    [SyntaxKind.DotDotDotToken]: '...';
+    [SyntaxKind.DotToken]: '.';
     [SyntaxKind.EqualsEqualsEqualsToken]: '===';
-    [SyntaxKind.ExclamationEqualsEqualsToken]: '!==';
+    [SyntaxKind.EqualsEqualsToken]: '==';
     [SyntaxKind.EqualsGreaterThanToken]: '=>';
-    [SyntaxKind.PlusToken]: '+';
+    [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.AsteriskToken]: '*';
-    [SyntaxKind.AsteriskAsteriskToken]: '**';
-    [SyntaxKind.SlashToken]: '/';
+    [SyntaxKind.OpenBraceToken]: '{';
+    [SyntaxKind.OpenBracketToken]: '[';
+    [SyntaxKind.OpenParenToken]: '(';
     [SyntaxKind.PercentToken]: '%';
     [SyntaxKind.PlusPlusToken]: '++';
-    [SyntaxKind.MinusMinusToken]: '--';
-    [SyntaxKind.LessThanLessThanToken]: '<<';
-    [SyntaxKind.GreaterThanGreaterThanToken]: '>>';
-    [SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: '>>>';
-    [SyntaxKind.AmpersandToken]: '&';
-    [SyntaxKind.BarToken]: '|';
-    [SyntaxKind.CaretToken]: '^';
-    [SyntaxKind.ExclamationToken]: '!';
-    [SyntaxKind.TildeToken]: '~';
-    [SyntaxKind.AmpersandAmpersandToken]: '&&';
-    [SyntaxKind.BarBarToken]: '||';
-    [SyntaxKind.QuestionToken]: '?';
-    [SyntaxKind.ColonToken]: ':';
-    [SyntaxKind.AtToken]: '@';
+    [SyntaxKind.PlusToken]: '+';
+    [SyntaxKind.QuestionDotToken]: '?.';
     [SyntaxKind.QuestionQuestionToken]: '??';
-    [SyntaxKind.BacktickToken]: '`';
-    [SyntaxKind.HashToken]: '#';
+    [SyntaxKind.QuestionToken]: '?';
+    [SyntaxKind.SemicolonToken]: ';';
+    [SyntaxKind.SlashToken]: '/';
+    [SyntaxKind.TildeToken]: '~';
 }
 /**
  * An array of two numbers.
@@ -1232,53 +1232,53 @@ export declare interface PunctuatorTokenToText extends AssignmentOperatorToText
  */
 export declare type Range = [number, number];
 export declare interface RegExpLiteral extends LiteralBase {
-    value: RegExp | null;
     regex: {
-        pattern: string;
         flags: string;
+        pattern: string;
     };
+    value: RegExp | null;
 }
 export declare interface RegularExpressionToken extends BaseToken {
-    type: AST_TOKEN_TYPES.RegularExpression;
     regex: {
-        pattern: string;
         flags: string;
+        pattern: string;
     };
+    type: AST_TOKEN_TYPES.RegularExpression;
 }
 export declare interface RestElement extends BaseNode {
-    type: AST_NODE_TYPES.RestElement;
     argument: DestructuringPattern;
-    typeAnnotation: TSTypeAnnotation | undefined;
+    decorators: Decorator[];
     optional: boolean;
+    type: AST_NODE_TYPES.RestElement;
+    typeAnnotation: TSTypeAnnotation | undefined;
     value: AssignmentPattern | undefined;
-    decorators: Decorator[];
 }
 export declare interface ReturnStatement extends BaseNode {
-    type: AST_NODE_TYPES.ReturnStatement;
     argument: Expression | null;
+    type: AST_NODE_TYPES.ReturnStatement;
 }
 export declare interface SequenceExpression extends BaseNode {
-    type: AST_NODE_TYPES.SequenceExpression;
     expressions: Expression[];
+    type: AST_NODE_TYPES.SequenceExpression;
 }
 export declare interface SourceLocation {
-    /**
-     * The position of the first character of the parsed source region
-     */
-    start: Position;
     /**
      * The position of the first character after the parsed source region
      */
     end: Position;
+    /**
+     * The position of the first character of the parsed source region
+     */
+    start: Position;
 }
 export declare interface SpreadElement extends BaseNode {
-    type: AST_NODE_TYPES.SpreadElement;
     argument: Expression;
+    type: AST_NODE_TYPES.SpreadElement;
 }
 export 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;
 export declare interface StaticBlock extends BaseNode {
-    type: AST_NODE_TYPES.StaticBlock;
     body: Statement[];
+    type: AST_NODE_TYPES.StaticBlock;
 }
 export declare interface StringLiteral extends LiteralBase {
     value: string;
@@ -1290,14 +1290,14 @@ export declare interface Super extends BaseNode {
     type: AST_NODE_TYPES.Super;
 }
 export declare interface SwitchCase extends BaseNode {
-    type: AST_NODE_TYPES.SwitchCase;
-    test: Expression | null;
     consequent: Statement[];
+    test: Expression | null;
+    type: AST_NODE_TYPES.SwitchCase;
 }
 export declare interface SwitchStatement extends BaseNode {
-    type: AST_NODE_TYPES.SwitchStatement;
-    discriminant: Expression;
     cases: SwitchCase[];
+    discriminant: Expression;
+    type: AST_NODE_TYPES.SwitchStatement;
 }
 export declare interface TaggedTemplateExpression extends BaseNode {
     quasi: TemplateLiteral;
@@ -1306,17 +1306,17 @@ export declare interface TaggedTemplateExpression extends BaseNode {
     typeArguments: TSTypeParameterInstantiation | undefined;
 }
 export declare interface TemplateElement extends BaseNode {
+    tail: boolean;
     type: AST_NODE_TYPES.TemplateElement;
     value: {
-        raw: string;
         cooked: string;
+        raw: string;
     };
-    tail: boolean;
 }
 export declare interface TemplateLiteral extends BaseNode {
-    type: AST_NODE_TYPES.TemplateLiteral;
-    quasis: TemplateElement[];
     expressions: Expression[];
+    quasis: TemplateElement[];
+    type: AST_NODE_TYPES.TemplateLiteral;
 }
 export declare interface TemplateToken extends BaseToken {
     type: AST_TOKEN_TYPES.Template;
@@ -1325,15 +1325,15 @@ export declare interface ThisExpression extends BaseNode {
     type: AST_NODE_TYPES.ThisExpression;
 }
 export declare interface ThrowStatement extends BaseNode {
-    type: AST_NODE_TYPES.ThrowStatement;
     argument: Statement | TSAsExpression | null;
+    type: AST_NODE_TYPES.ThrowStatement;
 }
 export declare type Token = BooleanToken | Comment | IdentifierToken | JSXIdentifierToken | JSXTextToken | KeywordToken | NullToken | NumericToken | PunctuatorToken | RegularExpressionToken | StringToken | TemplateToken;
 export declare interface TryStatement extends BaseNode {
-    type: AST_NODE_TYPES.TryStatement;
     block: BlockStatement;
-    handler: CatchClause | null;
     finalizer: BlockStatement | null;
+    handler: CatchClause | null;
+    type: AST_NODE_TYPES.TryStatement;
 }
 export declare type TSAbstractAccessorProperty = TSAbstractAccessorPropertyComputedName | TSAbstractAccessorPropertyNonComputedName;
 export declare interface TSAbstractAccessorPropertyComputedName extends PropertyDefinitionComputedNameBase {
@@ -1367,12 +1367,12 @@ export declare interface TSAnyKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSAnyKeyword;
 }
 export declare interface TSArrayType extends BaseNode {
-    type: AST_NODE_TYPES.TSArrayType;
     elementType: TypeNode;
+    type: AST_NODE_TYPES.TSArrayType;
 }
 export declare interface TSAsExpression extends BaseNode {
-    type: AST_NODE_TYPES.TSAsExpression;
     expression: Expression;
+    type: AST_NODE_TYPES.TSAsExpression;
     typeAnnotation: TypeNode;
 }
 export declare interface TSAsyncKeyword extends BaseNode {
@@ -1391,22 +1391,21 @@ export declare interface TSClassImplements extends TSHeritageBase {
     type: AST_NODE_TYPES.TSClassImplements;
 }
 export declare interface TSConditionalType extends BaseNode {
-    type: AST_NODE_TYPES.TSConditionalType;
     checkType: TypeNode;
     extendsType: TypeNode;
-    trueType: TypeNode;
     falseType: TypeNode;
+    trueType: TypeNode;
+    type: AST_NODE_TYPES.TSConditionalType;
 }
 export declare interface TSConstructorType extends TSFunctionSignatureBase {
-    type: AST_NODE_TYPES.TSConstructorType;
     abstract: boolean;
+    type: AST_NODE_TYPES.TSConstructorType;
 }
 export declare interface TSConstructSignatureDeclaration extends TSFunctionSignatureBase {
     type: AST_NODE_TYPES.TSConstructSignatureDeclaration;
 }
 export declare type TSDeclareFunction = TSDeclareFunctionNoDeclare | TSDeclareFunctionWithDeclare;
 declare interface TSDeclareFunctionBase extends FunctionBase {
-    type: AST_NODE_TYPES.TSDeclareFunction;
     /**
      * TS1183: An implementation cannot be declared in ambient contexts.
      */
@@ -1416,6 +1415,7 @@ declare interface TSDeclareFunctionBase extends FunctionBase {
      */
     declare: boolean;
     expression: false;
+    type: AST_NODE_TYPES.TSDeclareFunction;
 }
 /**
  * Function declaration without the `declare` keyword:
@@ -1454,16 +1454,15 @@ export declare interface TSDeclareKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSDeclareKeyword;
 }
 export declare interface TSEmptyBodyFunctionExpression extends FunctionBase {
-    type: AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
     body: null;
     id: null;
+    type: AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
 }
 export declare interface TSEnumBody extends BaseNode {
-    type: AST_NODE_TYPES.TSEnumBody;
     members: TSEnumMember[];
+    type: AST_NODE_TYPES.TSEnumBody;
 }
 export declare interface TSEnumDeclaration extends BaseNode {
-    type: AST_NODE_TYPES.TSEnumDeclaration;
     /**
      * The body of the enum.
      */
@@ -1493,13 +1492,14 @@ export declare interface TSEnumDeclaration extends BaseNode {
      * @deprecated Use {@link body} instead.
      */
     members: TSEnumMember[];
+    type: AST_NODE_TYPES.TSEnumDeclaration;
 }
 export declare type TSEnumMember = TSEnumMemberComputedName | TSEnumMemberNonComputedName;
 declare interface TSEnumMemberBase extends BaseNode {
-    type: AST_NODE_TYPES.TSEnumMember;
+    computed: boolean;
     id: PropertyNameComputed | PropertyNameNonComputed;
     initializer: Expression | undefined;
-    computed: boolean;
+    type: AST_NODE_TYPES.TSEnumMember;
 }
 /**
  * this should only really happen in semantically invalid code (errors 1164 and 2452)
@@ -1516,23 +1516,23 @@ declare interface TSEnumMemberBase extends BaseNode {
  * ```
  */
 export declare interface TSEnumMemberComputedName extends TSEnumMemberBase {
-    id: PropertyNameComputed;
     computed: true;
+    id: PropertyNameComputed;
 }
 export declare interface TSEnumMemberNonComputedName extends TSEnumMemberBase {
-    id: PropertyNameNonComputed;
     computed: false;
+    id: PropertyNameNonComputed;
 }
 export declare interface TSExportAssignment extends BaseNode {
-    type: AST_NODE_TYPES.TSExportAssignment;
     expression: Expression;
+    type: AST_NODE_TYPES.TSExportAssignment;
 }
 export declare interface TSExportKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSExportKeyword;
 }
 export declare interface TSExternalModuleReference extends BaseNode {
-    type: AST_NODE_TYPES.TSExternalModuleReference;
     expression: StringLiteral;
+    type: AST_NODE_TYPES.TSExternalModuleReference;
 }
 declare interface TSFunctionSignatureBase extends BaseNode {
     params: Parameter[];
@@ -1548,11 +1548,15 @@ declare interface TSHeritageBase extends BaseNode {
 }
 export declare type TSImportEqualsDeclaration = TSImportEqualsNamespaceDeclaration | TSImportEqualsRequireDeclaration;
 declare interface TSImportEqualsDeclarationBase extends BaseNode {
-    type: AST_NODE_TYPES.TSImportEqualsDeclaration;
     /**
      * The locally imported name.
      */
     id: Identifier;
+    /**
+     * The kind of the import. Always `'value'` unless `moduleReference` is a
+     * `TSExternalModuleReference`.
+     */
+    importKind: ImportKind;
     /**
      * The value being aliased.
      * @example
@@ -1563,13 +1567,13 @@ declare interface TSImportEqualsDeclarationBase extends BaseNode {
      * ```
      */
     moduleReference: Identifier | TSExternalModuleReference | TSQualifiedName;
-    /**
-     * The kind of the import. Always `'value'` unless `moduleReference` is a
-     * `TSExternalModuleReference`.
-     */
-    importKind: ImportKind;
+    type: AST_NODE_TYPES.TSImportEqualsDeclaration;
 }
 export declare interface TSImportEqualsNamespaceDeclaration extends TSImportEqualsDeclarationBase {
+    /**
+     * The kind of the import.
+     */
+    importKind: 'value';
     /**
      * The value being aliased.
      * ```
@@ -1578,12 +1582,12 @@ export declare interface TSImportEqualsNamespaceDeclaration extends TSImportEqua
      * ```
      */
     moduleReference: Identifier | TSQualifiedName;
+}
+export declare interface TSImportEqualsRequireDeclaration extends TSImportEqualsDeclarationBase {
     /**
      * The kind of the import.
      */
-    importKind: 'value';
-}
-export declare interface TSImportEqualsRequireDeclaration extends TSImportEqualsDeclarationBase {
+    importKind: ImportKind;
     /**
      * The value being aliased.
      * ```
@@ -1591,45 +1595,40 @@ export declare interface TSImportEqualsRequireDeclaration extends TSImportEquals
      * ```
      */
     moduleReference: TSExternalModuleReference;
-    /**
-     * The kind of the import.
-     */
-    importKind: ImportKind;
 }
 export declare interface TSImportType extends BaseNode {
-    type: AST_NODE_TYPES.TSImportType;
     argument: TypeNode;
     qualifier: EntityName | null;
+    type: AST_NODE_TYPES.TSImportType;
     typeArguments: TSTypeParameterInstantiation | null;
 }
 export declare interface TSIndexedAccessType extends BaseNode {
-    type: AST_NODE_TYPES.TSIndexedAccessType;
-    objectType: TypeNode;
     indexType: TypeNode;
+    objectType: TypeNode;
+    type: AST_NODE_TYPES.TSIndexedAccessType;
 }
 export declare interface TSIndexSignature extends BaseNode {
-    type: AST_NODE_TYPES.TSIndexSignature;
+    accessibility: Accessibility | undefined;
     parameters: Parameter[];
-    typeAnnotation: TSTypeAnnotation | undefined;
     readonly: boolean;
-    accessibility: Accessibility | undefined;
     static: boolean;
+    type: AST_NODE_TYPES.TSIndexSignature;
+    typeAnnotation: TSTypeAnnotation | undefined;
 }
 export declare interface TSInferType extends BaseNode {
     type: AST_NODE_TYPES.TSInferType;
     typeParameter: TSTypeParameter;
 }
 export declare interface TSInstantiationExpression extends BaseNode {
-    type: AST_NODE_TYPES.TSInstantiationExpression;
     expression: Expression;
+    type: AST_NODE_TYPES.TSInstantiationExpression;
     typeArguments: TSTypeParameterInstantiation;
 }
 export declare interface TSInterfaceBody extends BaseNode {
-    type: AST_NODE_TYPES.TSInterfaceBody;
     body: TypeElement[];
+    type: AST_NODE_TYPES.TSInterfaceBody;
 }
 export declare interface TSInterfaceDeclaration extends BaseNode {
-    type: AST_NODE_TYPES.TSInterfaceDeclaration;
     /**
      * The body of the interface
      */
@@ -1646,6 +1645,7 @@ export 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.
@@ -1663,23 +1663,22 @@ export declare interface TSIntrinsicKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSIntrinsicKeyword;
 }
 export declare interface TSLiteralType extends BaseNode {
-    type: AST_NODE_TYPES.TSLiteralType;
     literal: LiteralExpression | UnaryExpression | UpdateExpression;
+    type: AST_NODE_TYPES.TSLiteralType;
 }
 export declare interface TSMappedType extends BaseNode {
-    type: AST_NODE_TYPES.TSMappedType;
-    /** @deprecated Use {@link `constraint`} and {@link `key`} instead. */
-    typeParameter: TSTypeParameter;
     constraint: TypeNode;
     key: Identifier;
-    readonly: boolean | '-' | '+' | undefined;
-    optional: boolean | '-' | '+' | undefined;
-    typeAnnotation: TypeNode | undefined;
     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;
 }
 export declare type TSMethodSignature = TSMethodSignatureComputedName | TSMethodSignatureNonComputedName;
 declare interface TSMethodSignatureBase extends BaseNode {
-    type: AST_NODE_TYPES.TSMethodSignature;
     accessibility: Accessibility | undefined;
     computed: boolean;
     key: PropertyName;
@@ -1689,37 +1688,36 @@ declare interface TSMethodSignatureBase extends BaseNode {
     readonly: boolean;
     returnType: TSTypeAnnotation | undefined;
     static: boolean;
+    type: AST_NODE_TYPES.TSMethodSignature;
     typeParameters: TSTypeParameterDeclaration | undefined;
 }
 export declare interface TSMethodSignatureComputedName extends TSMethodSignatureBase {
-    key: PropertyNameComputed;
     computed: true;
+    key: PropertyNameComputed;
 }
 export declare interface TSMethodSignatureNonComputedName extends TSMethodSignatureBase {
-    key: PropertyNameNonComputed;
     computed: false;
+    key: PropertyNameNonComputed;
 }
 export declare interface TSModuleBlock extends BaseNode {
-    type: AST_NODE_TYPES.TSModuleBlock;
     body: ProgramStatement[];
+    type: AST_NODE_TYPES.TSModuleBlock;
 }
 export declare type TSModuleDeclaration = TSModuleDeclarationGlobal | TSModuleDeclarationModule | TSModuleDeclarationNamespace;
 declare interface TSModuleDeclarationBase extends BaseNode {
-    type: AST_NODE_TYPES.TSModuleDeclaration;
-    /**
-     * The name of the module
-     * ```
-     * namespace A {}
-     * namespace A.B.C {}
-     * module 'a' {}
-     * ```
-     */
-    id: Identifier | Literal | TSQualifiedName;
     /**
      * The body of the module.
      * This can only be `undefined` for the code `declare module 'mod';`
      */
     body?: TSModuleBlock;
+    /**
+     * Whether the module is `declare`d
+     * @example
+     * ```ts
+     * declare namespace F {}
+     * ```
+     */
+    declare: boolean;
     /**
      * Whether this is a global declaration
      * @example
@@ -1731,13 +1729,14 @@ declare interface TSModuleDeclarationBase extends BaseNode {
      */
     global: boolean;
     /**
-     * Whether the module is `declare`d
-     * @example
-     * ```ts
-     * declare namespace F {}
+     * The name of the module
+     * ```
+     * namespace A {}
+     * namespace A.B.C {}
+     * module 'a' {}
      * ```
      */
-    declare: boolean;
+    id: Identifier | Literal | TSQualifiedName;
     /**
      * The keyword used to define this module declaration
      * @example
@@ -1753,14 +1752,15 @@ declare interface TSModuleDeclarationBase extends BaseNode {
      * ```
      */
     kind: TSModuleDeclarationKind;
+    type: AST_NODE_TYPES.TSModuleDeclaration;
 }
 export declare interface TSModuleDeclarationGlobal extends TSModuleDeclarationBase {
-    kind: 'global';
+    body: TSModuleBlock;
     /**
      * This will always be an Identifier with name `global`
      */
     id: Identifier;
-    body: TSModuleBlock;
+    kind: 'global';
 }
 export declare type TSModuleDeclarationKind = 'global' | 'module' | 'namespace';
 export declare type TSModuleDeclarationModule = TSModuleDeclarationModuleWithIdentifierId | TSModuleDeclarationModuleWithStringId;
@@ -1774,9 +1774,9 @@ declare interface TSModuleDeclarationModuleBase extends TSModuleDeclarationBase
  * ```
  */
 export declare interface TSModuleDeclarationModuleWithIdentifierId extends TSModuleDeclarationModuleBase {
-    kind: 'module';
-    id: Identifier;
     body: TSModuleBlock;
+    id: Identifier;
+    kind: 'module';
 }
 export declare type TSModuleDeclarationModuleWithStringId = TSModuleDeclarationModuleWithStringIdDeclared | TSModuleDeclarationModuleWithStringIdNotDeclared;
 /**
@@ -1787,10 +1787,10 @@ export declare type TSModuleDeclarationModuleWithStringId = TSModuleDeclarationM
  * ```
  */
 export declare interface TSModuleDeclarationModuleWithStringIdDeclared extends TSModuleDeclarationModuleBase {
-    kind: 'module';
-    id: StringLiteral;
-    declare: true;
     body?: TSModuleBlock;
+    declare: true;
+    id: StringLiteral;
+    kind: 'module';
 }
 /**
  * A string module declaration that is not declared:
@@ -1799,21 +1799,21 @@ export declare interface TSModuleDeclarationModuleWithStringIdDeclared extends T
  * ```
  */
 export declare interface TSModuleDeclarationModuleWithStringIdNotDeclared extends TSModuleDeclarationModuleBase {
-    kind: 'module';
-    id: StringLiteral;
-    declare: false;
     body: TSModuleBlock;
+    declare: false;
+    id: StringLiteral;
+    kind: 'module';
 }
 export declare interface TSModuleDeclarationNamespace extends TSModuleDeclarationBase {
-    kind: 'namespace';
-    id: Identifier | TSQualifiedName;
     body: TSModuleBlock;
+    id: Identifier | TSQualifiedName;
+    kind: 'namespace';
 }
 export 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:
@@ -1822,18 +1822,18 @@ export declare interface TSNamedTupleMember extends BaseNode {
  * ```
  */
 export 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;
 }
 export declare interface TSNeverKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSNeverKeyword;
 }
 export declare interface TSNonNullExpression extends BaseNode {
-    type: AST_NODE_TYPES.TSNonNullExpression;
     expression: Expression;
+    type: AST_NODE_TYPES.TSNonNullExpression;
 }
 export declare interface TSNullKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSNullKeyword;
@@ -1849,35 +1849,35 @@ export declare interface TSOptionalType extends BaseNode {
     typeAnnotation: TypeNode;
 }
 export declare interface TSParameterProperty extends BaseNode {
-    type: AST_NODE_TYPES.TSParameterProperty;
     accessibility: Accessibility | undefined;
-    readonly: boolean;
-    static: boolean;
+    decorators: Decorator[];
     override: boolean;
     parameter: AssignmentPattern | BindingName | RestElement;
-    decorators: Decorator[];
+    readonly: boolean;
+    static: boolean;
+    type: AST_NODE_TYPES.TSParameterProperty;
 }
 export declare interface TSPrivateKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSPrivateKeyword;
 }
 export declare type TSPropertySignature = TSPropertySignatureComputedName | TSPropertySignatureNonComputedName;
 declare interface TSPropertySignatureBase extends BaseNode {
-    type: AST_NODE_TYPES.TSPropertySignature;
+    accessibility: Accessibility | undefined;
+    computed: boolean;
     key: PropertyName;
     optional: boolean;
-    computed: boolean;
-    typeAnnotation: TSTypeAnnotation | undefined;
     readonly: boolean;
     static: boolean;
-    accessibility: Accessibility | undefined;
+    type: AST_NODE_TYPES.TSPropertySignature;
+    typeAnnotation: TSTypeAnnotation | undefined;
 }
 export declare interface TSPropertySignatureComputedName extends TSPropertySignatureBase {
-    key: PropertyNameComputed;
     computed: true;
+    key: PropertyNameComputed;
 }
 export declare interface TSPropertySignatureNonComputedName extends TSPropertySignatureBase {
-    key: PropertyNameNonComputed;
     computed: false;
+    key: PropertyNameNonComputed;
 }
 export declare interface TSProtectedKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSProtectedKeyword;
@@ -1886,9 +1886,9 @@ export declare interface TSPublicKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSPublicKeyword;
 }
 export declare interface TSQualifiedName extends BaseNode {
-    type: AST_NODE_TYPES.TSQualifiedName;
     left: EntityName;
     right: Identifier;
+    type: AST_NODE_TYPES.TSQualifiedName;
 }
 export declare interface TSReadonlyKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSReadonlyKeyword;
@@ -1898,8 +1898,8 @@ export declare interface TSRestType extends BaseNode {
     typeAnnotation: TypeNode;
 }
 export declare interface TSSatisfiesExpression extends BaseNode {
-    type: AST_NODE_TYPES.TSSatisfiesExpression;
     expression: Expression;
+    type: AST_NODE_TYPES.TSSatisfiesExpression;
     typeAnnotation: TypeNode;
 }
 export declare interface TSStaticKeyword extends BaseNode {
@@ -1912,19 +1912,18 @@ export declare interface TSSymbolKeyword extends BaseNode {
     type: AST_NODE_TYPES.TSSymbolKeyword;
 }
 export declare interface TSTemplateLiteralType extends BaseNode {
-    type: AST_NODE_TYPES.TSTemplateLiteralType;
     quasis: TemplateElement[];
+    type: AST_NODE_TYPES.TSTemplateLiteralType;
     types: TypeNode[];
 }
 export declare interface TSThisType extends BaseNode {
     type: AST_NODE_TYPES.TSThisType;
 }
 export declare interface TSTupleType extends BaseNode {
-    type: AST_NODE_TYPES.TSTupleType;
     elementTypes: TypeNode[];
+    type: AST_NODE_TYPES.TSTupleType;
 }
 export declare interface TSTypeAliasDeclaration extends BaseNode {
-    type: AST_NODE_TYPES.TSTypeAliasDeclaration;
     /**
      * Whether the type was `declare`d.
      * @example
@@ -1937,6 +1936,7 @@ export declare interface TSTypeAliasDeclaration extends BaseNode {
      * The name of the type.
      */
     id: Identifier;
+    type: AST_NODE_TYPES.TSTypeAliasDeclaration;
     /**
      * The "value" (type) of the declaration
      */
@@ -1952,45 +1952,45 @@ export declare interface TSTypeAnnotation extends BaseNode {
     typeAnnotation: TypeNode;
 }
 export declare interface TSTypeAssertion extends BaseNode {
+    expression: Expression;
     type: AST_NODE_TYPES.TSTypeAssertion;
     typeAnnotation: TypeNode;
-    expression: Expression;
 }
 export declare interface TSTypeLiteral extends BaseNode {
-    type: AST_NODE_TYPES.TSTypeLiteral;
     members: TypeElement[];
+    type: AST_NODE_TYPES.TSTypeLiteral;
 }
 export declare interface TSTypeOperator extends BaseNode {
-    type: AST_NODE_TYPES.TSTypeOperator;
     operator: 'keyof' | 'readonly' | 'unique';
+    type: AST_NODE_TYPES.TSTypeOperator;
     typeAnnotation: TypeNode | undefined;
 }
 export declare interface TSTypeParameter extends BaseNode {
-    type: AST_NODE_TYPES.TSTypeParameter;
-    name: Identifier;
+    const: boolean;
     constraint: TypeNode | undefined;
     default: TypeNode | undefined;
     in: boolean;
+    name: Identifier;
     out: boolean;
-    const: boolean;
+    type: AST_NODE_TYPES.TSTypeParameter;
 }
 export declare interface TSTypeParameterDeclaration extends BaseNode {
-    type: AST_NODE_TYPES.TSTypeParameterDeclaration;
     params: TSTypeParameter[];
+    type: AST_NODE_TYPES.TSTypeParameterDeclaration;
 }
 export declare interface TSTypeParameterInstantiation extends BaseNode {
-    type: AST_NODE_TYPES.TSTypeParameterInstantiation;
     params: TypeNode[];
+    type: AST_NODE_TYPES.TSTypeParameterInstantiation;
 }
 export declare interface TSTypePredicate extends BaseNode {
-    type: AST_NODE_TYPES.TSTypePredicate;
     asserts: boolean;
     parameterName: Identifier | TSThisType;
+    type: AST_NODE_TYPES.TSTypePredicate;
     typeAnnotation: TSTypeAnnotation | null;
 }
 export declare interface TSTypeQuery extends BaseNode {
-    type: AST_NODE_TYPES.TSTypeQuery;
     exprName: EntityName | TSImportType;
+    type: AST_NODE_TYPES.TSTypeQuery;
     typeArguments: TSTypeParameterInstantiation | undefined;
 }
 export declare interface TSTypeReference extends BaseNode {
@@ -2015,21 +2015,20 @@ export declare interface TSVoidKeyword extends BaseNode {
 export declare type TypeElement = TSCallSignatureDeclaration | TSConstructSignatureDeclaration | TSIndexSignature | TSMethodSignature | TSPropertySignature;
 export 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;
 export 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;
     operator: string;
     prefix: boolean;
-    argument: Expression;
 }
 export declare interface UpdateExpression extends UnaryExpressionBase {
+    operator: '++' | '--';
     type: AST_NODE_TYPES.UpdateExpression;
-    operator: '--' | '++';
 }
 export 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.
@@ -2044,6 +2043,7 @@ declare interface UsingDeclarationBase extends BaseNode {
      * ```
      */
     kind: 'await using' | 'using';
+    type: AST_NODE_TYPES.VariableDeclaration;
 }
 export declare type UsingDeclarator = UsingInForOfDeclarator | UsingInNormalContextDeclarator;
 export declare interface UsingInForOfDeclaration extends UsingDeclarationBase {
@@ -2058,9 +2058,9 @@ export declare interface UsingInForOfDeclaration extends UsingDeclarationBase {
     declarations: [UsingInForOfDeclarator];
 }
 export declare interface UsingInForOfDeclarator extends VariableDeclaratorBase {
+    definite: false;
     id: Identifier;
     init: null;
-    definite: false;
 }
 export declare interface UsingInNormalContextDeclaration extends UsingDeclarationBase {
     /**
@@ -2075,15 +2075,20 @@ export declare interface UsingInNormalContextDeclaration extends UsingDeclaratio
     declarations: UsingInNormalContextDeclarator[];
 }
 export declare interface UsingInNormalContextDeclarator extends VariableDeclaratorBase {
+    definite: false;
     id: Identifier;
     init: Expression;
-    definite: false;
 }
 declare type ValueOf<T> = T[keyof T];
 export declare type VariableDeclaration = LetOrConstOrVarDeclaration | UsingDeclaration;
 export declare type VariableDeclarator = LetOrConstOrVarDeclarator | UsingDeclarator;
 declare interface VariableDeclaratorBase extends BaseNode {
-    type: AST_NODE_TYPES.VariableDeclarator;
+    /**
+     * Whether there's definite assignment assertion (`let x!: number`).
+     * If `true`, then: `id` must be an identifier with a type annotation,
+     * `init` must be `null`, and the declarator must be a `var`/`let` declarator.
+     */
+    definite: boolean;
     /**
      * The name(s) of the variable(s).
      */
@@ -2093,42 +2098,37 @@ declare interface VariableDeclaratorBase extends BaseNode {
      * in a `declare const`.
      */
     init: Expression | null;
-    /**
-     * 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;
+    type: AST_NODE_TYPES.VariableDeclarator;
 }
 export declare interface VariableDeclaratorDefiniteAssignment extends VariableDeclaratorBase {
+    definite: true;
     /**
      * The name of the variable. Must have a type annotation.
      */
     id: Identifier;
     init: null;
-    definite: true;
 }
 export declare interface VariableDeclaratorMaybeInit extends VariableDeclaratorBase {
     definite: false;
 }
 export declare interface VariableDeclaratorNoInit extends VariableDeclaratorBase {
-    init: null;
     definite: false;
+    init: null;
 }
 export declare interface WhileStatement extends BaseNode {
-    type: AST_NODE_TYPES.WhileStatement;
-    test: Expression;
     body: Statement;
+    test: Expression;
+    type: AST_NODE_TYPES.WhileStatement;
 }
 export declare interface WithStatement extends BaseNode {
-    type: AST_NODE_TYPES.WithStatement;
-    object: Expression;
     body: Statement;
+    object: Expression;
+    type: AST_NODE_TYPES.WithStatement;
 }
 export declare interface YieldExpression extends BaseNode {
-    type: AST_NODE_TYPES.YieldExpression;
-    delegate: boolean;
     argument: Expression | undefined;
+    delegate: boolean;
+    type: AST_NODE_TYPES.YieldExpression;
 }
 export {};
 //# sourceMappingURL=ast-spec.d.ts.map