@swc-next/types 0.0.0 → 0.3.1

package/index.d.ts

@@ -0,0 +1,1610 @@
+// Generated by tasks/ast_tools. Do not edit.
+
+export interface BaseNode {
+  start: number;
+  end: number;
+}
+
+export type SourceType = "module" | "script" | "commonjs" | "unambiguous";
+
+export type Lang = "js" | "ts" | "jsx" | "tsx" | "dts";
+
+export type MethodDefinitionKind = "constructor" | "method" | "get" | "set";
+
+export type Accessibility = null | "public" | "private" | "protected";
+
+export type ClassType = "ClassDeclaration" | "ClassExpression";
+
+export type BinaryOperator =
+  | "=="
+  | "!="
+  | "==="
+  | "!=="
+  | "<"
+  | "<="
+  | ">"
+  | ">="
+  | "+"
+  | "-"
+  | "*"
+  | "/"
+  | "%"
+  | "**"
+  | "|"
+  | "^"
+  | "&"
+  | "<<"
+  | ">>"
+  | ">>>"
+  | "in"
+  | "instanceof";
+
+export type LogicalOperator = "&&" | "||" | "??";
+
+export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+
+export type UpdateOperator = "++" | "--";
+
+export type AssignmentOperator =
+  | "="
+  | "+="
+  | "-="
+  | "*="
+  | "/="
+  | "%="
+  | "**="
+  | "<<="
+  | ">>="
+  | ">>>="
+  | "|="
+  | "^="
+  | "&="
+  | "||="
+  | "&&="
+  | "??=";
+
+export type VariableKind = "var" | "let" | "const" | "using" | "await using";
+
+export type FunctionType = "FunctionDeclaration" | "FunctionExpression";
+
+export type FormalParameterKind = "formal" | "unique" | "arrow" | "signature";
+
+export type PropertyKind = "init" | "get" | "set";
+
+export type ImportOrExportKind = "value" | "type";
+
+export type ImportPhase = "source" | "defer";
+
+export type TSTypeOperatorKind = "keyof" | "unique" | "readonly";
+
+export type TSMethodSignatureKind = "method" | "get" | "set";
+
+export type TSModuleDeclarationKind = "namespace" | "module";
+
+export type TSMappedTypeModifier = null | true | "+" | "-";
+
+export interface Program extends BaseNode {
+  type: "Program";
+  body: Array<Directive | Statement>;
+  hashbang: Hashbang | null;
+  sourceType: SourceType;
+}
+
+export type Statement =
+  | BlockStatement
+  | BreakStatement
+  | ContinueStatement
+  | DebuggerStatement
+  | Declaration
+  | DoWhileStatement
+  | EmptyStatement
+  | ExportAllDeclaration
+  | ExportDefaultDeclaration
+  | ExportNamedDeclaration
+  | ExpressionStatement
+  | ForInStatement
+  | ForOfStatement
+  | ForStatement
+  | IfStatement
+  | ImportDeclaration
+  | LabeledStatement
+  | ReturnStatement
+  | SwitchStatement
+  | TSExportAssignment
+  | TSNamespaceExportDeclaration
+  | ThrowStatement
+  | TryStatement
+  | WhileStatement
+  | WithStatement;
+
+export type Declaration =
+  | ClassDeclaration
+  | FunctionDeclaration
+  | TSDeclareFunction
+  | TSEnumDeclaration
+  | TSGlobalDeclaration
+  | TSImportEqualsDeclaration
+  | TSInterfaceDeclaration
+  | TSModuleDeclaration
+  | TSTypeAliasDeclaration
+  | VariableDeclaration;
+
+export type Expression =
+  | ArrayExpression
+  | ArrowFunctionExpression
+  | AssignmentExpression
+  | AwaitExpression
+  | BigIntLiteral
+  | BinaryExpression
+  | BooleanLiteral
+  | CallExpression
+  | ChainExpression
+  | ClassExpression
+  | ConditionalExpression
+  | FunctionExpression
+  | IdentifierReference
+  | ImportExpression
+  | JSXElement
+  | JSXFragment
+  | LogicalExpression
+  | MemberExpression
+  | MetaProperty
+  | NewExpression
+  | NullLiteral
+  | NumericLiteral
+  | ObjectExpression
+  | ParenthesizedExpression
+  | PrivateIdentifier
+  | RegExpLiteral
+  | SequenceExpression
+  | StringLiteral
+  | Super
+  | TSAsExpression
+  | TSInstantiationExpression
+  | TSNonNullExpression
+  | TSSatisfiesExpression
+  | TSTypeAssertion
+  | TaggedTemplateExpression
+  | TemplateLiteral
+  | ThisExpression
+  | UnaryExpression
+  | UpdateExpression
+  | YieldExpression;
+
+export type Pattern =
+  | ArrayPattern
+  | AssignmentPattern
+  | BindingIdentifier
+  | BindingRestElement
+  | ObjectPattern
+  | SimpleAssignmentTarget;
+
+export type AssignmentTarget = ArrayPattern | ObjectPattern | SimpleAssignmentTarget;
+
+export type SimpleAssignmentTarget =
+  | IdentifierReference
+  | MemberExpression
+  | TSAsExpression
+  | TSNonNullExpression
+  | TSSatisfiesExpression
+  | TSTypeAssertion;
+
+export type PropertyKey = Expression | IdentifierName;
+
+export type ModuleExportName = IdentifierName | StringLiteral;
+
+export type Argument = Expression | SpreadElement;
+
+export type ObjectPropertyKind = ObjectProperty | SpreadElement;
+
+export type ForStatementInit = Expression | VariableDeclaration;
+
+export type ForStatementLeft = AssignmentTarget | VariableDeclaration;
+
+export type ArrowFunctionBody = Expression | FunctionBody;
+
+export type FormalParameterItem = FormalParameter | TSParameterProperty;
+
+export type FormalParameterPattern = ArrayPattern | BindingIdentifier | ObjectPattern;
+
+export type ClassElement =
+  | MethodDefinition
+  | PropertyDefinition
+  | StaticBlock
+  | TSIndexSignature
+  | TSMethodDefinition;
+
+export type ImportDeclarationSpecifier =
+  | ImportDefaultSpecifier
+  | ImportNamespaceSpecifier
+  | ImportSpecifier;
+
+export type ExportDefaultDeclarationKind =
+  | ClassDeclaration
+  | Expression
+  | FunctionDeclaration
+  | TSDeclareFunction
+  | TSInterfaceDeclaration;
+
+export interface Super extends BaseNode {
+  type: "Super";
+}
+
+export interface ThisExpression extends BaseNode {
+  type: "ThisExpression";
+}
+
+export interface StringLiteral extends BaseNode {
+  type: "Literal";
+  value: string;
+  raw: string;
+}
+
+export type Literal = StringLiteral | NumericLiteral | BigIntLiteral | BooleanLiteral | NullLiteral | RegExpLiteral;
+
+export interface NumericLiteral extends BaseNode {
+  type: "Literal";
+  value: number;
+  raw: string;
+}
+
+export interface BigIntLiteral extends BaseNode {
+  type: "Literal";
+  raw: string;
+  value: bigint | null;
+  bigint: string;
+}
+
+export interface BooleanLiteral extends BaseNode {
+  type: "Literal";
+  value: boolean;
+  raw: "false" | "true";
+}
+
+export interface NullLiteral extends BaseNode {
+  type: "Literal";
+  value: null;
+  raw: "null";
+}
+
+export interface RegExpLiteral extends BaseNode {
+  type: "Literal";
+  value: RegExp | null;
+  raw: string;
+  regex: { pattern: string; flags: string };
+}
+
+export interface TemplateLiteral extends BaseNode {
+  type: "TemplateLiteral";
+  quasis: Array<TemplateElement>;
+  expressions: Array<Expression>;
+}
+
+export interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: { raw: string; cooked: string | null };
+}
+
+export type IdentifierReference = Identifier;
+
+export interface PrivateIdentifier extends BaseNode {
+  type: "PrivateIdentifier";
+  name: string;
+}
+
+export type BindingIdentifier = Identifier;
+
+export interface Identifier extends BaseNode {
+  type: "Identifier";
+  name: string;
+  decorators?: Array<Decorator>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation | null;
+}
+
+export type IdentifierName = Identifier;
+
+export type LabelIdentifier = Identifier;
+
+export interface AssignmentPattern extends BaseNode {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+  decorators?: Array<Decorator>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation | null;
+}
+
+export interface BindingRestElement extends BaseNode {
+  type: "RestElement";
+  argument: Pattern;
+  value?: null;
+  decorators?: Array<Decorator>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation | null;
+}
+
+export interface ArrayPattern extends BaseNode {
+  type: "ArrayPattern";
+  elements: Array<Pattern | null>;
+  decorators?: Array<Decorator>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation | null;
+}
+
+export interface ObjectPattern extends BaseNode {
+  type: "ObjectPattern";
+  properties: Array<BindingProperty | BindingRestElement>;
+  decorators?: Array<Decorator>;
+  optional?: boolean;
+  typeAnnotation?: TSTypeAnnotation | null;
+}
+
+export interface BindingProperty extends BaseNode {
+  type: "Property";
+  key: PropertyKey;
+  value: Pattern;
+  shorthand: boolean;
+  computed: boolean;
+  kind: "init";
+  method: false;
+  optional?: false;
+}
+
+export interface BinaryExpression extends BaseNode {
+  type: "BinaryExpression";
+  left: Expression;
+  right: Expression;
+  operator: BinaryOperator;
+}
+
+export interface LogicalExpression extends BaseNode {
+  type: "LogicalExpression";
+  left: Expression;
+  right: Expression;
+  operator: LogicalOperator;
+}
+
+export interface ConditionalExpression extends BaseNode {
+  type: "ConditionalExpression";
+  test: Expression;
+  consequent: Expression;
+  alternate: Expression;
+}
+
+export interface UnaryExpression extends BaseNode {
+  type: "UnaryExpression";
+  argument: Expression;
+  operator: UnaryOperator;
+  prefix: true;
+}
+
+export interface UpdateExpression extends BaseNode {
+  type: "UpdateExpression";
+  argument: SimpleAssignmentTarget;
+  operator: UpdateOperator;
+  prefix: boolean;
+}
+
+export interface AssignmentExpression extends BaseNode {
+  type: "AssignmentExpression";
+  left: AssignmentTarget;
+  right: Expression;
+  operator: AssignmentOperator;
+}
+
+export interface VariableDeclaration extends BaseNode {
+  type: "VariableDeclaration";
+  kind: VariableKind;
+  declarations: Array<VariableDeclarator>;
+  declare?: boolean;
+}
+
+export interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init: Expression | null;
+  definite?: boolean;
+}
+
+export interface IfStatement extends BaseNode {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate: Statement | null;
+}
+
+export interface SwitchStatement extends BaseNode {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: Array<SwitchCase>;
+}
+
+export interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test: Expression | null;
+  consequent: Array<Statement>;
+}
+
+export interface ForStatement extends BaseNode {
+  type: "ForStatement";
+  init: ForStatementInit | null;
+  test: Expression | null;
+  update: Expression | null;
+  body: Statement;
+}
+
+export interface ForInStatement extends BaseNode {
+  type: "ForInStatement";
+  left: ForStatementLeft;
+  right: Expression;
+  body: Statement;
+}
+
+export interface ForOfStatement extends BaseNode {
+  type: "ForOfStatement";
+  left: ForStatementLeft;
+  right: Expression;
+  body: Statement;
+  await: boolean;
+}
+
+export interface TryStatement extends BaseNode {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler: CatchClause | null;
+  finalizer: BlockStatement | null;
+}
+
+export interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern | null;
+  body: BlockStatement;
+}
+
+export interface BreakStatement extends BaseNode {
+  type: "BreakStatement";
+  label: LabelIdentifier | null;
+}
+
+export interface ContinueStatement extends BaseNode {
+  type: "ContinueStatement";
+  label: LabelIdentifier | null;
+}
+
+export interface LabeledStatement extends BaseNode {
+  type: "LabeledStatement";
+  label: LabelIdentifier;
+  body: Statement;
+}
+
+export interface ExpressionStatement extends BaseNode {
+  type: "ExpressionStatement";
+  expression: Expression;
+  directive?: string | null;
+}
+
+export interface ReturnStatement extends BaseNode {
+  type: "ReturnStatement";
+  argument: Expression | null;
+}
+
+export interface ThrowStatement extends BaseNode {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+
+export interface DebuggerStatement extends BaseNode {
+  type: "DebuggerStatement";
+}
+
+export interface EmptyStatement extends BaseNode {
+  type: "EmptyStatement";
+}
+
+export interface Directive extends BaseNode {
+  type: "ExpressionStatement";
+  expression: StringLiteral;
+  directive: string;
+}
+
+export interface Decorator extends BaseNode {
+  type: "Decorator";
+  expression: Expression;
+}
+
+export interface Class extends BaseNode {
+  type: ClassType;
+  decorators: Array<Decorator>;
+  id: BindingIdentifier | null;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  superClass: Expression | null;
+  superTypeArguments?: TSTypeParameterInstantiation | null;
+  implements?: Array<TSClassImplements>;
+  body: ClassBody;
+  abstract?: boolean;
+  declare?: boolean;
+}
+
+export type ClassDeclaration = Class & { type: "ClassDeclaration" };
+export type ClassExpression = Class & { type: "ClassExpression" };
+
+export interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<ClassElement>;
+}
+
+export interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition" | "TSAbstractMethodDefinition";
+  decorators: Array<Decorator>;
+  key: PropertyKey;
+  value: FunctionExpression;
+  kind: MethodDefinitionKind;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  optional?: boolean;
+  accessibility?: Accessibility;
+}
+
+export interface PropertyDefinition extends BaseNode {
+  type: "PropertyDefinition" | "AccessorProperty" | "TSAbstractPropertyDefinition" | "TSAbstractAccessorProperty";
+  decorators: Array<Decorator>;
+  key: PropertyKey;
+  typeAnnotation?: TSTypeAnnotation | null;
+  value: Expression | null;
+  computed: boolean;
+  static: boolean;
+  declare?: boolean;
+  override?: boolean;
+  optional?: boolean;
+  definite?: boolean;
+  readonly?: boolean;
+  accessibility?: Accessibility;
+}
+
+export interface StaticBlock extends BaseNode {
+  type: "StaticBlock";
+  body: Array<Statement>;
+}
+
+export interface Function extends BaseNode {
+  type: FunctionType;
+  id: BindingIdentifier | null;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FormalParameters;
+  returnType?: TSTypeAnnotation | null;
+  body: FunctionBody;
+  generator: boolean;
+  async: boolean;
+  expression: false;
+  declare?: false;
+}
+
+export type FunctionDeclaration = Function & { type: "FunctionDeclaration" };
+export type FunctionExpression = Function & { type: "FunctionExpression" };
+
+export type FunctionBody = BlockStatement;
+
+export interface BlockStatement extends BaseNode {
+  type: "BlockStatement";
+  body: Array<Statement>;
+}
+
+export interface WhileStatement extends BaseNode {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+
+export interface DoWhileStatement extends BaseNode {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+
+export interface WithStatement extends BaseNode {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+
+export type FormalParameters = Array<FormalParameterItem | FormalParameterRest | TSThisParameter>;
+
+export type FormalParameter = FormalParameterPattern | (AssignmentPattern & { left: FormalParameterPattern });
+
+export type FormalParameterRest = BindingRestElement & { argument: FormalParameterPattern };
+
+export interface ArrayExpression extends BaseNode {
+  type: "ArrayExpression";
+  elements: Array<Argument | null>;
+}
+
+export interface ObjectExpression extends BaseNode {
+  type: "ObjectExpression";
+  properties: Array<ObjectPropertyKind>;
+}
+
+export interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+
+export interface ObjectProperty extends BaseNode {
+  type: "Property";
+  key: PropertyKey;
+  value: Expression;
+  kind: PropertyKind;
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+  optional?: false;
+}
+
+export interface ParenthesizedExpression extends BaseNode {
+  type: "ParenthesizedExpression";
+  expression: Expression;
+}
+
+export interface ArrowFunctionExpression extends BaseNode {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  async: boolean;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FormalParameters;
+  returnType?: TSTypeAnnotation | null;
+  body: ArrowFunctionBody;
+  id: null;
+  generator: false;
+}
+
+export interface SequenceExpression extends BaseNode {
+  type: "SequenceExpression";
+  expressions: Array<Expression>;
+}
+
+export interface MemberExpression extends BaseNode {
+  type: "MemberExpression";
+  object: Expression;
+  property: PropertyKey;
+  computed: boolean;
+  optional: boolean;
+}
+
+export interface CallExpression extends BaseNode {
+  type: "CallExpression";
+  callee: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  arguments: Array<Argument>;
+  optional: boolean;
+}
+
+export interface ChainExpression extends BaseNode {
+  type: "ChainExpression";
+  expression: CallExpression | MemberExpression | TSNonNullExpression | TSInstantiationExpression;
+}
+
+export interface TaggedTemplateExpression extends BaseNode {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  quasi: TemplateLiteral;
+}
+
+export interface NewExpression extends BaseNode {
+  type: "NewExpression";
+  callee: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  arguments: Array<Argument>;
+}
+
+export interface AwaitExpression extends BaseNode {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+
+export interface YieldExpression extends BaseNode {
+  type: "YieldExpression";
+  argument: Expression | null;
+  delegate: boolean;
+}
+
+export interface MetaProperty extends BaseNode {
+  type: "MetaProperty";
+  meta: IdentifierName;
+  property: IdentifierName;
+}
+
+export interface ImportExpression extends BaseNode {
+  type: "ImportExpression";
+  source: Expression;
+  options: Expression | null;
+  phase: ImportPhase | null;
+}
+
+export interface ImportDeclaration extends BaseNode {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportDeclarationSpecifier>;
+  source: StringLiteral;
+  attributes: Array<ImportAttribute>;
+  phase: ImportPhase | null;
+  importKind?: ImportOrExportKind;
+}
+
+export interface ImportSpecifier extends BaseNode {
+  type: "ImportSpecifier";
+  imported: ModuleExportName;
+  local: BindingIdentifier;
+  importKind?: ImportOrExportKind;
+}
+
+export interface ImportDefaultSpecifier extends BaseNode {
+  type: "ImportDefaultSpecifier";
+  local: BindingIdentifier;
+}
+
+export interface ImportNamespaceSpecifier extends BaseNode {
+  type: "ImportNamespaceSpecifier";
+  local: BindingIdentifier;
+}
+
+export interface ImportAttribute extends BaseNode {
+  type: "ImportAttribute";
+  key: ModuleExportName;
+  value: StringLiteral;
+}
+
+export interface ExportNamedDeclaration extends BaseNode {
+  type: "ExportNamedDeclaration";
+  declaration: Declaration | null;
+  specifiers: Array<ExportSpecifier>;
+  source: StringLiteral | null;
+  attributes: Array<ImportAttribute>;
+  exportKind?: ImportOrExportKind;
+}
+
+export interface ExportDefaultDeclaration extends BaseNode {
+  type: "ExportDefaultDeclaration";
+  declaration: ExportDefaultDeclarationKind;
+  exportKind?: "value";
+}
+
+export interface ExportAllDeclaration extends BaseNode {
+  type: "ExportAllDeclaration";
+  exported: ModuleExportName | null;
+  source: StringLiteral;
+  attributes: Array<ImportAttribute>;
+  exportKind?: ImportOrExportKind;
+}
+
+export interface ExportSpecifier extends BaseNode {
+  type: "ExportSpecifier";
+  local: ModuleExportName;
+  exported: ModuleExportName;
+  exportKind?: ImportOrExportKind;
+}
+
+export interface Hashbang extends BaseNode {
+  type: "Hashbang";
+  value: string;
+}
+
+export type TSType =
+  | TSAnyKeyword
+  | TSArrayType
+  | TSBigIntKeyword
+  | TSBooleanKeyword
+  | TSConditionalType
+  | TSConstructorType
+  | TSFunctionType
+  | TSImportType
+  | TSIndexedAccessType
+  | TSInferType
+  | TSIntersectionType
+  | TSIntrinsicKeyword
+  | TSJSDocNonNullableType
+  | TSJSDocNullableType
+  | TSJSDocUnknownType
+  | TSLiteralType
+  | TSMappedType
+  | TSNeverKeyword
+  | TSNullKeyword
+  | TSNumberKeyword
+  | TSObjectKeyword
+  | TSOptionalType
+  | TSParenthesizedType
+  | TSRestType
+  | TSStringKeyword
+  | TSSymbolKeyword
+  | TSTemplateLiteralType
+  | TSThisType
+  | TSTupleType
+  | TSTypeLiteral
+  | TSTypeOperator
+  | TSTypePredicate
+  | TSTypeQuery
+  | TSTypeReference
+  | TSUndefinedKeyword
+  | TSUnionType
+  | TSUnknownKeyword
+  | TSVoidKeyword;
+
+export type TSTypeName = IdentifierReference | TSQualifiedName;
+
+export type TSQualifiedNameLeft =
+  | BindingIdentifier
+  | IdentifierName
+  | IdentifierReference
+  | TSQualifiedName
+  | ThisExpression;
+
+export type TSImportTypeQualifier = IdentifierName | TSQualifiedName;
+
+export type TSTypeQueryExprName = TSImportType | TSTypeName | ThisExpression;
+
+export type TSLiteral =
+  | BigIntLiteral
+  | BooleanLiteral
+  | NumericLiteral
+  | StringLiteral
+  | TemplateLiteral
+  | UnaryExpression & { operator: "+" | "-" };
+
+export type TSTupleElement = TSNamedTupleMember | TSType;
+
+export type TSTypeElement =
+  | TSCallSignatureDeclaration
+  | TSConstructSignatureDeclaration
+  | TSIndexSignature
+  | TSMethodSignature
+  | TSPropertySignature;
+
+export type TSTypePredicateName = IdentifierName | TSThisType;
+
+export type TSEnumMemberName = IdentifierName | StringLiteral | TemplateLiteral;
+
+export type TSModuleName = BindingIdentifier | StringLiteral | TSQualifiedName;
+
+export type TSModuleBody = TSModuleBlock | TSModuleDeclaration;
+
+export type TSModuleReference = TSExternalModuleReference | TSTypeName;
+
+export interface TSFunction extends BaseNode {
+  type: "TSDeclareFunction" | "TSEmptyBodyFunctionExpression";
+  id: BindingIdentifier | null;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FormalParameters;
+  returnType?: TSTypeAnnotation | null;
+  generator: boolean;
+  async: boolean;
+  declare: boolean;
+  body?: null;
+  expression: false;
+}
+
+export type TSDeclareFunction = TSFunction & { type: "TSDeclareFunction" };
+export type TSEmptyBodyFunctionExpression = TSFunction & { type: "TSEmptyBodyFunctionExpression" };
+
+export interface TSMethodDefinition extends BaseNode {
+  type: "MethodDefinition" | "TSAbstractMethodDefinition";
+  decorators: Array<Decorator>;
+  key: PropertyKey;
+  value: TSEmptyBodyFunctionExpression;
+  kind: MethodDefinitionKind;
+  computed: boolean;
+  static: boolean;
+  override?: boolean;
+  optional?: boolean;
+  accessibility?: Accessibility;
+}
+
+export interface TSTypeAnnotation extends BaseNode {
+  type: "TSTypeAnnotation";
+  typeAnnotation: TSType;
+}
+
+export interface TSAnyKeyword extends BaseNode {
+  type: "TSAnyKeyword";
+}
+
+export interface TSUnknownKeyword extends BaseNode {
+  type: "TSUnknownKeyword";
+}
+
+export interface TSNeverKeyword extends BaseNode {
+  type: "TSNeverKeyword";
+}
+
+export interface TSVoidKeyword extends BaseNode {
+  type: "TSVoidKeyword";
+}
+
+export interface TSNullKeyword extends BaseNode {
+  type: "TSNullKeyword";
+}
+
+export interface TSUndefinedKeyword extends BaseNode {
+  type: "TSUndefinedKeyword";
+}
+
+export interface TSStringKeyword extends BaseNode {
+  type: "TSStringKeyword";
+}
+
+export interface TSNumberKeyword extends BaseNode {
+  type: "TSNumberKeyword";
+}
+
+export interface TSBigIntKeyword extends BaseNode {
+  type: "TSBigIntKeyword";
+}
+
+export interface TSBooleanKeyword extends BaseNode {
+  type: "TSBooleanKeyword";
+}
+
+export interface TSSymbolKeyword extends BaseNode {
+  type: "TSSymbolKeyword";
+}
+
+export interface TSObjectKeyword extends BaseNode {
+  type: "TSObjectKeyword";
+}
+
+export interface TSIntrinsicKeyword extends BaseNode {
+  type: "TSIntrinsicKeyword";
+}
+
+export interface TSThisType extends BaseNode {
+  type: "TSThisType";
+}
+
+export interface TSTypeReference extends BaseNode {
+  type: "TSTypeReference";
+  typeName: TSTypeName;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+
+export interface TSQualifiedName extends BaseNode {
+  type: "TSQualifiedName";
+  left: TSQualifiedNameLeft;
+  right: IdentifierName;
+}
+
+export interface TSTypeQuery extends BaseNode {
+  type: "TSTypeQuery";
+  exprName: TSTypeQueryExprName;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+
+export interface TSImportType extends BaseNode {
+  type: "TSImportType";
+  source: StringLiteral;
+  options: Expression | null;
+  qualifier: TSImportTypeQualifier | null;
+  typeArguments: TSTypeParameterInstantiation | null;
+}
+
+export interface TSTypeParameter extends BaseNode {
+  type: "TSTypeParameter";
+  name: BindingIdentifier;
+  constraint?: TSType | null;
+  default?: TSType | null;
+  in: boolean;
+  out: boolean;
+  const: boolean;
+}
+
+export interface TSTypeParameterDeclaration extends BaseNode {
+  type: "TSTypeParameterDeclaration";
+  params: Array<TSTypeParameter>;
+}
+
+export interface TSTypeParameterInstantiation extends BaseNode {
+  type: "TSTypeParameterInstantiation";
+  params: Array<TSType>;
+}
+
+export interface TSLiteralType extends BaseNode {
+  type: "TSLiteralType";
+  literal: TSLiteral;
+}
+
+export interface TSTemplateLiteralType extends BaseNode {
+  type: "TSTemplateLiteralType";
+  quasis: Array<TemplateElement>;
+  types: Array<TSType>;
+}
+
+export interface TSArrayType extends BaseNode {
+  type: "TSArrayType";
+  elementType: TSType;
+}
+
+export interface TSIndexedAccessType extends BaseNode {
+  type: "TSIndexedAccessType";
+  objectType: TSType;
+  indexType: TSType;
+}
+
+export interface TSTupleType extends BaseNode {
+  type: "TSTupleType";
+  elementTypes: Array<TSTupleElement>;
+}
+
+export interface TSNamedTupleMember extends BaseNode {
+  type: "TSNamedTupleMember";
+  label: IdentifierName;
+  elementType: TSType;
+  optional: boolean;
+}
+
+export interface TSOptionalType extends BaseNode {
+  type: "TSOptionalType";
+  typeAnnotation: TSType;
+}
+
+export interface TSRestType extends BaseNode {
+  type: "TSRestType";
+  typeAnnotation: TSTupleElement;
+}
+
+export interface TSJSDocNullableType extends BaseNode {
+  type: "TSJSDocNullableType";
+  typeAnnotation: TSType;
+  postfix: boolean;
+}
+
+export interface TSJSDocNonNullableType extends BaseNode {
+  type: "TSJSDocNonNullableType";
+  typeAnnotation: TSType;
+  postfix: boolean;
+}
+
+export interface TSJSDocUnknownType extends BaseNode {
+  type: "TSJSDocUnknownType";
+}
+
+export interface TSUnionType extends BaseNode {
+  type: "TSUnionType";
+  types: Array<TSType>;
+}
+
+export interface TSIntersectionType extends BaseNode {
+  type: "TSIntersectionType";
+  types: Array<TSType>;
+}
+
+export interface TSConditionalType extends BaseNode {
+  type: "TSConditionalType";
+  checkType: TSType;
+  extendsType: TSType;
+  trueType: TSType;
+  falseType: TSType;
+}
+
+export interface TSInferType extends BaseNode {
+  type: "TSInferType";
+  typeParameter: TSTypeParameter;
+}
+
+export interface TSTypeOperator extends BaseNode {
+  type: "TSTypeOperator";
+  operator: TSTypeOperatorKind;
+  typeAnnotation: TSType;
+}
+
+export interface TSParenthesizedType extends BaseNode {
+  type: "TSParenthesizedType";
+  typeAnnotation: TSType;
+}
+
+export interface TSFunctionType extends BaseNode {
+  type: "TSFunctionType";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FormalParameters;
+  returnType: TSTypeAnnotation;
+}
+
+export interface TSConstructorType extends BaseNode {
+  type: "TSConstructorType";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FormalParameters;
+  returnType: TSTypeAnnotation;
+  abstract: boolean;
+}
+
+export interface TSTypePredicate extends BaseNode {
+  type: "TSTypePredicate";
+  parameterName: TSTypePredicateName;
+  typeAnnotation: TSTypeAnnotation | null;
+  asserts: boolean;
+}
+
+export interface TSTypeLiteral extends BaseNode {
+  type: "TSTypeLiteral";
+  members: Array<TSTypeElement>;
+}
+
+export interface TSMappedType extends BaseNode {
+  type: "TSMappedType";
+  key: BindingIdentifier;
+  constraint: TSType;
+  nameType: TSType | null;
+  typeAnnotation?: TSType | null;
+  optional?: boolean | "+" | "-";
+  readonly?: TSMappedTypeModifier | false;
+}
+
+export interface TSPropertySignature extends BaseNode {
+  type: "TSPropertySignature";
+  key: PropertyKey;
+  typeAnnotation?: TSTypeAnnotation | null;
+  computed: boolean;
+  optional: boolean;
+  readonly: boolean;
+  accessibility?: null;
+  static?: false;
+}
+
+export interface TSMethodSignature extends BaseNode {
+  type: "TSMethodSignature";
+  key: PropertyKey;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FormalParameters;
+  returnType?: TSTypeAnnotation | null;
+  kind: TSMethodSignatureKind;
+  computed: boolean;
+  optional: boolean;
+  accessibility?: null;
+  readonly: false;
+  static: false;
+}
+
+export interface TSCallSignatureDeclaration extends BaseNode {
+  type: "TSCallSignatureDeclaration";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FormalParameters;
+  returnType?: TSTypeAnnotation | null;
+}
+
+export interface TSConstructSignatureDeclaration extends BaseNode {
+  type: "TSConstructSignatureDeclaration";
+  typeParameters?: TSTypeParameterDeclaration | null;
+  params: FormalParameters;
+  returnType?: TSTypeAnnotation | null;
+}
+
+export interface TSIndexSignature extends BaseNode {
+  type: "TSIndexSignature";
+  parameters: Array<TSIndexSignatureParameter>;
+  typeAnnotation: TSTypeAnnotation;
+  readonly: boolean;
+  static?: boolean;
+  accessibility?: null;
+}
+
+export interface TSTypeAliasDeclaration extends BaseNode {
+  type: "TSTypeAliasDeclaration";
+  id: BindingIdentifier;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  typeAnnotation: TSType;
+  declare: boolean;
+}
+
+export interface TSInterfaceDeclaration extends BaseNode {
+  type: "TSInterfaceDeclaration";
+  id: BindingIdentifier;
+  typeParameters?: TSTypeParameterDeclaration | null;
+  extends: Array<TSInterfaceHeritage>;
+  body: TSInterfaceBody;
+  declare: boolean;
+}
+
+export interface TSInterfaceBody extends BaseNode {
+  type: "TSInterfaceBody";
+  body: Array<TSTypeElement>;
+}
+
+export interface TSInterfaceHeritage extends BaseNode {
+  type: "TSInterfaceHeritage";
+  expression: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+
+export interface TSClassImplements extends BaseNode {
+  type: "TSClassImplements";
+  expression: Expression;
+  typeArguments?: TSTypeParameterInstantiation | null;
+}
+
+export interface TSEnumDeclaration extends BaseNode {
+  type: "TSEnumDeclaration";
+  id: BindingIdentifier;
+  body: TSEnumBody;
+  const: boolean;
+  declare: boolean;
+}
+
+export interface TSEnumBody extends BaseNode {
+  type: "TSEnumBody";
+  members: Array<TSEnumMember>;
+}
+
+export interface TSEnumMember extends BaseNode {
+  type: "TSEnumMember";
+  id: TSEnumMemberName;
+  initializer?: Expression | null;
+  computed: boolean;
+}
+
+export interface TSModuleDeclaration extends BaseNode {
+  type: "TSModuleDeclaration";
+  id: TSModuleName;
+  body?: TSModuleBody | null;
+  kind: TSModuleDeclarationKind;
+  declare: boolean;
+  global: false;
+}
+
+export interface TSModuleBlock extends BaseNode {
+  type: "TSModuleBlock";
+  body: Array<Directive | Statement>;
+}
+
+export interface TSGlobalDeclaration extends BaseNode {
+  type: "TSModuleDeclaration";
+  id: IdentifierName;
+  body: TSModuleBlock;
+  declare: boolean;
+  kind: "global";
+  global: true;
+}
+
+export interface TSParameterProperty extends BaseNode {
+  type: "TSParameterProperty";
+  decorators: Array<Decorator>;
+  parameter: FormalParameter;
+  override: boolean;
+  readonly: boolean;
+  accessibility: Accessibility;
+  static?: false;
+}
+
+export interface TSThisParameter extends BaseNode {
+  type: "Identifier";
+  typeAnnotation?: TSTypeAnnotation | null;
+  decorators?: Array<Decorator>;
+  name: "this";
+  optional: false;
+}
+
+export interface TSAsExpression extends BaseNode {
+  type: "TSAsExpression";
+  expression: Expression;
+  typeAnnotation: TSType;
+}
+
+export interface TSSatisfiesExpression extends BaseNode {
+  type: "TSSatisfiesExpression";
+  expression: Expression;
+  typeAnnotation: TSType;
+}
+
+export interface TSTypeAssertion extends BaseNode {
+  type: "TSTypeAssertion";
+  typeAnnotation: TSType;
+  expression: Expression;
+}
+
+export interface TSNonNullExpression extends BaseNode {
+  type: "TSNonNullExpression";
+  expression: Expression;
+}
+
+export interface TSInstantiationExpression extends BaseNode {
+  type: "TSInstantiationExpression";
+  expression: Expression;
+  typeArguments: TSTypeParameterInstantiation;
+}
+
+export interface TSExportAssignment extends BaseNode {
+  type: "TSExportAssignment";
+  expression: Expression;
+}
+
+export interface TSNamespaceExportDeclaration extends BaseNode {
+  type: "TSNamespaceExportDeclaration";
+  id: IdentifierName;
+}
+
+export interface TSImportEqualsDeclaration extends BaseNode {
+  type: "TSImportEqualsDeclaration";
+  id: BindingIdentifier;
+  moduleReference: TSModuleReference;
+  importKind: ImportOrExportKind;
+}
+
+export interface TSExternalModuleReference extends BaseNode {
+  type: "TSExternalModuleReference";
+  expression: StringLiteral;
+}
+
+export type TSIndexSignatureParameter = Identifier & { typeAnnotation: TSTypeAnnotation };
+
+export type JSXElementName = JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+
+export type JSXMemberExpressionObject = JSXIdentifier | JSXMemberExpression;
+
+export type JSXAttributeName = JSXIdentifier | JSXNamespacedName;
+
+export type JSXAttributeItem = JSXAttribute | JSXSpreadAttribute;
+
+export type JSXAttributeValue =
+  | JSXElement
+  | JSXExpressionContainer
+  | JSXFragment
+  | StringLiteral;
+
+export type JSXExpression = Expression | JSXEmptyExpression;
+
+export type JSXChild =
+  | JSXElement
+  | JSXExpressionContainer
+  | JSXFragment
+  | JSXSpreadChild
+  | JSXText;
+
+export interface JSXElement extends BaseNode {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement;
+  children: Array<JSXChild>;
+  closingElement: JSXClosingElement | null;
+}
+
+export interface JSXOpeningElement extends BaseNode {
+  type: "JSXOpeningElement";
+  name: JSXElementName;
+  typeArguments?: TSTypeParameterInstantiation | null;
+  attributes: Array<JSXAttributeItem>;
+  selfClosing: boolean;
+}
+
+export interface JSXClosingElement extends BaseNode {
+  type: "JSXClosingElement";
+  name: JSXElementName;
+}
+
+export interface JSXFragment extends BaseNode {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  children: Array<JSXChild>;
+  closingFragment: JSXClosingFragment;
+}
+
+export interface JSXOpeningFragment extends BaseNode {
+  type: "JSXOpeningFragment";
+}
+
+export interface JSXClosingFragment extends BaseNode {
+  type: "JSXClosingFragment";
+}
+
+export interface JSXIdentifier extends BaseNode {
+  type: "JSXIdentifier";
+  name: string;
+}
+
+export interface JSXNamespacedName extends BaseNode {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier;
+  name: JSXIdentifier;
+}
+
+export interface JSXMemberExpression extends BaseNode {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpressionObject;
+  property: JSXIdentifier;
+}
+
+export interface JSXAttribute extends BaseNode {
+  type: "JSXAttribute";
+  name: JSXAttributeName;
+  value: JSXAttributeValue | null;
+}
+
+export interface JSXSpreadAttribute extends BaseNode {
+  type: "JSXSpreadAttribute";
+  argument: Expression;
+}
+
+export interface JSXExpressionContainer extends BaseNode {
+  type: "JSXExpressionContainer";
+  expression: JSXExpression;
+}
+
+export interface JSXEmptyExpression extends BaseNode {
+  type: "JSXEmptyExpression";
+}
+
+export interface JSXText extends BaseNode {
+  type: "JSXText";
+  value: string;
+  raw: string;
+}
+
+export interface JSXSpreadChild extends BaseNode {
+  type: "JSXSpreadChild";
+  expression: Expression;
+}
+
+export type Node =
+  | ArrayExpression
+  | ArrayPattern
+  | ArrowFunctionExpression
+  | AssignmentExpression
+  | AssignmentPattern
+  | AwaitExpression
+  | BigIntLiteral
+  | BinaryExpression
+  | BindingProperty
+  | BindingRestElement
+  | BlockStatement
+  | BooleanLiteral
+  | BreakStatement
+  | CallExpression
+  | CatchClause
+  | ChainExpression
+  | Class
+  | ClassBody
+  | ConditionalExpression
+  | ContinueStatement
+  | DebuggerStatement
+  | Decorator
+  | Directive
+  | DoWhileStatement
+  | EmptyStatement
+  | ExportAllDeclaration
+  | ExportDefaultDeclaration
+  | ExportNamedDeclaration
+  | ExportSpecifier
+  | ExpressionStatement
+  | ForInStatement
+  | ForOfStatement
+  | ForStatement
+  | Function
+  | Hashbang
+  | Identifier
+  | IfStatement
+  | ImportAttribute
+  | ImportDeclaration
+  | ImportDefaultSpecifier
+  | ImportExpression
+  | ImportNamespaceSpecifier
+  | ImportSpecifier
+  | JSXAttribute
+  | JSXClosingElement
+  | JSXClosingFragment
+  | JSXElement
+  | JSXEmptyExpression
+  | JSXExpressionContainer
+  | JSXFragment
+  | JSXIdentifier
+  | JSXMemberExpression
+  | JSXNamespacedName
+  | JSXOpeningElement
+  | JSXOpeningFragment
+  | JSXSpreadAttribute
+  | JSXSpreadChild
+  | JSXText
+  | LabeledStatement
+  | LogicalExpression
+  | MemberExpression
+  | MetaProperty
+  | MethodDefinition
+  | NewExpression
+  | NullLiteral
+  | NumericLiteral
+  | ObjectExpression
+  | ObjectPattern
+  | ObjectProperty
+  | ParenthesizedExpression
+  | PrivateIdentifier
+  | Program
+  | PropertyDefinition
+  | RegExpLiteral
+  | ReturnStatement
+  | SequenceExpression
+  | SpreadElement
+  | StaticBlock
+  | StringLiteral
+  | Super
+  | SwitchCase
+  | SwitchStatement
+  | TSAnyKeyword
+  | TSArrayType
+  | TSAsExpression
+  | TSBigIntKeyword
+  | TSBooleanKeyword
+  | TSCallSignatureDeclaration
+  | TSClassImplements
+  | TSConditionalType
+  | TSConstructSignatureDeclaration
+  | TSConstructorType
+  | TSEnumBody
+  | TSEnumDeclaration
+  | TSEnumMember
+  | TSExportAssignment
+  | TSExternalModuleReference
+  | TSFunction
+  | TSFunctionType
+  | TSGlobalDeclaration
+  | TSImportEqualsDeclaration
+  | TSImportType
+  | TSIndexSignature
+  | TSIndexedAccessType
+  | TSInferType
+  | TSInstantiationExpression
+  | TSInterfaceBody
+  | TSInterfaceDeclaration
+  | TSInterfaceHeritage
+  | TSIntersectionType
+  | TSIntrinsicKeyword
+  | TSJSDocNonNullableType
+  | TSJSDocNullableType
+  | TSJSDocUnknownType
+  | TSLiteralType
+  | TSMappedType
+  | TSMethodDefinition
+  | TSMethodSignature
+  | TSModuleBlock
+  | TSModuleDeclaration
+  | TSNamedTupleMember
+  | TSNamespaceExportDeclaration
+  | TSNeverKeyword
+  | TSNonNullExpression
+  | TSNullKeyword
+  | TSNumberKeyword
+  | TSObjectKeyword
+  | TSOptionalType
+  | TSParameterProperty
+  | TSParenthesizedType
+  | TSPropertySignature
+  | TSQualifiedName
+  | TSRestType
+  | TSSatisfiesExpression
+  | TSStringKeyword
+  | TSSymbolKeyword
+  | TSTemplateLiteralType
+  | TSThisParameter
+  | TSThisType
+  | TSTupleType
+  | TSTypeAliasDeclaration
+  | TSTypeAnnotation
+  | TSTypeAssertion
+  | TSTypeLiteral
+  | TSTypeOperator
+  | TSTypeParameter
+  | TSTypeParameterDeclaration
+  | TSTypeParameterInstantiation
+  | TSTypePredicate
+  | TSTypeQuery
+  | TSTypeReference
+  | TSUndefinedKeyword
+  | TSUnionType
+  | TSUnknownKeyword
+  | TSVoidKeyword
+  | TaggedTemplateExpression
+  | TemplateElement
+  | TemplateLiteral
+  | ThisExpression
+  | ThrowStatement
+  | TryStatement
+  | UnaryExpression
+  | UpdateExpression
+  | VariableDeclaration
+  | VariableDeclarator
+  | WhileStatement
+  | WithStatement
+  | YieldExpression;