@swc/core 1.2.212 → 1.2.218

package/types.d.ts

@@ -874,29 +874,31 @@ export interface HasDecorator {
 export interface Class extends HasSpan, HasDecorator {
     body: ClassMember[];
     superClass?: Expression;
-    is_abstract: boolean;
-    typeParams: TsTypeParameterDeclaration;
+    isAbstract: boolean;
+    typeParams?: TsTypeParameterDeclaration;
     superTypeParams?: TsTypeParameterInstantiation;
     implements: TsExpressionWithTypeArguments[];
 }
-export declare type ClassMember = Constructor | ClassMethod | PrivateMethod | ClassProperty | PrivateProperty | TsIndexSignature;
+export declare type ClassMember = Constructor | ClassMethod | PrivateMethod | ClassProperty | PrivateProperty | TsIndexSignature | EmptyStatement | StaticBlock;
 export interface ClassPropertyBase extends Node, HasSpan, HasDecorator {
     value?: Expression;
     typeAnnotation?: TsTypeAnnotation;
-    is_static: boolean;
+    isStatic: boolean;
     accessibility?: Accessibility;
-    is_optional: boolean;
+    isOptional: boolean;
+    isOverride: boolean;
     readonly: boolean;
+    definite: boolean;
 }
 export interface ClassProperty extends ClassPropertyBase {
     type: "ClassProperty";
     key: PropertyName;
+    isAbstract: boolean;
+    declare: boolean;
 }
 export interface PrivateProperty extends ClassPropertyBase {
     type: "PrivateProperty";
     key: PrivateName;
-    is_abstract: boolean;
-    definite: boolean;
 }
 export interface Param extends Node, HasSpan, HasDecorator {
     type: "Parameter";
@@ -905,18 +907,19 @@ export interface Param extends Node, HasSpan, HasDecorator {
 export interface Constructor extends Node, HasSpan {
     type: "Constructor";
     key: PropertyName;
-    params: (Param | TsParameterProperty)[];
-    body: BlockStatement;
+    params: (TsParameterProperty | Param)[];
+    body?: BlockStatement;
     accessibility?: Accessibility;
-    is_optional: boolean;
+    isOptional: boolean;
 }
 export interface ClassMethodBase extends Node, HasSpan {
     function: Fn;
     kind: MethodKind;
-    is_static: boolean;
+    isStatic: boolean;
     accessibility?: Accessibility;
-    is_abstract: boolean;
-    is_optional: boolean;
+    isAbstract: boolean;
+    isOptional: boolean;
+    isOverride: boolean;
 }
 export interface ClassMethod extends ClassMethodBase {
     type: "ClassMethod";
@@ -926,11 +929,15 @@ export interface PrivateMethod extends ClassMethodBase {
     type: "PrivateMethod";
     key: PrivateName;
 }
+export interface StaticBlock extends Node, HasSpan {
+    type: "StaticBlock";
+    body: BlockStatement;
+}
 export interface Decorator extends Node, HasSpan {
     type: "Decorator";
     expression: Expression;
 }
-export declare type MethodKind = "method" | "setter" | "getter";
+export declare type MethodKind = "method" | "getter" | "setter";
 export declare type Declaration = ClassDeclaration | FunctionDeclaration | VariableDeclaration | TsInterfaceDeclaration | TsTypeAliasDeclaration | TsEnumDeclaration | TsModuleDeclaration;
 export interface FunctionDeclaration extends Fn {
     type: "FunctionDeclaration";
@@ -955,15 +962,27 @@ export interface VariableDeclarator extends Node, HasSpan {
     init?: Expression;
     definite: boolean;
 }
-export declare type Expression = ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression | UnaryExpression | UpdateExpression | BinaryExpression | AssignmentExpression | MemberExpression | SuperPropExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier | Literal | TemplateLiteral | TaggedTemplateExpression | ArrowFunctionExpression | ClassExpression | YieldExpression | MetaProperty | AwaitExpression | ParenthesisExpression | JSXMemberExpression | JSXNamespacedName | JSXEmptyExpression | JSXElement | JSXFragment | TsTypeAssertion | TsConstAssertion | TsNonNullExpression | TsAsExpression | PrivateName | OptionalChainingExpression | Invalid;
+export declare type Expression = ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression | UnaryExpression | UpdateExpression | BinaryExpression | AssignmentExpression | MemberExpression | SuperPropExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | Identifier | Literal | TemplateLiteral | TaggedTemplateExpression | ArrowFunctionExpression | ClassExpression | YieldExpression | MetaProperty | AwaitExpression | ParenthesisExpression | JSXMemberExpression | JSXNamespacedName | JSXEmptyExpression | JSXElement | JSXFragment | TsTypeAssertion | TsConstAssertion | TsNonNullExpression | TsAsExpression | TsInstantiation | PrivateName | OptionalChainingExpression | Invalid;
 interface ExpressionBase extends Node, HasSpan {
 }
+export interface Identifier extends ExpressionBase {
+    type: "Identifier";
+    value: string;
+    optional: boolean;
+}
 export interface OptionalChainingExpression extends ExpressionBase {
     type: "OptionalChainingExpression";
+    questionDotToken: Span;
     /**
      * Call expression or member expression.
      */
-    base: Expression;
+    base: MemberExpression | OptionalChainingCall;
+}
+export interface OptionalChainingCall extends ExpressionBase {
+    type: "CallExpression";
+    callee: Expression;
+    arguments: ExprOrSpread[];
+    typeArguments?: TsTypeParameterInstantiation;
 }
 export interface ThisExpression extends ExpressionBase {
     type: "ThisExpression";
@@ -978,13 +997,12 @@ export interface ExprOrSpread {
 }
 export interface ObjectExpression extends ExpressionBase {
     type: "ObjectExpression";
-    properties: (Property | SpreadElement)[];
+    properties: (SpreadElement | Property)[];
 }
 export interface Argument {
     spread?: Span;
     expression: Expression;
 }
-export declare type PropertOrSpread = Property | SpreadElement;
 export interface SpreadElement extends Node {
     type: "SpreadElement";
     spread: Span;
@@ -1009,16 +1027,16 @@ export interface BinaryExpression extends ExpressionBase {
 }
 export interface FunctionExpression extends Fn, ExpressionBase {
     type: "FunctionExpression";
-    identifier: Identifier;
+    identifier?: Identifier;
 }
 export interface ClassExpression extends Class, ExpressionBase {
     type: "ClassExpression";
-    identifier: Identifier;
+    identifier?: Identifier;
 }
 export interface AssignmentExpression extends ExpressionBase {
     type: "AssignmentExpression";
     operator: AssignmentOperator;
-    left: Pattern | Expression;
+    left: Expression | Pattern;
     right: Expression;
 }
 export interface MemberExpression extends ExpressionBase {
@@ -1028,7 +1046,7 @@ export interface MemberExpression extends ExpressionBase {
 }
 export interface SuperPropExpression extends ExpressionBase {
     type: "SuperPropExpression";
-    object: Super;
+    obj: Super;
     property: Identifier | ComputedPropName;
 }
 export interface ConditionalExpression extends ExpressionBase {
@@ -1045,14 +1063,14 @@ export interface Import extends Node, HasSpan {
 }
 export interface CallExpression extends ExpressionBase {
     type: "CallExpression";
-    callee: Expression | Super | Import;
+    callee: Super | Import | Expression;
     arguments: Argument[];
     typeArguments?: TsTypeParameterInstantiation;
 }
 export interface NewExpression extends ExpressionBase {
     type: "NewExpression";
     callee: Expression;
-    arguments: Argument[];
+    arguments?: Argument[];
     typeArguments?: TsTypeParameterInstantiation;
 }
 export interface SequenceExpression extends ExpressionBase {
@@ -1073,9 +1091,9 @@ export interface YieldExpression extends ExpressionBase {
     argument?: Expression;
     delegate: boolean;
 }
-export interface MetaProperty extends Node {
+export interface MetaProperty extends Node, HasSpan {
     type: "MetaProperty";
-    kind: 'ImportMeta' | 'NewTarget';
+    kind: "new.target" | "import.meta";
 }
 export interface AwaitExpression extends ExpressionBase {
     type: "AwaitExpression";
@@ -1089,14 +1107,14 @@ export interface TemplateLiteral extends ExpressionBase {
 export interface TaggedTemplateExpression extends ExpressionBase {
     type: "TaggedTemplateExpression";
     tag: Expression;
+    typeParameters?: TsTypeParameterInstantiation;
     template: TemplateLiteral;
-    typeParameters: TsTypeParameterInstantiation;
 }
 export interface TemplateElement extends ExpressionBase {
     type: "TemplateElement";
     tail: boolean;
-    cooked: StringLiteral;
-    raw: StringLiteral;
+    cooked?: string;
+    raw: string;
 }
 export interface ParenthesisExpression extends ExpressionBase {
     type: "ParenthesisExpression";
@@ -1104,20 +1122,15 @@ export interface ParenthesisExpression extends ExpressionBase {
 }
 export interface Fn extends HasSpan, HasDecorator {
     params: Param[];
-    body: BlockStatement;
+    body?: BlockStatement;
     generator: boolean;
     async: boolean;
     typeParameters?: TsTypeParameterDeclaration;
     returnType?: TsTypeAnnotation;
 }
-interface PatternBase {
+interface PatternBase extends Node, HasSpan {
     typeAnnotation?: TsTypeAnnotation;
 }
-export interface Identifier extends HasSpan, PatternBase {
-    type: "Identifier";
-    value: string;
-    optional: boolean;
-}
 export interface PrivateName extends ExpressionBase {
     type: "PrivateName";
     id: Identifier;
@@ -1139,12 +1152,12 @@ export interface JSXNamespacedName extends Node {
 export interface JSXEmptyExpression extends Node, HasSpan {
     type: "JSXEmptyExpression";
 }
-export interface JSXExpressionContainer extends Node {
+export interface JSXExpressionContainer extends Node, HasSpan {
     type: "JSXExpressionContainer";
     expression: JSXExpression;
 }
 export declare type JSXExpression = JSXEmptyExpression | Expression;
-export interface JSXSpreadChild extends Node {
+export interface JSXSpreadChild extends Node, HasSpan {
     type: "JSXSpreadChild";
     expression: Expression;
 }
@@ -1152,7 +1165,7 @@ export declare type JSXElementName = Identifier | JSXMemberExpression | JSXNames
 export interface JSXOpeningElement extends Node, HasSpan {
     type: "JSXOpeningElement";
     name: JSXElementName;
-    attributes?: JSXAttributeOrSpread[];
+    attributes: JSXAttributeOrSpread[];
     selfClosing: boolean;
     typeArguments?: TsTypeParameterInstantiation;
 }
@@ -1192,11 +1205,11 @@ export interface JSXOpeningFragment extends Node, HasSpan {
 export interface JSXClosingFragment extends Node, HasSpan {
     type: "JSXClosingFragment";
 }
-export declare type Literal = StringLiteral | BooleanLiteral | NullLiteral | NumericLiteral | RegExpLiteral | JSXText;
+export declare type Literal = StringLiteral | BooleanLiteral | NullLiteral | NumericLiteral | BigIntLiteral | RegExpLiteral | JSXText;
 export interface StringLiteral extends Node, HasSpan {
     type: "StringLiteral";
     value: string;
-    hasEscape: boolean;
+    raw?: string;
 }
 export interface BooleanLiteral extends Node, HasSpan {
     type: "BooleanLiteral";
@@ -1213,10 +1226,12 @@ export interface RegExpLiteral extends Node, HasSpan {
 export interface NumericLiteral extends Node, HasSpan {
     type: "NumericLiteral";
     value: number;
+    raw?: string;
 }
 export interface BigIntLiteral extends Node, HasSpan {
     type: "BigIntLiteral";
     value: bigint;
+    raw?: string;
 }
 export declare type ModuleDeclaration = ImportDeclaration | ExportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportDefaultExpression | ExportAllDeclaration | TsImportEqualsDeclaration | TsExportAssignment | TsNamespaceExportDeclaration;
 export interface ExportDefaultExpression extends Node, HasSpan {
@@ -1229,13 +1244,15 @@ export interface ExportDeclaration extends Node, HasSpan {
 }
 export interface ImportDeclaration extends Node, HasSpan {
     type: "ImportDeclaration";
-    typeOnly?: boolean;
     specifiers: ImportSpecifier[];
     source: StringLiteral;
+    typeOnly: boolean;
+    asserts?: ObjectExpression;
 }
 export interface ExportAllDeclaration extends Node, HasSpan {
     type: "ExportAllDeclaration";
     source: StringLiteral;
+    asserts?: ObjectExpression;
 }
 /**
  * - `export { foo } from 'mod'`
@@ -1246,6 +1263,7 @@ export interface ExportNamedDeclaration extends Node, HasSpan {
     specifiers: ExportSpecifier[];
     source?: StringLiteral;
     typeOnly: boolean;
+    asserts?: ObjectExpression;
 }
 export interface ExportDefaultDeclaration extends Node, HasSpan {
     type: "ExportDefaultDeclaration";
@@ -1279,16 +1297,17 @@ export interface ImportNamespaceSpecifier extends Node, HasSpan {
 export interface NamedImportSpecifier extends Node, HasSpan {
     type: "ImportSpecifier";
     local: Identifier;
-    imported: Identifier | null;
-    isTypeOnly?: boolean;
+    imported?: ModuleExportName;
+    isTypeOnly: boolean;
 }
+export declare type ModuleExportName = Identifier | StringLiteral;
 export declare type ExportSpecifier = ExportNamespaceSpecifier | ExportDefaultSpecifier | NamedExportSpecifier;
 /**
  * `export * as foo from 'src';`
  */
 export interface ExportNamespaceSpecifier extends Node, HasSpan {
     type: "ExportNamespaceSpecifier";
-    name: Identifier;
+    name: ModuleExportName;
 }
 export interface ExportDefaultSpecifier extends Node, HasSpan {
     type: "ExportDefaultSpecifier";
@@ -1296,12 +1315,12 @@ export interface ExportDefaultSpecifier extends Node, HasSpan {
 }
 export interface NamedExportSpecifier extends Node, HasSpan {
     type: "ExportSpecifier";
-    orig: Identifier;
+    orig: ModuleExportName;
     /**
      * `Some(bar)` in `export { foo as bar }`
      */
-    exported: Identifier | null;
-    isTypeOnly?: boolean;
+    exported?: ModuleExportName;
+    isTypeOnly: boolean;
 }
 interface HasInterpreter {
     /**
@@ -1319,25 +1338,32 @@ export interface Script extends Node, HasSpan, HasInterpreter {
     body: Statement[];
 }
 export declare type ModuleItem = ModuleDeclaration | Statement;
-export declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "||" | "&&" | "in" | "instanceof" | "??";
-export declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=";
+export declare type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "|" | "^" | "&" | "||" | "&&" | "in" | "instanceof" | "**" | "??";
+export declare type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "**=" | "&&=" | "||=" | "??=";
 export declare type UpdateOperator = "++" | "--";
 export declare type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
-export declare type Pattern = Identifier | ArrayPattern | RestElement | ObjectPattern | AssignmentPattern | Invalid | Expression;
-export interface ArrayPattern extends Node, HasSpan, PatternBase {
+export declare type Pattern = BindingIdentifier | ArrayPattern | RestElement | ObjectPattern | AssignmentPattern | Invalid | Expression;
+export interface BindingIdentifier extends PatternBase {
+    type: "Identifier";
+    value: string;
+    optional: boolean;
+}
+export interface ArrayPattern extends PatternBase {
     type: "ArrayPattern";
     elements: (Pattern | undefined)[];
+    optional: boolean;
 }
-export interface ObjectPattern extends Node, HasSpan, PatternBase {
+export interface ObjectPattern extends PatternBase {
     type: "ObjectPattern";
     properties: ObjectPatternProperty[];
+    optional: boolean;
 }
-export interface AssignmentPattern extends Node, HasSpan, PatternBase {
+export interface AssignmentPattern extends PatternBase {
     type: "AssignmentPattern";
     left: Pattern;
     right: Expression;
 }
-export interface RestElement extends Node, HasSpan, PatternBase {
+export interface RestElement extends PatternBase {
     type: "RestElement";
     rest: Span;
     argument: Pattern;
@@ -1376,17 +1402,17 @@ export interface AssignmentProperty extends Node {
 export interface GetterProperty extends PropBase, HasSpan {
     type: "GetterProperty";
     typeAnnotation?: TsTypeAnnotation;
-    body: BlockStatement;
+    body?: BlockStatement;
 }
 export interface SetterProperty extends PropBase, HasSpan {
     type: "SetterProperty";
     param: Pattern;
-    body: BlockStatement;
+    body?: BlockStatement;
 }
 export interface MethodProperty extends PropBase, Fn {
     type: "MethodProperty";
 }
-export declare type PropertyName = Identifier | StringLiteral | NumericLiteral | BigIntLiteral | ComputedPropName;
+export declare type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropName | BigIntLiteral;
 export interface ComputedPropName extends Node, HasSpan {
     type: "Computed";
     expression: Expression;
@@ -1399,7 +1425,7 @@ export interface ExpressionStatement extends Node, HasSpan {
     type: "ExpressionStatement";
     expression: Expression;
 }
-export declare type Statement = ExpressionStatement | BlockStatement | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+export declare type Statement = BlockStatement | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration | ExpressionStatement;
 export interface EmptyStatement extends Node, HasSpan {
     type: "EmptyStatement";
 }
@@ -1413,7 +1439,7 @@ export interface WithStatement extends Node, HasSpan {
 }
 export interface ReturnStatement extends Node, HasSpan {
     type: "ReturnStatement";
-    argument: Expression;
+    argument?: Expression;
 }
 export interface LabeledStatement extends Node, HasSpan {
     type: "LabeledStatement";
@@ -1422,11 +1448,11 @@ export interface LabeledStatement extends Node, HasSpan {
 }
 export interface BreakStatement extends Node, HasSpan {
     type: "BreakStatement";
-    label: Identifier;
+    label?: Identifier;
 }
 export interface ContinueStatement extends Node, HasSpan {
     type: "ContinueStatement";
-    label: Identifier;
+    label?: Identifier;
 }
 export interface IfStatement extends Node, HasSpan {
     type: "IfStatement";
@@ -1447,7 +1473,7 @@ export interface TryStatement extends Node, HasSpan {
     type: "TryStatement";
     block: BlockStatement;
     handler?: CatchClause;
-    finalizer: BlockStatement;
+    finalizer?: BlockStatement;
 }
 export interface WhileStatement extends Node, HasSpan {
     type: "WhileStatement";
@@ -1479,7 +1505,7 @@ export interface ForOfStatement extends Node, HasSpan {
      *
      *  es2018 for-await-of statements, e.g., `for await (const x of xs) {`
      */
-    await: Span;
+    await?: Span;
     left: VariableDeclaration | Pattern;
     right: Expression;
     body: Statement;
@@ -1497,7 +1523,7 @@ export interface CatchClause extends Node, HasSpan {
     /**
      * The param is `undefined` if the catch binding is omitted. E.g., `try { foo() } catch {}`
      */
-    param: Pattern;
+    param?: Pattern;
     body: BlockStatement;
 }
 export interface TsTypeAnnotation extends Node, HasSpan {
@@ -1511,8 +1537,10 @@ export interface TsTypeParameterDeclaration extends Node, HasSpan {
 export interface TsTypeParameter extends Node, HasSpan {
     type: "TsTypeParameter";
     name: Identifier;
-    constraint: TsType;
-    default: TsType;
+    in: boolean;
+    out: boolean;
+    constraint?: TsType;
+    default?: TsType;
 }
 export interface TsTypeParameterInstantiation extends Node, HasSpan {
     type: "TsTypeParameterInstantiation";
@@ -1521,28 +1549,29 @@ export interface TsTypeParameterInstantiation extends Node, HasSpan {
 export interface TsParameterProperty extends Node, HasSpan, HasDecorator {
     type: "TsParameterProperty";
     accessibility?: Accessibility;
+    override: boolean;
     readonly: boolean;
     param: TsParameterPropertyParameter;
 }
-export declare type TsParameterPropertyParameter = Identifier | AssignmentPattern;
+export declare type TsParameterPropertyParameter = BindingIdentifier | AssignmentPattern;
 export interface TsQualifiedName extends Node {
     type: "TsQualifiedName";
     left: TsEntityName;
     right: Identifier;
 }
 export declare type TsEntityName = TsQualifiedName | Identifier;
-export declare type TsTypeElement = TsCallSignatureDeclaration | TsConstructSignatureDeclaration | TsPropertySignature | TsMethodSignature | TsIndexSignature;
+export declare type TsTypeElement = TsCallSignatureDeclaration | TsConstructSignatureDeclaration | TsPropertySignature | TsGetterSignature | TsSetterSignature | TsMethodSignature | TsIndexSignature;
 export interface TsCallSignatureDeclaration extends Node, HasSpan {
     type: "TsCallSignatureDeclaration";
     params: TsFnParameter[];
-    typeAnnotation: TsTypeAnnotation;
-    typeParams: TsTypeParameterDeclaration;
+    typeAnnotation?: TsTypeAnnotation;
+    typeParams?: TsTypeParameterDeclaration;
 }
 export interface TsConstructSignatureDeclaration extends Node, HasSpan {
     type: "TsConstructSignatureDeclaration";
     params: TsFnParameter[];
-    typeAnnotation: TsTypeAnnotation;
-    typeParams: TsTypeParameterDeclaration;
+    typeAnnotation?: TsTypeAnnotation;
+    typeParams?: TsTypeParameterDeclaration;
 }
 export interface TsPropertySignature extends Node, HasSpan {
     type: "TsPropertySignature";
@@ -1550,10 +1579,26 @@ export interface TsPropertySignature extends Node, HasSpan {
     key: Expression;
     computed: boolean;
     optional: boolean;
-    init: Expression;
+    init?: Expression;
     params: TsFnParameter[];
     typeAnnotation?: TsTypeAnnotation;
-    typeParams: TsTypeParameterDeclaration;
+    typeParams?: TsTypeParameterDeclaration;
+}
+export interface TsGetterSignature extends Node, HasSpan {
+    type: "TsGetterSignature";
+    readonly: boolean;
+    key: Expression;
+    computed: boolean;
+    optional: boolean;
+    typeAnnotation?: TsTypeAnnotation;
+}
+export interface TsSetterSignature extends Node, HasSpan {
+    type: "TsSetterSignature";
+    readonly: boolean;
+    key: Expression;
+    computed: boolean;
+    optional: boolean;
+    param: TsFnParameter;
 }
 export interface TsMethodSignature extends Node, HasSpan {
     type: "TsMethodSignature";
@@ -1562,50 +1607,54 @@ export interface TsMethodSignature extends Node, HasSpan {
     computed: boolean;
     optional: boolean;
     params: TsFnParameter[];
-    typeAnnotation: TsTypeAnnotation;
-    typeParams: TsTypeParameterDeclaration;
+    typeAnn?: TsTypeAnnotation;
+    typeParams?: TsTypeParameterDeclaration;
 }
 export interface TsIndexSignature extends Node, HasSpan {
     type: "TsIndexSignature";
-    readonly: boolean;
     params: TsFnParameter[];
     typeAnnotation?: TsTypeAnnotation;
+    readonly: boolean;
+    static: boolean;
 }
-export declare type TsType = TsKeywordType | TsThisType | TsFnOrConstructorType | TsTypeReference | TsTypeQuery | TsTypeLiteral | TsArrayType | TsTupleType | TsOptionalType | TsRestType | TsUnionOrIntersectionType | TsConditionalType | TsInferType | TsParenthesizedType | TsTypeOperator | TsIndexedAccessType | TsMappedType | TsLiteralType | TsImportType | TsTypePredicate;
+export declare type TsType = TsKeywordType | TsThisType | TsFnOrConstructorType | TsTypeReference | TsTypeQuery | TsTypeLiteral | TsArrayType | TsTupleType | TsOptionalType | TsRestType | TsUnionOrIntersectionType | TsConditionalType | TsInferType | TsParenthesizedType | TsTypeOperator | TsIndexedAccessType | TsMappedType | TsLiteralType | TsTypePredicate | TsImportType;
 export declare type TsFnOrConstructorType = TsFunctionType | TsConstructorType;
 export interface TsKeywordType extends Node, HasSpan {
     type: "TsKeywordType";
     kind: TsKeywordTypeKind;
 }
-export declare type TsKeywordTypeKind = "any" | "unknown" | "number" | "object" | "boolean" | "bigint" | "string" | "symbol" | "void" | "undefined" | "null" | "never";
+export declare type TsKeywordTypeKind = "any" | "unknown" | "number" | "object" | "boolean" | "bigint" | "string" | "symbol" | "void" | "undefined" | "null" | "never" | "intrinsic";
 export interface TsThisType extends Node, HasSpan {
     type: "TsThisType";
 }
-export declare type TsFnParameter = Identifier | RestElement | ObjectPattern;
+export declare type TsFnParameter = BindingIdentifier | ArrayPattern | RestElement | ObjectPattern;
 export interface TsFunctionType extends Node, HasSpan {
     type: "TsFunctionType";
-    typeParams: TsTypeParameterDeclaration;
+    params: TsFnParameter[];
+    typeParams?: TsTypeParameterDeclaration;
     typeAnnotation: TsTypeAnnotation;
 }
 export interface TsConstructorType extends Node, HasSpan {
     type: "TsConstructorType";
     params: TsFnParameter[];
-    typeParams: TsTypeParameterDeclaration;
+    typeParams?: TsTypeParameterDeclaration;
     typeAnnotation: TsTypeAnnotation;
+    isAbstract: boolean;
 }
 export interface TsTypeReference extends Node, HasSpan {
     type: "TsTypeReference";
     typeName: TsEntityName;
-    typeParams: TsTypeParameterInstantiation;
+    typeParams?: TsTypeParameterInstantiation;
 }
 export interface TsTypePredicate extends Node, HasSpan {
     type: "TsTypePredicate";
     asserts: boolean;
     paramName: TsThisTypeOrIdent;
-    typeAnnotation: TsTypeAnnotation;
+    typeAnnotation?: TsTypeAnnotation;
 }
 export declare type TsThisTypeOrIdent = TsThisType | Identifier;
 export interface TsImportType extends Node, HasSpan {
+    type: "TsImportType";
     argument: StringLiteral;
     qualifier?: TsEntityName;
     typeArguments?: TsTypeParameterInstantiation;
@@ -1616,6 +1665,7 @@ export interface TsImportType extends Node, HasSpan {
 export interface TsTypeQuery extends Node, HasSpan {
     type: "TsTypeQuery";
     exprName: TsTypeQueryExpr;
+    typeArguments?: TsTypeParameterInstantiation;
 }
 export declare type TsTypeQueryExpr = TsEntityName | TsImportType;
 export interface TsTypeLiteral extends Node, HasSpan {
@@ -1628,7 +1678,12 @@ export interface TsArrayType extends Node, HasSpan {
 }
 export interface TsTupleType extends Node, HasSpan {
     type: "TsTupleType";
-    elemTypes: TsType[];
+    elemTypes: TsTupleElement[];
+}
+export interface TsTupleElement extends Node, HasSpan {
+    type: "TsTupleElement";
+    label?: Pattern;
+    ty: TsType;
 }
 export interface TsOptionalType extends Node, HasSpan {
     type: "TsOptionalType";
@@ -1667,25 +1722,32 @@ export interface TsTypeOperator extends Node, HasSpan {
     op: TsTypeOperatorOp;
     typeAnnotation: TsType;
 }
-export declare type TsTypeOperatorOp = "keyof" | "unique";
+export declare type TsTypeOperatorOp = "keyof" | "unique" | "readonly";
 export interface TsIndexedAccessType extends Node, HasSpan {
     type: "TsIndexedAccessType";
+    readonly: boolean;
     objectType: TsType;
     indexType: TsType;
 }
 export declare type TruePlusMinus = true | "+" | "-";
 export interface TsMappedType extends Node, HasSpan {
     type: "TsMappedType";
-    readonly: TruePlusMinus;
+    readonly?: TruePlusMinus;
     typeParam: TsTypeParameter;
-    optional: TruePlusMinus;
-    typeAnnotation: TsType;
+    nameType?: TsType;
+    optional?: TruePlusMinus;
+    typeAnnotation?: TsType;
 }
 export interface TsLiteralType extends Node, HasSpan {
     type: "TsLiteralType";
     literal: TsLiteral;
 }
-export declare type TsLiteral = NumericLiteral | StringLiteral | BooleanLiteral | TemplateLiteral;
+export declare type TsLiteral = NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TsTemplateLiteralType;
+export interface TsTemplateLiteralType extends Node, HasSpan {
+    type: "TemplateLiteral";
+    types: TsType[];
+    quasis: TemplateElement[];
+}
 export interface TsInterfaceDeclaration extends Node, HasSpan {
     type: "TsInterfaceDeclaration";
     id: Identifier;
@@ -1700,7 +1762,7 @@ export interface TsInterfaceBody extends Node, HasSpan {
 }
 export interface TsExpressionWithTypeArguments extends Node, HasSpan {
     type: "TsExpressionWithTypeArguments";
-    expression: TsEntityName;
+    expression: Expression;
     typeArguments?: TsTypeParameterInstantiation;
 }
 export interface TsTypeAliasDeclaration extends Node, HasSpan {
@@ -1713,7 +1775,7 @@ export interface TsTypeAliasDeclaration extends Node, HasSpan {
 export interface TsEnumDeclaration extends Node, HasSpan {
     type: "TsEnumDeclaration";
     declare: boolean;
-    is_const: boolean;
+    isConst: boolean;
     id: Identifier;
     members: TsEnumMember[];
 }
@@ -1749,14 +1811,15 @@ export declare type TsModuleName = Identifier | StringLiteral;
 export interface TsImportEqualsDeclaration extends Node, HasSpan {
     type: "TsImportEqualsDeclaration";
     declare: boolean;
-    is_export: boolean;
+    isExport: boolean;
+    isTypeOnly: boolean;
     id: Identifier;
     moduleRef: TsModuleReference;
 }
 export declare type TsModuleReference = TsEntityName | TsExternalModuleReference;
 export interface TsExternalModuleReference extends Node, HasSpan {
     type: "TsExternalModuleReference";
-    expression: Expression;
+    expression: StringLiteral;
 }
 export interface TsExportAssignment extends Node, HasSpan {
     type: "TsExportAssignment";
@@ -1771,6 +1834,11 @@ export interface TsAsExpression extends ExpressionBase {
     expression: Expression;
     typeAnnotation: TsType;
 }
+export interface TsInstantiation extends Node, HasSpan {
+    type: "TsInstantiation";
+    expression: Expression;
+    typeArguments: TsTypeParameterInstantiation;
+}
 export interface TsTypeAssertion extends ExpressionBase {
     type: "TsTypeAssertion";
     expression: Expression;