xbintsc 0.1.0

package/dist/src/ast/nodes.d.ts

@@ -0,0 +1,848 @@
+/**
+ * The xbintsc abstract syntax tree.
+ *
+ * The AST is a faithful, lossless-enough representation of the TypeScript
+ * source. Nodes are discriminated unions keyed by `kind` so the binder, checker
+ * and code generator can switch exhaustively over them. Every node carries a
+ * source range (`start`/`end` offsets) which the diagnostics layer maps back to
+ * line/column, and which the incremental cache uses to detect changes.
+ */
+import type { Token } from "../lexer/token.js";
+export interface Range {
+    /** Inclusive start offset (UTF-16 code units). */
+    readonly start: number;
+    /** Exclusive end offset. */
+    readonly end: number;
+}
+export interface Node extends Range {
+    readonly kind: SyntaxKind;
+}
+export declare const enum SyntaxKind {
+    Unknown = 0,
+    EndOfFileToken = 1,
+    SourceFile = 300,
+    QualifiedName = 301,
+    ExpressionWithTypeArguments = 302,
+    ImportType = 303,
+    Identifier = 2,
+    PrivateIdentifier = 3,
+    NumericLiteral = 4,
+    BigIntLiteral = 5,
+    StringLiteral = 6,
+    NoSubstitutionTemplateLiteral = 7,
+    TemplateLiteral = 8,
+    TemplateSpan = 9,
+    RegularExpressionLiteral = 10,
+    TrueKeyword = 11,
+    FalseKeyword = 12,
+    NullKeyword = 13,
+    UndefinedKeyword = 14,
+    ThisKeyword = 15,
+    ArrayLiteralExpression = 20,
+    ObjectLiteralExpression = 21,
+    PropertyAssignment = 22,
+    ShorthandPropertyAssignment = 23,
+    SpreadElement = 24,
+    FunctionExpression = 25,
+    ArrowFunction = 26,
+    ClassExpression = 27,
+    CallExpression = 28,
+    NewExpression = 29,
+    PropertyAccessExpression = 30,
+    ElementAccessExpression = 31,
+    ParenthesizedExpression = 32,
+    PrefixUnaryExpression = 33,
+    PostfixUnaryExpression = 34,
+    BinaryExpression = 35,
+    ConditionalExpression = 36,
+    AsExpression = 37,
+    SatisfiesExpression = 38,
+    NonNullExpression = 39,
+    TypeOfExpression = 40,
+    VoidExpression = 41,
+    DeleteExpression = 42,
+    AwaitExpression = 43,
+    YieldExpression = 44,
+    TaggedTemplateExpression = 45,
+    ExpressionStatement = 60,
+    Block = 61,
+    EmptyStatement = 62,
+    DebuggerStatement = 63,
+    VariableStatement = 64,
+    VariableDeclarationList = 65,
+    VariableDeclaration = 66,
+    IfStatement = 67,
+    WhileStatement = 68,
+    DoStatement = 69,
+    ForStatement = 70,
+    ForOfStatement = 71,
+    ForInStatement = 72,
+    ReturnStatement = 73,
+    BreakStatement = 74,
+    ContinueStatement = 75,
+    ThrowStatement = 76,
+    TryStatement = 77,
+    CatchClause = 78,
+    SwitchStatement = 79,
+    CaseClause = 80,
+    DefaultClause = 81,
+    LabeledStatement = 82,
+    FunctionDeclaration = 100,
+    ClassDeclaration = 101,
+    InterfaceDeclaration = 102,
+    TypeAliasDeclaration = 103,
+    EnumDeclaration = 104,
+    EnumMember = 105,
+    ModuleDeclaration = 106,
+    Parameter = 107,
+    TypeParameterDeclaration = 108,
+    PropertyDeclaration = 109,
+    MethodDeclaration = 110,
+    ConstructorDeclaration = 111,
+    HeritageClause = 112,
+    ImportDeclaration = 113,
+    ImportClause = 114,
+    NamedImports = 115,
+    ImportSpecifier = 116,
+    NamespaceImport = 117,
+    ExportDeclaration = 118,
+    ExportAssignment = 119,
+    NamedExports = 120,
+    ExportSpecifier = 121,
+    TypeReference = 200,
+    TypePredicate = 201,
+    AnyKeywordType = 202,
+    UnknownKeywordType = 203,
+    NumberKeywordType = 204,
+    BigIntKeywordType = 205,
+    StringKeywordType = 206,
+    BooleanKeywordType = 207,
+    SymbolKeywordType = 208,
+    VoidKeywordType = 209,
+    UndefinedKeywordType = 210,
+    NullKeywordType = 211,
+    NeverKeywordType = 212,
+    ObjectKeywordType = 213,
+    ThisKeywordType = 214,
+    LiteralType = 215,
+    ArrayType = 216,
+    TupleType = 217,
+    UnionType = 218,
+    IntersectionType = 219,
+    FunctionType = 220,
+    TypeLiteral = 221,
+    PropertySignature = 222,
+    MethodSignature = 223,
+    IndexSignature = 224,
+    ParenthesizedType = 225,
+    TypeQuery = 226,
+    IndexedAccessType = 227,
+    TypeOperator = 228,
+    MappedType = 229,
+    ConditionalType = 230,
+    InferType = 231,
+    OptionalType = 232,
+    RestType = 233
+}
+export declare const enum NodeFlags {
+    None = 0,
+    Let = 1,
+    Const = 2,
+    Var = 4,
+    Exported = 8,
+    Default = 16,
+    Declare = 32,
+    Async = 64,
+    Generator = 128,
+    Ambient = 256,
+    Readonly = 512,
+    Abstract = 1024,
+    Optional = 2048
+}
+export declare const enum ModifierKind {
+    Export = "export",
+    Default = "default",
+    Declare = "declare",
+    Abstract = "abstract",
+    Public = "public",
+    Private = "private",
+    Protected = "protected",
+    Static = "static",
+    Readonly = "readonly",
+    Async = "async"
+}
+export interface Modifier extends Node {
+    readonly kind: SyntaxKind.Unknown;
+    readonly modifierKind: ModifierKind;
+}
+export type Expression = Identifier | PrivateIdentifier | NumericLiteral | BigIntLiteral | StringLiteral | NoSubstitutionTemplateLiteral | TemplateLiteral | RegularExpressionLiteral | BooleanLiteral | NullLiteral | UndefinedLiteral | ThisExpression | ArrayLiteralExpression | ObjectLiteralExpression | FunctionExpression | ArrowFunction | ClassExpression | CallExpression | NewExpression | PropertyAccessExpression | ElementAccessExpression | ParenthesizedExpression | PrefixUnaryExpression | PostfixUnaryExpression | BinaryExpression | ConditionalExpression | AsExpression | SatisfiesExpression | NonNullExpression | TypeOfExpression | VoidExpression | DeleteExpression | AwaitExpression | YieldExpression | TaggedTemplateExpression | SpreadElement;
+export type Statement = ExpressionStatement | Block | EmptyStatement | DebuggerStatement | VariableStatement | IfStatement | WhileStatement | DoStatement | ForStatement | ForOfStatement | ForInStatement | ReturnStatement | BreakStatement | ContinueStatement | ThrowStatement | TryStatement | SwitchStatement | LabeledStatement | FunctionDeclaration | ClassDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumDeclaration | ModuleDeclaration | ImportDeclaration | ExportDeclaration | ExportAssignment;
+export type TypeNode = TypeReference | TypePredicate | KeywordTypeNode | LiteralTypeNode | ArrayTypeNode | TupleTypeNode | UnionTypeNode | IntersectionTypeNode | FunctionTypeNode | TypeLiteralNode | ParenthesizedTypeNode | TypeQueryNode | IndexedAccessTypeNode | TypeOperatorNode | MappedTypeNode | ConditionalTypeNode | InferTypeNode | OptionalTypeNode | RestTypeNode;
+export interface SourceFileNode extends Node {
+    readonly kind: SyntaxKind.SourceFile;
+    readonly statements: Statement[];
+    readonly fileName: string;
+    readonly text: string;
+}
+export interface Identifier extends Node {
+    readonly kind: SyntaxKind.Identifier;
+    readonly text: string;
+    /** True when the identifier was written with a `#` prefix. */
+    readonly escaped?: boolean;
+}
+export interface PrivateIdentifier extends Node {
+    readonly kind: SyntaxKind.PrivateIdentifier;
+    readonly text: string;
+}
+export interface NumericLiteral extends Node {
+    readonly kind: SyntaxKind.NumericLiteral;
+    readonly text: string;
+    readonly value: number;
+}
+export interface BigIntLiteral extends Node {
+    readonly kind: SyntaxKind.BigIntLiteral;
+    readonly text: string;
+    readonly value: bigint;
+}
+export interface StringLiteral extends Node {
+    readonly kind: SyntaxKind.StringLiteral;
+    readonly text: string;
+    readonly value: string;
+    /** Raw source text, including quotes. */
+    readonly raw: string;
+}
+export interface NoSubstitutionTemplateLiteral extends Node {
+    readonly kind: SyntaxKind.NoSubstitutionTemplateLiteral;
+    readonly text: string;
+    readonly value: string;
+}
+export interface TemplateLiteral extends Node {
+    readonly kind: SyntaxKind.TemplateLiteral;
+    readonly head: string;
+    readonly spans: TemplateSpan[];
+}
+export interface TemplateSpan extends Node {
+    readonly kind: SyntaxKind.TemplateSpan;
+    readonly expression: Expression;
+    readonly literal: string;
+    /** True when this span terminates the template (tail) rather than continues it. */
+    readonly isTail: boolean;
+}
+export interface RegularExpressionLiteral extends Node {
+    readonly kind: SyntaxKind.RegularExpressionLiteral;
+    readonly text: string;
+    readonly pattern: string;
+    readonly flags: string;
+}
+export interface BooleanLiteral extends Node {
+    readonly kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword;
+    readonly value: boolean;
+}
+export interface NullLiteral extends Node {
+    readonly kind: SyntaxKind.NullKeyword;
+}
+export interface UndefinedLiteral extends Node {
+    readonly kind: SyntaxKind.UndefinedKeyword;
+}
+export interface ThisExpression extends Node {
+    readonly kind: SyntaxKind.ThisKeyword;
+}
+export interface ArrayLiteralExpression extends Node {
+    readonly kind: SyntaxKind.ArrayLiteralExpression;
+    readonly elements: Expression[];
+}
+export interface PropertyAssignment extends Node {
+    readonly kind: SyntaxKind.PropertyAssignment;
+    readonly name: PropertyName;
+    readonly initializer: Expression;
+}
+export interface ShorthandPropertyAssignment extends Node {
+    readonly kind: SyntaxKind.ShorthandPropertyAssignment;
+    readonly name: Identifier;
+}
+export interface SpreadElement extends Node {
+    readonly kind: SyntaxKind.SpreadElement;
+    readonly expression: Expression;
+}
+export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadElement;
+export interface ObjectLiteralExpression extends Node {
+    readonly kind: SyntaxKind.ObjectLiteralExpression;
+    readonly properties: ObjectLiteralElementLike[];
+}
+export type PropertyName = Identifier | StringLiteral | NumericLiteral | PrivateIdentifier;
+export interface FunctionExpression extends Node {
+    readonly kind: SyntaxKind.FunctionExpression;
+    readonly name?: Identifier;
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+    readonly body: Block;
+    readonly flags: NodeFlags;
+}
+export interface ArrowFunction extends Node {
+    readonly kind: SyntaxKind.ArrowFunction;
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+    readonly body: Block | Expression;
+    readonly flags: NodeFlags;
+}
+export interface ClassExpression extends Node {
+    readonly kind: SyntaxKind.ClassExpression;
+    readonly name?: Identifier;
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly heritage: HeritageClause[];
+    readonly members: ClassElement[];
+}
+export interface CallExpression extends Node {
+    readonly kind: SyntaxKind.CallExpression;
+    readonly expression: Expression;
+    readonly typeArguments: TypeNode[];
+    readonly arguments: Expression[];
+    readonly optional: boolean;
+}
+export interface NewExpression extends Node {
+    readonly kind: SyntaxKind.NewExpression;
+    readonly expression: Expression;
+    readonly typeArguments: TypeNode[];
+    readonly arguments: Expression[];
+}
+export interface PropertyAccessExpression extends Node {
+    readonly kind: SyntaxKind.PropertyAccessExpression;
+    readonly expression: Expression;
+    readonly name: Identifier;
+    readonly optional: boolean;
+}
+export interface ElementAccessExpression extends Node {
+    readonly kind: SyntaxKind.ElementAccessExpression;
+    readonly expression: Expression;
+    readonly argumentExpression: Expression;
+    readonly optional: boolean;
+}
+export interface ParenthesizedExpression extends Node {
+    readonly kind: SyntaxKind.ParenthesizedExpression;
+    readonly expression: Expression;
+}
+export declare const enum PrefixUnaryOperator {
+    Plus = "+",
+    Minus = "-",
+    Tilde = "~",
+    Exclamation = "!",
+    TypeOf = "typeof",
+    Void = "void",
+    Delete = "delete",
+    PlusPlus = "++",
+    MinusMinus = "--",
+    Await = "await"
+}
+export interface PrefixUnaryExpression extends Node {
+    readonly kind: SyntaxKind.PrefixUnaryExpression;
+    readonly operator: PrefixUnaryOperator;
+    readonly operand: Expression;
+}
+export declare const enum PostfixUnaryOperator {
+    PlusPlus = "++",
+    MinusMinus = "--"
+}
+export interface PostfixUnaryExpression extends Node {
+    readonly kind: SyntaxKind.PostfixUnaryExpression;
+    readonly operator: PostfixUnaryOperator;
+    readonly operand: Expression;
+}
+export declare const enum BinaryOperator {
+    Add = "+",
+    Subtract = "-",
+    Multiply = "*",
+    Divide = "/",
+    Remainder = "%",
+    Exponent = "**",
+    LessThan = "<",
+    LessThanEquals = "<=",
+    GreaterThan = ">",
+    GreaterThanEquals = ">=",
+    EqualsEquals = "==",
+    ExclamationEquals = "!=",
+    EqualsEqualsEquals = "===",
+    ExclamationEqualsEquals = "!==",
+    AmpersandAmpersand = "&&",
+    BarBar = "||",
+    QuestionQuestion = "??",
+    Ampersand = "&",
+    Bar = "|",
+    Caret = "^",
+    LessThanLessThan = "<<",
+    GreaterThanGreaterThan = ">>",
+    GreaterThanGreaterThanGreaterThan = ">>>",
+    Comma = ",",
+    In = "in",
+    InstanceOf = "instanceof"
+}
+/** Assignment operators, including the compound forms. */
+export declare const enum AssignmentOperator {
+    Assign = "=",
+    AddAssign = "+=",
+    SubtractAssign = "-=",
+    MultiplyAssign = "*=",
+    DivideAssign = "/=",
+    RemainderAssign = "%=",
+    ExponentAssign = "**=",
+    LessThanLessThanAssign = "<<=",
+    GreaterThanGreaterThanAssign = ">>=",
+    GreaterThanGreaterThanGreaterThanAssign = ">>>=",
+    AmpersandAssign = "&=",
+    BarAssign = "|=",
+    CaretAssign = "^=",
+    AmpersandAmpersandAssign = "&&=",
+    BarBarAssign = "||=",
+    QuestionQuestionAssign = "??="
+}
+export interface BinaryExpression extends Node {
+    readonly kind: SyntaxKind.BinaryExpression;
+    readonly left: Expression;
+    readonly operator: BinaryOperator;
+    readonly right: Expression;
+    readonly operatorToken: Token;
+}
+export interface AssignmentExpression extends Node {
+    readonly kind: SyntaxKind.BinaryExpression;
+    readonly left: Expression;
+    readonly operator: AssignmentOperator;
+    readonly right: Expression;
+    readonly operatorToken: Token;
+}
+export interface ConditionalExpression extends Node {
+    readonly kind: SyntaxKind.ConditionalExpression;
+    readonly condition: Expression;
+    readonly whenTrue: Expression;
+    readonly whenFalse: Expression;
+}
+export interface AsExpression extends Node {
+    readonly kind: SyntaxKind.AsExpression;
+    readonly expression: Expression;
+    readonly type: TypeNode;
+}
+export interface SatisfiesExpression extends Node {
+    readonly kind: SyntaxKind.SatisfiesExpression;
+    readonly expression: Expression;
+    readonly type: TypeNode;
+}
+export interface NonNullExpression extends Node {
+    readonly kind: SyntaxKind.NonNullExpression;
+    readonly expression: Expression;
+}
+export interface TypeOfExpression extends Node {
+    readonly kind: SyntaxKind.TypeOfExpression;
+    readonly expression: Expression;
+}
+export interface VoidExpression extends Node {
+    readonly kind: SyntaxKind.VoidExpression;
+    readonly expression?: Expression;
+}
+export interface DeleteExpression extends Node {
+    readonly kind: SyntaxKind.DeleteExpression;
+    readonly expression: Expression;
+}
+export interface AwaitExpression extends Node {
+    readonly kind: SyntaxKind.AwaitExpression;
+    readonly expression: Expression;
+}
+export interface YieldExpression extends Node {
+    readonly kind: SyntaxKind.YieldExpression;
+    readonly expression?: Expression;
+    readonly delegate: boolean;
+}
+export interface TaggedTemplateExpression extends Node {
+    readonly kind: SyntaxKind.TaggedTemplateExpression;
+    readonly tag: Expression;
+    readonly template: TemplateLiteral | NoSubstitutionTemplateLiteral;
+}
+export interface ExpressionStatement extends Node {
+    readonly kind: SyntaxKind.ExpressionStatement;
+    readonly expression: Expression;
+}
+export interface Block extends Node {
+    readonly kind: SyntaxKind.Block;
+    readonly statements: Statement[];
+}
+export interface EmptyStatement extends Node {
+    readonly kind: SyntaxKind.EmptyStatement;
+}
+export interface DebuggerStatement extends Node {
+    readonly kind: SyntaxKind.DebuggerStatement;
+}
+export interface VariableDeclaration extends Node {
+    readonly kind: SyntaxKind.VariableDeclaration;
+    readonly name: Identifier;
+    readonly exclamation: boolean;
+    readonly type?: TypeNode;
+    readonly initializer?: Expression;
+}
+export interface VariableDeclarationList extends Node {
+    readonly kind: SyntaxKind.VariableDeclarationList;
+    readonly declarations: VariableDeclaration[];
+    readonly declarationKind: "var" | "let" | "const" | "using";
+}
+export interface VariableStatement extends Node {
+    readonly kind: SyntaxKind.VariableStatement;
+    readonly declarationList: VariableDeclarationList;
+    readonly modifiers: Modifier[];
+}
+export interface IfStatement extends Node {
+    readonly kind: SyntaxKind.IfStatement;
+    readonly condition: Expression;
+    readonly thenStatement: Statement;
+    readonly elseStatement?: Statement;
+}
+export interface WhileStatement extends Node {
+    readonly kind: SyntaxKind.WhileStatement;
+    readonly condition: Expression;
+    readonly statement: Statement;
+}
+export interface DoStatement extends Node {
+    readonly kind: SyntaxKind.DoStatement;
+    readonly condition: Expression;
+    readonly statement: Statement;
+}
+export interface ForStatement extends Node {
+    readonly kind: SyntaxKind.ForStatement;
+    readonly initializer?: VariableDeclarationList | Expression;
+    readonly condition?: Expression;
+    readonly incrementor?: Expression;
+    readonly statement: Statement;
+}
+export interface ForOfStatement extends Node {
+    readonly kind: SyntaxKind.ForOfStatement;
+    readonly initializer: VariableDeclarationList | Expression;
+    readonly expression: Expression;
+    readonly statement: Statement;
+    readonly awaitModifier: boolean;
+}
+export interface ForInStatement extends Node {
+    readonly kind: SyntaxKind.ForInStatement;
+    readonly initializer: VariableDeclarationList | Expression;
+    readonly expression: Expression;
+    readonly statement: Statement;
+}
+export interface ReturnStatement extends Node {
+    readonly kind: SyntaxKind.ReturnStatement;
+    readonly expression?: Expression;
+}
+export interface BreakStatement extends Node {
+    readonly kind: SyntaxKind.BreakStatement;
+    readonly label?: Identifier;
+}
+export interface ContinueStatement extends Node {
+    readonly kind: SyntaxKind.ContinueStatement;
+    readonly label?: Identifier;
+}
+export interface ThrowStatement extends Node {
+    readonly kind: SyntaxKind.ThrowStatement;
+    readonly expression: Expression;
+}
+export interface CatchClause extends Node {
+    readonly kind: SyntaxKind.CatchClause;
+    readonly variable?: Identifier;
+    readonly type?: TypeNode;
+    readonly block: Block;
+}
+export interface TryStatement extends Node {
+    readonly kind: SyntaxKind.TryStatement;
+    readonly tryBlock: Block;
+    readonly catchClause?: CatchClause;
+    readonly finallyBlock?: Block;
+}
+export interface CaseClause extends Node {
+    readonly kind: SyntaxKind.CaseClause;
+    readonly expression: Expression;
+    readonly statements: Statement[];
+}
+export interface DefaultClause extends Node {
+    readonly kind: SyntaxKind.DefaultClause;
+    readonly statements: Statement[];
+}
+export interface SwitchStatement extends Node {
+    readonly kind: SyntaxKind.SwitchStatement;
+    readonly expression: Expression;
+    readonly clauses: (CaseClause | DefaultClause)[];
+}
+export interface LabeledStatement extends Node {
+    readonly kind: SyntaxKind.LabeledStatement;
+    readonly label: Identifier;
+    readonly statement: Statement;
+}
+export interface Parameter extends Node {
+    readonly kind: SyntaxKind.Parameter;
+    readonly name: Identifier;
+    readonly modifiers: Modifier[];
+    readonly dotDotDotToken: boolean;
+    readonly questionToken: boolean;
+    readonly type?: TypeNode;
+    readonly initializer?: Expression;
+}
+export interface TypeParameterDeclaration extends Node {
+    readonly kind: SyntaxKind.TypeParameterDeclaration;
+    readonly name: Identifier;
+    readonly constraint?: TypeNode;
+    readonly default?: TypeNode;
+}
+export interface FunctionDeclaration extends Node {
+    readonly kind: SyntaxKind.FunctionDeclaration;
+    readonly name?: Identifier;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+    readonly body?: Block;
+    readonly flags: NodeFlags;
+}
+export interface HeritageClause extends Node {
+    readonly kind: SyntaxKind.HeritageClause;
+    readonly token: "extends" | "implements";
+    readonly types: ExpressionWithTypeArguments[];
+}
+export interface ExpressionWithTypeArguments extends Node {
+    readonly kind: SyntaxKind.ExpressionWithTypeArguments;
+    readonly expression: Expression;
+    readonly typeArguments: TypeNode[];
+}
+export type ClassElement = PropertyDeclaration | MethodDeclaration | ConstructorDeclaration;
+export interface PropertyDeclaration extends Node {
+    readonly kind: SyntaxKind.PropertyDeclaration;
+    readonly name: PropertyName;
+    readonly modifiers: Modifier[];
+    readonly questionToken: boolean;
+    readonly exclamationToken: boolean;
+    readonly type?: TypeNode;
+    readonly initializer?: Expression;
+}
+export interface MethodDeclaration extends Node {
+    readonly kind: SyntaxKind.MethodDeclaration;
+    readonly name: PropertyName;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+    readonly body?: Block;
+    readonly flags: NodeFlags;
+    readonly optional: boolean;
+}
+export interface ConstructorDeclaration extends Node {
+    readonly kind: SyntaxKind.ConstructorDeclaration;
+    readonly modifiers: Modifier[];
+    readonly parameters: Parameter[];
+    readonly body?: Block;
+}
+export interface ClassDeclaration extends Node {
+    readonly kind: SyntaxKind.ClassDeclaration;
+    readonly name?: Identifier;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly heritage: HeritageClause[];
+    readonly members: ClassElement[];
+}
+export interface InterfaceDeclaration extends Node {
+    readonly kind: SyntaxKind.InterfaceDeclaration;
+    readonly name: Identifier;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly heritage: HeritageClause[];
+    readonly members: TypeElement[];
+}
+export interface TypeAliasDeclaration extends Node {
+    readonly kind: SyntaxKind.TypeAliasDeclaration;
+    readonly name: Identifier;
+    readonly modifiers: Modifier[];
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly type: TypeNode;
+}
+export interface EnumMember extends Node {
+    readonly kind: SyntaxKind.EnumMember;
+    readonly name: PropertyName;
+    readonly initializer?: Expression;
+}
+export interface EnumDeclaration extends Node {
+    readonly kind: SyntaxKind.EnumDeclaration;
+    readonly name: Identifier;
+    readonly modifiers: Modifier[];
+    readonly members: EnumMember[];
+}
+export interface ModuleDeclaration extends Node {
+    readonly kind: SyntaxKind.ModuleDeclaration;
+    readonly name: Identifier | StringLiteral;
+    readonly modifiers: Modifier[];
+    readonly body?: Block;
+}
+export interface ImportSpecifier extends Node {
+    readonly kind: SyntaxKind.ImportSpecifier;
+    readonly propertyName?: Identifier;
+    readonly name: Identifier;
+    readonly isTypeOnly: boolean;
+}
+export interface NamedImports extends Node {
+    readonly kind: SyntaxKind.NamedImports;
+    readonly elements: ImportSpecifier[];
+}
+export interface NamespaceImport extends Node {
+    readonly kind: SyntaxKind.NamespaceImport;
+    readonly name: Identifier;
+}
+export interface ImportClause extends Node {
+    readonly kind: SyntaxKind.ImportClause;
+    readonly name?: Identifier;
+    readonly namedBindings?: NamedImports | NamespaceImport;
+    readonly isTypeOnly: boolean;
+}
+export interface ImportDeclaration extends Node {
+    readonly kind: SyntaxKind.ImportDeclaration;
+    readonly importClause?: ImportClause;
+    readonly moduleSpecifier: StringLiteral;
+    readonly attributes: {
+        name: string;
+        value: string;
+    }[];
+}
+export interface ExportSpecifier extends Node {
+    readonly kind: SyntaxKind.ExportSpecifier;
+    readonly propertyName?: Identifier;
+    readonly name: Identifier;
+    readonly isTypeOnly: boolean;
+}
+export interface NamedExports extends Node {
+    readonly kind: SyntaxKind.NamedExports;
+    readonly elements: ExportSpecifier[];
+}
+export interface ExportDeclaration extends Node {
+    readonly kind: SyntaxKind.ExportDeclaration;
+    readonly modifiers: Modifier[];
+    readonly exportClause?: NamedExports | NamespaceExport;
+    readonly moduleSpecifier?: StringLiteral;
+    readonly isTypeOnly: boolean;
+}
+export interface NamespaceExport extends Node {
+    readonly kind: SyntaxKind.NamespaceImport;
+    readonly name: Identifier;
+}
+export interface ExportAssignment extends Node {
+    readonly kind: SyntaxKind.ExportAssignment;
+    readonly isExportEquals: boolean;
+    readonly expression: Expression;
+}
+export interface TypeReference extends Node {
+    readonly kind: SyntaxKind.TypeReference;
+    readonly typeName: Identifier | QualifiedName;
+    readonly typeArguments: TypeNode[];
+}
+export interface QualifiedName extends Node {
+    readonly kind: SyntaxKind.QualifiedName;
+    readonly left: Identifier | QualifiedName;
+    readonly right: Identifier;
+}
+export interface TypePredicate extends Node {
+    readonly kind: SyntaxKind.TypePredicate;
+    readonly parameterName: Identifier | ThisExpression;
+    readonly type?: TypeNode;
+}
+export interface KeywordTypeNode extends Node {
+    readonly kind: SyntaxKind.AnyKeywordType | SyntaxKind.UnknownKeywordType | SyntaxKind.NumberKeywordType | SyntaxKind.BigIntKeywordType | SyntaxKind.StringKeywordType | SyntaxKind.BooleanKeywordType | SyntaxKind.SymbolKeywordType | SyntaxKind.VoidKeywordType | SyntaxKind.UndefinedKeywordType | SyntaxKind.NullKeywordType | SyntaxKind.NeverKeywordType | SyntaxKind.ObjectKeywordType | SyntaxKind.ThisKeywordType;
+}
+export interface LiteralTypeNode extends Node {
+    readonly kind: SyntaxKind.LiteralType;
+    readonly literal: StringLiteral | NumericLiteral | BooleanLiteral | NullLiteral;
+}
+export interface ArrayTypeNode extends Node {
+    readonly kind: SyntaxKind.ArrayType;
+    readonly elementType: TypeNode;
+}
+export interface TupleTypeNode extends Node {
+    readonly kind: SyntaxKind.TupleType;
+    readonly elements: TypeNode[];
+}
+export interface UnionTypeNode extends Node {
+    readonly kind: SyntaxKind.UnionType;
+    readonly types: TypeNode[];
+}
+export interface IntersectionTypeNode extends Node {
+    readonly kind: SyntaxKind.IntersectionType;
+    readonly types: TypeNode[];
+}
+export interface FunctionTypeNode extends Node {
+    readonly kind: SyntaxKind.FunctionType;
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType: TypeNode;
+}
+export type TypeElement = PropertySignature | MethodSignature | IndexSignature;
+export interface PropertySignature extends Node {
+    readonly kind: SyntaxKind.PropertySignature;
+    readonly name: PropertyName;
+    readonly questionToken: boolean;
+    readonly readonlyToken: boolean;
+    readonly type?: TypeNode;
+}
+export interface MethodSignature extends Node {
+    readonly kind: SyntaxKind.MethodSignature;
+    readonly name: PropertyName;
+    readonly questionToken: boolean;
+    readonly typeParameters: TypeParameterDeclaration[];
+    readonly parameters: Parameter[];
+    readonly returnType?: TypeNode;
+}
+export interface IndexSignature extends Node {
+    readonly kind: SyntaxKind.IndexSignature;
+    readonly parameters: Parameter[];
+    readonly type?: TypeNode;
+}
+export interface TypeLiteralNode extends Node {
+    readonly kind: SyntaxKind.TypeLiteral;
+    readonly members: TypeElement[];
+}
+export interface ParenthesizedTypeNode extends Node {
+    readonly kind: SyntaxKind.ParenthesizedType;
+    readonly type: TypeNode;
+}
+export interface TypeQueryNode extends Node {
+    readonly kind: SyntaxKind.TypeQuery;
+    readonly exprName: Identifier | QualifiedName;
+    readonly typeArguments: TypeNode[];
+}
+export interface IndexedAccessTypeNode extends Node {
+    readonly kind: SyntaxKind.IndexedAccessType;
+    readonly objectType: TypeNode;
+    readonly indexType: TypeNode;
+}
+export declare const enum TypeOperator {
+    KeyOf = "keyof",
+    Unique = "unique",
+    Readonly = "readonly"
+}
+export interface TypeOperatorNode extends Node {
+    readonly kind: SyntaxKind.TypeOperator;
+    readonly operator: TypeOperator;
+    readonly type: TypeNode;
+}
+export interface MappedTypeNode extends Node {
+    readonly kind: SyntaxKind.MappedType;
+    readonly readonlyToken: boolean | "+" | "-";
+    readonly typeParameter: TypeParameterDeclaration;
+    readonly questionToken: boolean | "+" | "-";
+    readonly type?: TypeNode;
+}
+export interface ConditionalTypeNode extends Node {
+    readonly kind: SyntaxKind.ConditionalType;
+    readonly checkType: TypeNode;
+    readonly extendsType: TypeNode;
+    readonly trueType: TypeNode;
+    readonly falseType: TypeNode;
+}
+export interface InferTypeNode extends Node {
+    readonly kind: SyntaxKind.InferType;
+    readonly typeParameter: TypeParameterDeclaration;
+}
+export interface OptionalTypeNode extends Node {
+    readonly kind: SyntaxKind.OptionalType;
+    readonly type: TypeNode;
+}
+export interface RestTypeNode extends Node {
+    readonly kind: SyntaxKind.RestType;
+    readonly type: TypeNode;
+}