tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/ast.d.ts

@@ -0,0 +1,2350 @@
+import type { ProgramLifetime } from '@scriptc/types';
+import { SyntaxKind } from './syntax-kind.js';
+import { type CommentDirective, type CommentRange, type LanguageVariant, TokenFlags } from './types.js';
+import { type Diagnostic, DiagnosticFile } from './diagnostics.js';
+import type { ResolutionMode } from './module-resolution-types.js';
+import type { FlowNode } from './flow.js';
+import type { Symbol, SymbolTable } from './symbol.js';
+/**
+ * Takes node ids in chunks from `counter[0]`, shared by the threads that parse together; with
+ * `undefined`, goes back to a plain counter above every id handed out.
+ */
+export declare function shareNodeIds(counter: Int32Array | undefined): void;
+/** The last node id handed out on this thread. */
+export declare function lastNodeIdValue(): number;
+/** Continues node ids above `last` (a checker thread starts above the program it checks). */
+export declare function reserveNodeIds(last: number): void;
+export declare const enum NodeFlags {
+    None = 0,
+    Let = 1,
+    Const = 2,
+    Using = 4,
+    /** Synthesized while parsing, e.g. from JSDoc. */
+    Reparsed = 8,
+    Synthesized = 16,
+    OptionalChain = 32,
+    ExportContext = 64,
+    ContainsThis = 128,
+    HasImplicitReturn = 256,
+    HasExplicitReturn = 512,
+    DisallowInContext = 1024,
+    YieldContext = 2048,
+    DecoratorContext = 4096,
+    AwaitContext = 8192,
+    DisallowConditionalTypesContext = 16384,
+    ThisNodeHasError = 32768,
+    JavaScriptFile = 65536,
+    ThisNodeOrAnySubNodesHasError = 131072,
+    HasAsyncFunctions = 262144,
+    PossiblyContainsDynamicImport = 524288,
+    PossiblyContainsImportMeta = 1048576,
+    HasJSDoc = 2097152,
+    /** Parsed inside a JSDoc comment. */
+    JSDoc = 4194304,
+    Ambient = 8388608,
+    InWithStatement = 16777216,
+    JsonFile = 33554432,
+    PossiblyContainsDeprecatedTag = 67108864,
+    Unreachable = 134217728,
+    ReparserTransformedLiteral = 268435456,
+    BlockScoped = 7,
+    Constant = 6,
+    AwaitUsing = 6,
+    ReachabilityCheckFlags = 768,
+    ReachabilityAndEmitFlags = 262912,
+    ContextFlags = 25263104,
+    TypeExcludesFlags = 10240,
+    PermanentlySetIncrementalFlags = 1572864,
+    IdentifierHasExtendedUnicodeEscape = 128,
+    IdentifierIsInJSDocNamespace = 262144,
+    NestedNamespace = 32
+}
+export declare const enum ModifierFlags {
+    None = 0,
+    Public = 1,
+    Private = 2,
+    Protected = 4,
+    Readonly = 8,
+    Override = 16,
+    Export = 32,
+    Abstract = 64,
+    Ambient = 128,
+    Static = 256,
+    Accessor = 512,
+    Async = 1024,
+    Default = 2048,
+    Const = 4096,
+    In = 8192,
+    Out = 16384,
+    Decorator = 32768,
+    Deprecated = 65536,
+    JSDocPublic = 8388608,
+    JSDocPrivate = 16777216,
+    JSDocProtected = 33554432,
+    JSDocReadonly = 67108864,
+    JSDocOverride = 134217728,
+    HasComputedJSDocModifiers = 268435456,
+    HasComputedFlags = 536870912,
+    SyntacticOrJSDocModifiers = 31,
+    SyntacticOnlyModifiers = 65504,
+    SyntacticModifiers = 65535,
+    JSDocCacheOnlyModifiers = 260046848,
+    JSDocOnlyModifiers = 65536,
+    NonCacheOnlyModifiers = 131071,
+    AccessibilityModifier = 7,
+    ParameterPropertyModifier = 31,
+    NonPublicAccessibilityModifier = 6,
+    TypeScriptModifier = 28895,
+    ExportDefault = 2080,
+    All = 131071,
+    Modifier = 98303,
+    JavaScript = 3872
+}
+export declare const enum ScriptKind {
+    Unknown = 0,
+    JS = 1,
+    JSX = 2,
+    TS = 3,
+    TSX = 4,
+    External = 5,
+    JSON = 6,
+    Deferred = 7
+}
+export declare const enum Tristate {
+    Unknown = 0,
+    False = 1,
+    True = 2
+}
+/** Visits the children of a node in tsgo's order; any method returning `true` stops the walk. */
+export declare abstract class NodeVisitor {
+    abstract visitNode(node: Node): boolean;
+    visitList(list: NodeList): boolean;
+    visitModifiers(list: ModifierList): boolean;
+}
+export declare abstract class Node implements ProgramLifetime {
+    readonly kind: SyntaxKind;
+    flags: NodeFlags;
+    /** Start including leading trivia, as a UTF-16 offset. */
+    pos: number;
+    end: number;
+    parent: Node | undefined;
+    /** A program-wide id, unique among all nodes, in construction order. */
+    readonly id: number;
+    constructor(kind: SyntaxKind);
+    /** Calls `visitor` for each child in order; returns `true` if the visitor stopped. */
+    abstract forEachChild(visitor: NodeVisitor): boolean;
+    /**
+     * Makes this node the parent of each child that `forEachChild` visits. Natively, storing
+     * `this` only retains it, where a visitor holding the parent in a field would release each
+     * previous parent, making every finished node a cycle-collector candidate.
+     */
+    abstract setParentOfChildren(): void;
+    /** A copy of this subtree with the same positions and flags; parents are not set. */
+    abstract deepClone(): Node;
+    /** The flags of the node's modifiers, ModifierFlags.None without any: TypeScript 7's API `modifierFlags`. */
+    get modifierFlags(): ModifierFlags;
+}
+/** A program-wide id, unique among all nodes. */
+export declare function getNodeId(node: Node): number;
+/** A list of child nodes with its own text range. */
+export declare class NodeList implements ProgramLifetime {
+    pos: number;
+    end: number;
+    nodes: Node[];
+    constructor(pos: number, end: number, nodes: Node[]);
+    /** Created where the list's opening token was missing (a `MissingNodeList`, not a stored flag: natively that keeps a list at 48 bytes). */
+    get isMissingList(): boolean;
+    hasTrailingComma(): boolean;
+}
+/** An empty list created where the list's opening token was missing. */
+export declare class MissingNodeList extends NodeList {
+}
+export declare class ModifierList extends NodeList {
+    modifierFlags: ModifierFlags;
+    constructor(pos: number, end: number, nodes: Node[], modifierFlags: ModifierFlags);
+}
+/** A `/// <reference …/>` path, types or lib directive. */
+export declare class FileReference {
+    readonly pos: number;
+    readonly end: number;
+    readonly fileName: string;
+    readonly resolutionMode: ResolutionMode;
+    readonly preserve: boolean;
+    constructor(pos: number, end: number, fileName: string, resolutionMode: ResolutionMode, preserve: boolean);
+}
+export declare class PragmaArgument {
+    readonly pos: number;
+    readonly end: number;
+    readonly name: string;
+    readonly value: string;
+    constructor(pos: number, end: number, name: string, value: string);
+}
+/** A comment pragma such as `/// <reference path="…"/>`, `// @ts-nocheck` or `/** @jsx h *\/`. */
+export declare class Pragma {
+    readonly range: CommentRange;
+    readonly name: string;
+    readonly args: Map<string, PragmaArgument>;
+    constructor(range: CommentRange, name: string, args: Map<string, PragmaArgument>);
+}
+export declare class CheckJsDirective {
+    readonly enabled: boolean;
+    readonly range: CommentRange;
+    constructor(enabled: boolean, range: CommentRange);
+}
+/** What makes a non-declaration file a module besides imports and exports. */
+export declare class ExternalModuleIndicatorOptions {
+    /** JSX tags make the file a module (`jsx: react-jsx` or `react-jsxdev`). */
+    readonly jsx: boolean;
+    /** Every non-declaration file is a module (`moduleDetection: force`, or an ESM-format file). */
+    readonly force: boolean;
+    constructor(jsx: boolean, force: boolean);
+}
+/** How to parse a source file. */
+export declare class ParseOptions {
+    /** The canonical path; defaults to the file name. */
+    readonly path: string;
+    /** Defaults to the kind implied by the file extension. */
+    readonly scriptKind: ScriptKind;
+    readonly externalModuleIndicatorOptions: ExternalModuleIndicatorOptions;
+    constructor(path: string, scriptKind: ScriptKind, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions);
+}
+export type Expression = Node;
+export type LeftHandSideExpression = Node;
+export type Statement = Node;
+export type TypeNode = Node;
+export type BindingName = Node;
+export type ConciseBody = Node;
+export type EntityName = Node;
+export type ForInitializer = Node;
+export type FunctionBody = Node;
+export type ImportAttributeName = Node;
+export type JSDocFullName = Node;
+export type JsxAttributeName = Node;
+export type JsxAttributeValue = Node;
+export type JsxTagNameExpression = Node;
+export type MemberName = Node;
+export type ModuleBody = Node;
+export type ModuleExportName = Node;
+export type ModuleName = Node;
+export type ModuleReference = Node;
+export type NamedExportBindings = Node;
+export type NamedImportBindings = Node;
+export type PropertyName = Node;
+export type DeclarationName = Node;
+export type TemplateLiteral = Node;
+export type TemplateMiddleOrTail = Node;
+export type TypePredicateParameterName = Node;
+export declare class Token extends Node {
+    constructor(kind: SyntaxKind);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): Token;
+}
+export declare class Identifier extends Node {
+    text: string;
+    flowNode: FlowNode | undefined;
+    constructor(text: string);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): Identifier;
+}
+export declare class PrivateIdentifier extends Node {
+    text: string;
+    constructor(text: string);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): PrivateIdentifier;
+}
+export declare class QualifiedName extends Node {
+    left: EntityName;
+    right: Identifier;
+    flowNode: FlowNode | undefined;
+    constructor(left: EntityName, right: Identifier);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): QualifiedName;
+}
+export declare class ComputedPropertyName extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ComputedPropertyName;
+}
+export declare class Decorator extends Node {
+    expression: LeftHandSideExpression;
+    constructor(expression: LeftHandSideExpression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): Decorator;
+}
+export declare class EmptyStatement extends Node {
+    flowNode: FlowNode | undefined;
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): EmptyStatement;
+}
+export declare class IfStatement extends Node {
+    expression: Expression;
+    thenStatement: Statement;
+    elseStatement: Statement | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): IfStatement;
+}
+export declare class DoStatement extends Node {
+    statement: Statement;
+    expression: Expression;
+    flowNode: FlowNode | undefined;
+    constructor(statement: Statement, expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): DoStatement;
+}
+export declare class WhileStatement extends Node {
+    expression: Expression;
+    statement: Statement;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression, statement: Statement);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): WhileStatement;
+}
+export declare class ForStatement extends Node {
+    initializer: ForInitializer | undefined;
+    condition: Expression | undefined;
+    incrementor: Expression | undefined;
+    statement: Statement;
+    flowNode: FlowNode | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ForStatement;
+}
+export declare class ForInOrOfStatement extends Node {
+    awaitModifier: Token | undefined;
+    initializer: ForInitializer;
+    expression: Expression;
+    statement: Statement;
+    flowNode: FlowNode | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(kind: SyntaxKind, awaitModifier: Token | undefined, initializer: ForInitializer, expression: Expression, statement: Statement);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ForInOrOfStatement;
+}
+export declare class BreakStatement extends Node {
+    label: Identifier | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(label: Identifier | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): BreakStatement;
+}
+export declare class ContinueStatement extends Node {
+    label: Identifier | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(label: Identifier | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ContinueStatement;
+}
+export declare class ReturnStatement extends Node {
+    expression: Expression | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ReturnStatement;
+}
+export declare class WithStatement extends Node {
+    expression: Expression;
+    statement: Statement;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression, statement: Statement);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): WithStatement;
+}
+export declare class SwitchStatement extends Node {
+    expression: Expression;
+    caseBlock: CaseBlock;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression, caseBlock: CaseBlock);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): SwitchStatement;
+}
+export declare class CaseBlock extends Node {
+    clauses: NodeList;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(clauses: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): CaseBlock;
+}
+export declare class CaseOrDefaultClause extends Node {
+    expression: Expression | undefined;
+    statements: NodeList;
+    fallthroughFlowNode: FlowNode | undefined;
+    constructor(kind: SyntaxKind, expression: Expression | undefined, statements: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): CaseOrDefaultClause;
+}
+export declare class ThrowStatement extends Node {
+    expression: Expression;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ThrowStatement;
+}
+export declare class TryStatement extends Node {
+    tryBlock: Block;
+    catchClause: CatchClause | undefined;
+    finallyBlock: Block | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TryStatement;
+}
+export declare class CatchClause extends Node {
+    variableDeclaration: VariableDeclaration | undefined;
+    block: Block;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(variableDeclaration: VariableDeclaration | undefined, block: Block);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): CatchClause;
+}
+export declare class DebuggerStatement extends Node {
+    flowNode: FlowNode | undefined;
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): DebuggerStatement;
+}
+export declare class LabeledStatement extends Node {
+    label: Identifier;
+    statement: Statement;
+    flowNode: FlowNode | undefined;
+    constructor(label: Identifier, statement: Statement);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): LabeledStatement;
+}
+export declare class ExpressionStatement extends Node {
+    expression: Expression;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ExpressionStatement;
+}
+export declare class Block extends Node {
+    statements: NodeList;
+    multiLine: boolean;
+    flowNode: FlowNode | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(statements: NodeList, multiLine: boolean);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): Block;
+}
+export declare class VariableStatement extends Node {
+    modifiers: ModifierList | undefined;
+    declarationList: VariableDeclarationList;
+    flowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, declarationList: VariableDeclarationList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): VariableStatement;
+}
+export declare class VariableDeclaration extends Node {
+    name: BindingName;
+    exclamationToken: Token | undefined;
+    type: TypeNode | undefined;
+    initializer: Expression | undefined;
+    symbol: Symbol | undefined;
+    localSymbol: Symbol | undefined;
+    constructor(name: BindingName, exclamationToken: Token | undefined, type: TypeNode | undefined, initializer: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): VariableDeclaration;
+}
+export declare class VariableDeclarationList extends Node {
+    declarations: NodeList;
+    constructor(declarations: NodeList, flags: NodeFlags);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): VariableDeclarationList;
+}
+export declare class BindingPattern extends Node {
+    elements: NodeList;
+    constructor(kind: SyntaxKind, elements: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): BindingPattern;
+}
+export declare class ParameterDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    dotDotDotToken: Token | undefined;
+    name: BindingName;
+    questionToken: Token | undefined;
+    type: TypeNode | undefined;
+    initializer: Expression | undefined;
+    symbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, dotDotDotToken: Token | undefined, name: BindingName, questionToken: Token | undefined, type: TypeNode | undefined, initializer: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ParameterDeclaration;
+}
+export declare class BindingElement extends Node {
+    dotDotDotToken: Token | undefined;
+    propertyName: PropertyName | undefined;
+    name: BindingName | undefined;
+    initializer: Expression | undefined;
+    symbol: Symbol | undefined;
+    localSymbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(dotDotDotToken: Token | undefined, propertyName: PropertyName | undefined, name: BindingName | undefined, initializer: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): BindingElement;
+}
+export declare class MissingDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    flowNode: FlowNode | undefined;
+    symbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): MissingDeclaration;
+}
+export declare class FunctionDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    asteriskToken: Token | undefined;
+    name: Identifier | undefined;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    fullSignature: TypeNode | undefined;
+    body: FunctionBody | undefined;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    localSymbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    endFlowNode: FlowNode | undefined;
+    returnFlowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, asteriskToken: Token | undefined, name: Identifier | undefined, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined, fullSignature: TypeNode | undefined, body: FunctionBody | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): FunctionDeclaration;
+}
+export declare class ClassDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: Identifier | undefined;
+    typeParameters: NodeList | undefined;
+    heritageClauses: NodeList | undefined;
+    members: NodeList;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    localSymbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(modifiers: ModifierList | undefined, name: Identifier | undefined, typeParameters: NodeList | undefined, heritageClauses: NodeList | undefined, members: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ClassDeclaration;
+}
+export declare class ClassExpression extends Node {
+    modifiers: ModifierList | undefined;
+    name: Identifier | undefined;
+    typeParameters: NodeList | undefined;
+    heritageClauses: NodeList | undefined;
+    members: NodeList;
+    symbol: Symbol | undefined;
+    localSymbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(modifiers: ModifierList | undefined, name: Identifier | undefined, typeParameters: NodeList | undefined, heritageClauses: NodeList | undefined, members: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ClassExpression;
+}
+export declare class HeritageClause extends Node {
+    token: SyntaxKind;
+    types: NodeList;
+    constructor(token: SyntaxKind, types: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): HeritageClause;
+}
+export declare class InterfaceDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: Identifier;
+    typeParameters: NodeList | undefined;
+    heritageClauses: NodeList | undefined;
+    members: NodeList;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    localSymbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, name: Identifier, typeParameters: NodeList | undefined, heritageClauses: NodeList | undefined, members: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): InterfaceDeclaration;
+}
+export declare class TypeAliasDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: Identifier;
+    typeParameters: NodeList | undefined;
+    type: TypeNode;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    localSymbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(kind: SyntaxKind, modifiers: ModifierList | undefined, name: Identifier, typeParameters: NodeList | undefined, type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypeAliasDeclaration;
+}
+export declare class EnumMember extends Node {
+    name: PropertyName;
+    initializer: Expression | undefined;
+    symbol: Symbol | undefined;
+    constructor(name: PropertyName, initializer: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): EnumMember;
+}
+export declare class EnumDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: Identifier;
+    members: NodeList;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    localSymbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, name: Identifier, members: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): EnumDeclaration;
+}
+export declare class ModuleBlock extends Node {
+    statements: NodeList;
+    flowNode: FlowNode | undefined;
+    constructor(statements: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ModuleBlock;
+}
+export declare class NotEmittedStatement extends Node {
+    flowNode: FlowNode | undefined;
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NotEmittedStatement;
+}
+export declare class NotEmittedTypeElement extends Node {
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NotEmittedTypeElement;
+}
+export declare class ImportDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    importClause: ImportClause | undefined;
+    moduleSpecifier: Expression;
+    attributes: ImportAttributes | undefined;
+    flowNode: FlowNode | undefined;
+    symbol: Symbol | undefined;
+    constructor(kind: SyntaxKind, modifiers: ModifierList | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression, attributes: ImportAttributes | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ImportDeclaration;
+}
+export declare class ExternalModuleReference extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ExternalModuleReference;
+}
+export declare class NamespaceImport extends Node {
+    name: Identifier;
+    symbol: Symbol | undefined;
+    localSymbol: Symbol | undefined;
+    constructor(name: Identifier);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NamespaceImport;
+}
+export declare class NamedImports extends Node {
+    elements: NodeList;
+    constructor(elements: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NamedImports;
+}
+export declare class ExportAssignment extends Node {
+    modifiers: ModifierList | undefined;
+    isExportEquals: boolean;
+    type: TypeNode | undefined;
+    expression: Expression;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, isExportEquals: boolean, type: TypeNode | undefined, expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ExportAssignment;
+}
+export declare class NamespaceExportDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: Identifier;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, name: Identifier);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NamespaceExportDeclaration;
+}
+export declare class NamespaceExport extends Node {
+    name: ModuleExportName;
+    symbol: Symbol | undefined;
+    constructor(name: ModuleExportName);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NamespaceExport;
+}
+export declare class NamedExports extends Node {
+    elements: NodeList;
+    constructor(elements: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NamedExports;
+}
+export declare class ExportSpecifier extends Node {
+    isTypeOnly: boolean;
+    propertyName: ModuleExportName | undefined;
+    name: ModuleExportName;
+    symbol: Symbol | undefined;
+    localSymbol: Symbol | undefined;
+    constructor(isTypeOnly: boolean, propertyName: ModuleExportName | undefined, name: ModuleExportName);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ExportSpecifier;
+}
+export declare class CallSignatureDeclaration extends Node {
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): CallSignatureDeclaration;
+}
+export declare class ConstructSignatureDeclaration extends Node {
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ConstructSignatureDeclaration;
+}
+export declare class ConstructorDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    fullSignature: TypeNode | undefined;
+    body: FunctionBody | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    endFlowNode: FlowNode | undefined;
+    returnFlowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined, fullSignature: TypeNode | undefined, body: FunctionBody | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ConstructorDeclaration;
+}
+export declare class GetAccessorDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: PropertyName;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    fullSignature: TypeNode | undefined;
+    body: FunctionBody | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    endFlowNode: FlowNode | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, name: PropertyName, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined, fullSignature: TypeNode | undefined, body: FunctionBody | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): GetAccessorDeclaration;
+}
+export declare class SetAccessorDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: PropertyName;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    fullSignature: TypeNode | undefined;
+    body: FunctionBody | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    endFlowNode: FlowNode | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, name: PropertyName, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined, fullSignature: TypeNode | undefined, body: FunctionBody | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): SetAccessorDeclaration;
+}
+export declare class IndexSignatureDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(modifiers: ModifierList | undefined, parameters: NodeList, type: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): IndexSignatureDeclaration;
+}
+export declare class MethodSignatureDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: PropertyName;
+    postfixToken: Token | undefined;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): MethodSignatureDeclaration;
+}
+export declare class MethodDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    asteriskToken: Token | undefined;
+    name: PropertyName;
+    postfixToken: Token | undefined;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    fullSignature: TypeNode | undefined;
+    body: FunctionBody | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    endFlowNode: FlowNode | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, asteriskToken: Token | undefined, name: PropertyName, postfixToken: Token | undefined, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined, fullSignature: TypeNode | undefined, body: FunctionBody | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): MethodDeclaration;
+}
+export declare class PropertySignatureDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: PropertyName;
+    postfixToken: Token | undefined;
+    type: TypeNode | undefined;
+    initializer: Expression | undefined;
+    symbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, type: TypeNode | undefined, initializer: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): PropertySignatureDeclaration;
+}
+export declare class PropertyDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: PropertyName;
+    postfixToken: Token | undefined;
+    type: TypeNode | undefined;
+    initializer: Expression | undefined;
+    symbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, type: TypeNode | undefined, initializer: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): PropertyDeclaration;
+}
+export declare class SemicolonClassElement extends Node {
+    symbol: Symbol | undefined;
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): SemicolonClassElement;
+}
+export declare class ClassStaticBlockDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    body: Block;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    returnFlowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, body: Block);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ClassStaticBlockDeclaration;
+}
+export declare class OmittedExpression extends Node {
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): OmittedExpression;
+}
+export declare class KeywordExpression extends Node {
+    flowNode: FlowNode | undefined;
+    constructor(kind: SyntaxKind);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): KeywordExpression;
+}
+export declare class StringLiteral extends Node {
+    text: string;
+    tokenFlags: TokenFlags;
+    constructor(text: string, tokenFlags: TokenFlags);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): StringLiteral;
+}
+export declare class NumericLiteral extends Node {
+    text: string;
+    tokenFlags: TokenFlags;
+    constructor(text: string, tokenFlags: TokenFlags);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NumericLiteral;
+}
+export declare class BigIntLiteral extends Node {
+    text: string;
+    tokenFlags: TokenFlags;
+    constructor(text: string, tokenFlags: TokenFlags);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): BigIntLiteral;
+}
+export declare class RegularExpressionLiteral extends Node {
+    text: string;
+    tokenFlags: TokenFlags;
+    constructor(text: string, tokenFlags: TokenFlags);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): RegularExpressionLiteral;
+}
+export declare class NoSubstitutionTemplateLiteral extends Node {
+    text: string;
+    templateFlags: TokenFlags;
+    symbol: Symbol | undefined;
+    constructor(text: string, templateFlags: TokenFlags);
+    get tokenFlags(): TokenFlags;
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NoSubstitutionTemplateLiteral;
+}
+export declare class BinaryExpression extends Node {
+    modifiers: ModifierList | undefined;
+    left: Expression;
+    type: TypeNode | undefined;
+    operatorToken: Token;
+    right: Expression;
+    symbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, left: Expression, type: TypeNode | undefined, operatorToken: Token, right: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): BinaryExpression;
+}
+export declare class PrefixUnaryExpression extends Node {
+    operator: SyntaxKind;
+    operand: Expression;
+    constructor(operator: SyntaxKind, operand: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): PrefixUnaryExpression;
+}
+export declare class PostfixUnaryExpression extends Node {
+    operand: Expression;
+    operator: SyntaxKind;
+    constructor(operand: Expression, operator: SyntaxKind);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): PostfixUnaryExpression;
+}
+export declare class YieldExpression extends Node {
+    asteriskToken: Token | undefined;
+    expression: Expression | undefined;
+    constructor(asteriskToken: Token | undefined, expression: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): YieldExpression;
+}
+export declare class ArrowFunction extends Node {
+    modifiers: ModifierList | undefined;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    fullSignature: TypeNode | undefined;
+    equalsGreaterThanToken: Token | undefined;
+    body: ConciseBody;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    endFlowNode: FlowNode | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined, fullSignature: TypeNode | undefined, equalsGreaterThanToken: Token | undefined, body: ConciseBody);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ArrowFunction;
+}
+export declare class FunctionExpression extends Node {
+    modifiers: ModifierList | undefined;
+    asteriskToken: Token | undefined;
+    name: Identifier | undefined;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    fullSignature: TypeNode | undefined;
+    body: FunctionBody;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    endFlowNode: FlowNode | undefined;
+    flowNode: FlowNode | undefined;
+    returnFlowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, asteriskToken: Token | undefined, name: Identifier | undefined, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined, fullSignature: TypeNode | undefined, body: FunctionBody);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): FunctionExpression;
+}
+export declare class AsExpression extends Node {
+    expression: Expression;
+    type: TypeNode;
+    constructor(expression: Expression, type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): AsExpression;
+}
+export declare class SatisfiesExpression extends Node {
+    expression: Expression;
+    type: TypeNode;
+    constructor(expression: Expression, type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): SatisfiesExpression;
+}
+export declare class ConditionalExpression extends Node {
+    condition: Expression;
+    questionToken: Token;
+    whenTrue: Expression;
+    colonToken: Token;
+    whenFalse: Expression;
+    constructor(condition: Expression, questionToken: Token, whenTrue: Expression, colonToken: Token, whenFalse: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ConditionalExpression;
+}
+export declare class PropertyAccessExpression extends Node {
+    expression: Expression;
+    questionDotToken: Token | undefined;
+    name: MemberName;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression, questionDotToken: Token | undefined, name: MemberName, flags: NodeFlags);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): PropertyAccessExpression;
+}
+export declare class ElementAccessExpression extends Node {
+    expression: Expression;
+    questionDotToken: Token | undefined;
+    argumentExpression: Expression;
+    flowNode: FlowNode | undefined;
+    constructor(expression: Expression, questionDotToken: Token | undefined, argumentExpression: Expression, flags: NodeFlags);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ElementAccessExpression;
+}
+export declare class CallExpression extends Node {
+    expression: Expression;
+    questionDotToken: Token | undefined;
+    typeArguments: NodeList | undefined;
+    arguments: NodeList;
+    symbol: Symbol | undefined;
+    constructor(expression: Expression, questionDotToken: Token | undefined, typeArguments: NodeList | undefined, args: NodeList, flags: NodeFlags);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): CallExpression;
+}
+export declare class NewExpression extends Node {
+    expression: Expression;
+    typeArguments: NodeList | undefined;
+    arguments: NodeList | undefined;
+    constructor(expression: Expression, typeArguments: NodeList | undefined, args: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NewExpression;
+}
+export declare class MetaProperty extends Node {
+    keywordToken: SyntaxKind;
+    name: Identifier;
+    flowNode: FlowNode | undefined;
+    constructor(keywordToken: SyntaxKind, name: Identifier);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): MetaProperty;
+}
+export declare class NonNullExpression extends Node {
+    expression: Expression;
+    constructor(expression: Expression, flags: NodeFlags);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NonNullExpression;
+}
+export declare class SpreadElement extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): SpreadElement;
+}
+export declare class TemplateExpression extends Node {
+    head: TemplateHead;
+    templateSpans: NodeList;
+    constructor(head: TemplateHead, templateSpans: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TemplateExpression;
+}
+export declare class TemplateSpan extends Node {
+    expression: Expression;
+    literal: TemplateMiddleOrTail;
+    constructor(expression: Expression, literal: TemplateMiddleOrTail);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TemplateSpan;
+}
+export declare class TaggedTemplateExpression extends Node {
+    tag: Expression;
+    questionDotToken: Token | undefined;
+    typeArguments: NodeList | undefined;
+    template: TemplateLiteral;
+    constructor(tag: Expression, questionDotToken: Token | undefined, typeArguments: NodeList | undefined, template: TemplateLiteral, flags: NodeFlags);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TaggedTemplateExpression;
+}
+export declare class ParenthesizedExpression extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ParenthesizedExpression;
+}
+export declare class ArrayLiteralExpression extends Node {
+    elements: NodeList;
+    multiLine: boolean;
+    constructor(elements: NodeList, multiLine: boolean);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ArrayLiteralExpression;
+}
+export declare class ObjectLiteralExpression extends Node {
+    properties: NodeList;
+    multiLine: boolean;
+    symbol: Symbol | undefined;
+    constructor(properties: NodeList, multiLine: boolean);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ObjectLiteralExpression;
+}
+export declare class SpreadAssignment extends Node {
+    expression: Expression;
+    symbol: Symbol | undefined;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): SpreadAssignment;
+}
+export declare class PropertyAssignment extends Node {
+    modifiers: ModifierList | undefined;
+    name: PropertyName;
+    postfixToken: Token | undefined;
+    type: TypeNode | undefined;
+    initializer: Expression;
+    symbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, type: TypeNode | undefined, initializer: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): PropertyAssignment;
+}
+export declare class ShorthandPropertyAssignment extends Node {
+    modifiers: ModifierList | undefined;
+    name: PropertyName;
+    postfixToken: Token | undefined;
+    type: TypeNode | undefined;
+    equalsToken: Token | undefined;
+    objectAssignmentInitializer: Expression | undefined;
+    symbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, name: PropertyName, postfixToken: Token | undefined, type: TypeNode | undefined, equalsToken: Token | undefined, objectAssignmentInitializer: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ShorthandPropertyAssignment;
+}
+export declare class DeleteExpression extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): DeleteExpression;
+}
+export declare class TypeOfExpression extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypeOfExpression;
+}
+export declare class VoidExpression extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): VoidExpression;
+}
+export declare class AwaitExpression extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): AwaitExpression;
+}
+export declare class TypeAssertion extends Node {
+    type: TypeNode;
+    expression: Expression;
+    constructor(type: TypeNode, expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypeAssertion;
+}
+export declare class KeywordTypeNode extends Node {
+    constructor(kind: SyntaxKind);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): KeywordTypeNode;
+}
+export declare class UnionTypeNode extends Node {
+    types: NodeList;
+    constructor(types: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): UnionTypeNode;
+}
+export declare class IntersectionTypeNode extends Node {
+    types: NodeList;
+    constructor(types: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): IntersectionTypeNode;
+}
+export declare class ConditionalTypeNode extends Node {
+    checkType: TypeNode;
+    extendsType: TypeNode;
+    trueType: TypeNode;
+    falseType: TypeNode;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ConditionalTypeNode;
+}
+export declare class TypeOperatorNode extends Node {
+    operator: SyntaxKind;
+    type: TypeNode;
+    constructor(operator: SyntaxKind, type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypeOperatorNode;
+}
+export declare class InferTypeNode extends Node {
+    typeParameter: TypeParameterDeclaration;
+    constructor(typeParameter: TypeParameterDeclaration);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): InferTypeNode;
+}
+export declare class ArrayTypeNode extends Node {
+    elementType: TypeNode;
+    constructor(elementType: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ArrayTypeNode;
+}
+export declare class IndexedAccessTypeNode extends Node {
+    objectType: TypeNode;
+    indexType: TypeNode;
+    constructor(objectType: TypeNode, indexType: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): IndexedAccessTypeNode;
+}
+export declare class TypeReferenceNode extends Node {
+    typeName: EntityName;
+    typeArguments: NodeList | undefined;
+    constructor(typeName: EntityName, typeArguments: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypeReferenceNode;
+}
+export declare class ExpressionWithTypeArguments extends Node {
+    expression: Expression;
+    typeArguments: NodeList | undefined;
+    constructor(expression: Expression, typeArguments: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ExpressionWithTypeArguments;
+}
+export declare class LiteralTypeNode extends Node {
+    literal: Node;
+    constructor(literal: Node);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): LiteralTypeNode;
+}
+export declare class ThisTypeNode extends Node {
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ThisTypeNode;
+}
+export declare class TypePredicateNode extends Node {
+    assertsModifier: Token | undefined;
+    parameterName: TypePredicateParameterName;
+    type: TypeNode | undefined;
+    constructor(assertsModifier: Token | undefined, parameterName: TypePredicateParameterName, type: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypePredicateNode;
+}
+export declare class ImportAttribute extends Node {
+    name: ImportAttributeName | undefined;
+    value: Expression;
+    constructor(name: ImportAttributeName | undefined, value: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ImportAttribute;
+}
+export declare class ImportAttributes extends Node {
+    token: SyntaxKind;
+    attributes: NodeList;
+    multiLine: boolean;
+    constructor(token: SyntaxKind, attributes: NodeList, multiLine: boolean);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ImportAttributes;
+}
+export declare class TypeQueryNode extends Node {
+    exprName: EntityName;
+    typeArguments: NodeList | undefined;
+    constructor(exprName: EntityName, typeArguments: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypeQueryNode;
+}
+export declare class MappedTypeNode extends Node {
+    readonlyToken: Token | undefined;
+    typeParameter: TypeParameterDeclaration;
+    nameType: TypeNode | undefined;
+    questionToken: Token | undefined;
+    type: TypeNode | undefined;
+    members: NodeList | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(readonlyToken: Token | undefined, typeParameter: TypeParameterDeclaration, nameType: TypeNode | undefined, questionToken: Token | undefined, type: TypeNode | undefined, members: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): MappedTypeNode;
+}
+export declare class TypeLiteralNode extends Node {
+    members: NodeList;
+    symbol: Symbol | undefined;
+    constructor(members: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypeLiteralNode;
+}
+export declare class TupleTypeNode extends Node {
+    elements: NodeList;
+    constructor(elements: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TupleTypeNode;
+}
+export declare class NamedTupleMember extends Node {
+    dotDotDotToken: Token | undefined;
+    name: Identifier;
+    questionToken: Token | undefined;
+    type: TypeNode;
+    symbol: Symbol | undefined;
+    constructor(dotDotDotToken: Token | undefined, name: Identifier, questionToken: Token | undefined, type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): NamedTupleMember;
+}
+export declare class OptionalTypeNode extends Node {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): OptionalTypeNode;
+}
+export declare class RestTypeNode extends Node {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): RestTypeNode;
+}
+export declare class ParenthesizedTypeNode extends Node {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ParenthesizedTypeNode;
+}
+export declare class FunctionTypeNode extends Node {
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): FunctionTypeNode;
+}
+export declare class ConstructorTypeNode extends Node {
+    modifiers: ModifierList | undefined;
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(modifiers: ModifierList | undefined, typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ConstructorTypeNode;
+}
+export declare class TemplateHead extends Node {
+    text: string;
+    rawText: string;
+    templateFlags: TokenFlags;
+    constructor(text: string, rawText: string, templateFlags: TokenFlags);
+    get tokenFlags(): TokenFlags;
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TemplateHead;
+}
+export declare class TemplateMiddle extends Node {
+    text: string;
+    rawText: string;
+    templateFlags: TokenFlags;
+    constructor(text: string, rawText: string, templateFlags: TokenFlags);
+    get tokenFlags(): TokenFlags;
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TemplateMiddle;
+}
+export declare class TemplateTail extends Node {
+    text: string;
+    rawText: string;
+    templateFlags: TokenFlags;
+    constructor(text: string, rawText: string, templateFlags: TokenFlags);
+    get tokenFlags(): TokenFlags;
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TemplateTail;
+}
+export declare class TemplateLiteralTypeNode extends Node {
+    head: TemplateHead;
+    templateSpans: NodeList;
+    constructor(head: TemplateHead, templateSpans: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TemplateLiteralTypeNode;
+}
+export declare class TemplateLiteralTypeSpan extends Node {
+    type: TypeNode;
+    literal: TemplateMiddleOrTail;
+    constructor(type: TypeNode, literal: TemplateMiddleOrTail);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TemplateLiteralTypeSpan;
+}
+export declare class PartiallyEmittedExpression extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): PartiallyEmittedExpression;
+}
+export declare class JsxElement extends Node {
+    openingElement: JsxOpeningElement;
+    children: NodeList;
+    closingElement: JsxClosingElement;
+    constructor(openingElement: JsxOpeningElement, children: NodeList, closingElement: JsxClosingElement);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxElement;
+}
+export declare class JsxAttributes extends Node {
+    properties: NodeList;
+    symbol: Symbol | undefined;
+    constructor(properties: NodeList);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxAttributes;
+}
+export declare class JsxNamespacedName extends Node {
+    namespace: Identifier;
+    name: Identifier;
+    constructor(namespace: Identifier, name: Identifier);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxNamespacedName;
+}
+export declare class JsxOpeningElement extends Node {
+    tagName: JsxTagNameExpression;
+    typeArguments: NodeList | undefined;
+    attributes: JsxAttributes;
+    constructor(tagName: JsxTagNameExpression, typeArguments: NodeList | undefined, attributes: JsxAttributes);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxOpeningElement;
+}
+export declare class JsxSelfClosingElement extends Node {
+    tagName: JsxTagNameExpression;
+    typeArguments: NodeList | undefined;
+    attributes: JsxAttributes;
+    constructor(tagName: JsxTagNameExpression, typeArguments: NodeList | undefined, attributes: JsxAttributes);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxSelfClosingElement;
+}
+export declare class JsxFragment extends Node {
+    openingFragment: JsxOpeningFragment;
+    children: NodeList;
+    closingFragment: JsxClosingFragment;
+    constructor(openingFragment: JsxOpeningFragment, children: NodeList, closingFragment: JsxClosingFragment);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxFragment;
+}
+export declare class JsxOpeningFragment extends Node {
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxOpeningFragment;
+}
+export declare class JsxClosingFragment extends Node {
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxClosingFragment;
+}
+export declare class JsxAttribute extends Node {
+    name: JsxAttributeName;
+    initializer: JsxAttributeValue | undefined;
+    symbol: Symbol | undefined;
+    constructor(name: JsxAttributeName, initializer: JsxAttributeValue | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxAttribute;
+}
+export declare class JsxSpreadAttribute extends Node {
+    expression: Expression;
+    constructor(expression: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxSpreadAttribute;
+}
+export declare class JsxClosingElement extends Node {
+    tagName: JsxTagNameExpression;
+    constructor(tagName: JsxTagNameExpression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxClosingElement;
+}
+export declare class JsxExpression extends Node {
+    dotDotDotToken: Token | undefined;
+    expression: Expression | undefined;
+    constructor(dotDotDotToken: Token | undefined, expression: Expression | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxExpression;
+}
+export declare class JsxText extends Node {
+    text: string;
+    containsOnlyTriviaWhiteSpaces: boolean;
+    constructor(text: string, containsOnlyTriviaWhiteSpaces: boolean);
+    get tokenFlags(): TokenFlags;
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JsxText;
+}
+export declare class SyntaxList extends Node {
+    children: Node[];
+    constructor(children: Node[]);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): SyntaxList;
+}
+export declare class JSDoc extends Node {
+    comment: NodeList;
+    tags: NodeList | undefined;
+    constructor(comment: NodeList, tags: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDoc;
+}
+export declare class JSDocTypeExpression extends Node {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocTypeExpression;
+}
+export declare class JSDocNonNullableType extends Node {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocNonNullableType;
+}
+export declare class JSDocNullableType extends Node {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocNullableType;
+}
+export declare class JSDocAllType extends Node {
+    constructor();
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocAllType;
+}
+export declare class JSDocVariadicType extends Node {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocVariadicType;
+}
+export declare class JSDocOptionalType extends Node {
+    type: TypeNode;
+    constructor(type: TypeNode);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocOptionalType;
+}
+export declare class JSDocTypeTag extends Node {
+    tagName: Identifier;
+    typeExpression: Node;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, typeExpression: Node, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocTypeTag;
+}
+export declare class JSDocUnknownTag extends Node {
+    tagName: Identifier;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocUnknownTag;
+}
+export declare class JSDocTemplateTag extends Node {
+    tagName: Identifier;
+    constraint: Node | undefined;
+    typeParameters: NodeList;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, constraint: Node | undefined, typeParameters: NodeList, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocTemplateTag;
+}
+export declare class JSDocReturnTag extends Node {
+    tagName: Identifier;
+    typeExpression: TypeNode | undefined;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, typeExpression: TypeNode | undefined, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocReturnTag;
+}
+export declare class JSDocPublicTag extends Node {
+    tagName: Identifier;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocPublicTag;
+}
+export declare class JSDocPrivateTag extends Node {
+    tagName: Identifier;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocPrivateTag;
+}
+export declare class JSDocProtectedTag extends Node {
+    tagName: Identifier;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocProtectedTag;
+}
+export declare class JSDocReadonlyTag extends Node {
+    tagName: Identifier;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocReadonlyTag;
+}
+export declare class JSDocOverrideTag extends Node {
+    tagName: Identifier;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocOverrideTag;
+}
+export declare class JSDocDeprecatedTag extends Node {
+    tagName: Identifier;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocDeprecatedTag;
+}
+export declare class JSDocSeeTag extends Node {
+    tagName: Identifier;
+    nameExpression: TypeNode | undefined;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, nameExpression: TypeNode | undefined, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocSeeTag;
+}
+export declare class JSDocImplementsTag extends Node {
+    tagName: Identifier;
+    className: ExpressionWithTypeArguments;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, className: ExpressionWithTypeArguments, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocImplementsTag;
+}
+export declare class JSDocAugmentsTag extends Node {
+    tagName: Identifier;
+    className: ExpressionWithTypeArguments;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, className: ExpressionWithTypeArguments, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocAugmentsTag;
+}
+export declare class JSDocSatisfiesTag extends Node {
+    tagName: Identifier;
+    typeExpression: TypeNode;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, typeExpression: TypeNode, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocSatisfiesTag;
+}
+export declare class JSDocThrowsTag extends Node {
+    tagName: Identifier;
+    typeExpression: TypeNode | undefined;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, typeExpression: TypeNode | undefined, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocThrowsTag;
+}
+export declare class JSDocThisTag extends Node {
+    tagName: Identifier;
+    typeExpression: TypeNode;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, typeExpression: TypeNode, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocThisTag;
+}
+export declare class JSDocImportTag extends Node {
+    tagName: Identifier;
+    importClause: ImportClause | undefined;
+    moduleSpecifier: Expression;
+    attributes: ImportAttributes | undefined;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, importClause: ImportClause | undefined, moduleSpecifier: Expression, attributes: ImportAttributes | undefined, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocImportTag;
+}
+export declare class JSDocCallbackTag extends Node {
+    tagName: Identifier;
+    typeExpression: TypeNode;
+    name: JSDocFullName | undefined;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, typeExpression: TypeNode, name: JSDocFullName | undefined, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocCallbackTag;
+}
+export declare class JSDocOverloadTag extends Node {
+    tagName: Identifier;
+    typeExpression: TypeNode;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, typeExpression: TypeNode, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocOverloadTag;
+}
+export declare class JSDocTypedefTag extends Node {
+    tagName: Identifier;
+    typeExpression: Node | undefined;
+    name: JSDocFullName | undefined;
+    comment: NodeList | undefined;
+    constructor(tagName: Identifier, typeExpression: Node | undefined, name: JSDocFullName | undefined, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocTypedefTag;
+}
+export declare class JSDocSignature extends Node {
+    typeParameters: NodeList | undefined;
+    parameters: NodeList;
+    type: TypeNode | undefined;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    constructor(typeParameters: NodeList | undefined, parameters: NodeList, type: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocSignature;
+}
+export declare class JSDocNameReference extends Node {
+    name: EntityName | undefined;
+    constructor(name: EntityName | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocNameReference;
+}
+export declare class ModuleDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    keyword: SyntaxKind;
+    name: ModuleName;
+    body: ModuleBody | undefined;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    localSymbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    endFlowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, keyword: SyntaxKind, name: ModuleName, body: ModuleBody | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ModuleDeclaration;
+}
+export declare class ImportEqualsDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    isTypeOnly: boolean;
+    name: Identifier;
+    moduleReference: ModuleReference;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    localSymbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, isTypeOnly: boolean, name: Identifier, moduleReference: ModuleReference);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ImportEqualsDeclaration;
+}
+export declare class ExportDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    isTypeOnly: boolean;
+    exportClause: NamedExportBindings | undefined;
+    moduleSpecifier: Expression | undefined;
+    attributes: ImportAttributes | undefined;
+    symbol: Symbol | undefined;
+    flowNode: FlowNode | undefined;
+    constructor(modifiers: ModifierList | undefined, isTypeOnly: boolean, exportClause: NamedExportBindings | undefined, moduleSpecifier: Expression | undefined, attributes: ImportAttributes | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ExportDeclaration;
+}
+export declare class ImportTypeNode extends Node {
+    isTypeOf: boolean;
+    argument: TypeNode;
+    attributes: ImportAttributes | undefined;
+    qualifier: EntityName | undefined;
+    typeArguments: NodeList | undefined;
+    constructor(isTypeOf: boolean, argument: TypeNode, attributes: ImportAttributes | undefined, qualifier: EntityName | undefined, typeArguments: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ImportTypeNode;
+}
+export declare class ImportClause extends Node {
+    phaseModifier: SyntaxKind | undefined;
+    name: Identifier | undefined;
+    namedBindings: NamedImportBindings | undefined;
+    symbol: Symbol | undefined;
+    localSymbol: Symbol | undefined;
+    constructor(phaseModifier: SyntaxKind | undefined, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ImportClause;
+}
+export declare class ImportSpecifier extends Node {
+    isTypeOnly: boolean;
+    propertyName: ModuleExportName | undefined;
+    name: Identifier;
+    symbol: Symbol | undefined;
+    localSymbol: Symbol | undefined;
+    constructor(isTypeOnly: boolean, propertyName: ModuleExportName | undefined, name: Identifier);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): ImportSpecifier;
+}
+export declare class JSDocText extends Node {
+    text: string;
+    constructor(text: string);
+    forEachChild(_v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocText;
+}
+export declare class JSDocLink extends Node {
+    name: EntityName | undefined;
+    text: string;
+    constructor(name: EntityName | undefined, text: string);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocLink;
+}
+export declare class JSDocLinkPlain extends Node {
+    name: EntityName | undefined;
+    text: string;
+    constructor(name: EntityName | undefined, text: string);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocLinkPlain;
+}
+export declare class JSDocLinkCode extends Node {
+    name: EntityName | undefined;
+    text: string;
+    constructor(name: EntityName | undefined, text: string);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocLinkCode;
+}
+export declare class TypeParameterDeclaration extends Node {
+    modifiers: ModifierList | undefined;
+    name: Identifier;
+    constraint: TypeNode | undefined;
+    expression: Expression | undefined;
+    defaultType: TypeNode | undefined;
+    symbol: Symbol | undefined;
+    constructor(modifiers: ModifierList | undefined, name: Identifier, constraint: TypeNode | undefined, expression: Expression | undefined, defaultType: TypeNode | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): TypeParameterDeclaration;
+}
+export declare class SyntheticReferenceExpression extends Node {
+    expression: Expression;
+    thisArg: Expression;
+    constructor(expression: Expression, thisArg: Expression);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): SyntheticReferenceExpression;
+}
+export declare class JSDocTypeLiteral extends Node {
+    jsdocPropertyTags: Node[] | undefined;
+    isArrayType: boolean;
+    symbol: Symbol | undefined;
+    constructor(jsdocPropertyTags: Node[] | undefined, isArrayType: boolean);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocTypeLiteral;
+}
+/** `@param` or `@property`. Children are visited name-first when the name precedes the type. */
+export declare class JSDocParameterOrPropertyTag extends Node {
+    tagName: Identifier;
+    name: EntityName;
+    isBracketed: boolean;
+    typeExpression: TypeNode | undefined;
+    isNameFirst: boolean;
+    comment: NodeList | undefined;
+    constructor(kind: SyntaxKind, tagName: Identifier, name: EntityName, isBracketed: boolean, typeExpression: TypeNode | undefined, isNameFirst: boolean, comment: NodeList | undefined);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    copy(): JSDocParameterOrPropertyTag;
+}
+export declare class SourceFile extends Node {
+    readonly fileName: string;
+    readonly path: string;
+    readonly text: string;
+    readonly externalModuleIndicatorOptions: ExternalModuleIndicatorOptions;
+    statements: NodeList;
+    endOfFileToken: Token;
+    diagnostics: Diagnostic[];
+    /** Diagnostics for TypeScript-only syntax in JavaScript files. */
+    jsDiagnostics: Diagnostic[];
+    jsDocDiagnostics: Diagnostic[];
+    languageVariant: LanguageVariant;
+    scriptKind: ScriptKind;
+    isDeclarationFile: boolean;
+    containsNonASCII: boolean;
+    /** Whether imports of Node built-ins use the `node:` prefix. */
+    usesUriStyleNodeCoreModules: Tristate;
+    /** Identifier and interned literal texts in parse order, with repeats. */
+    identifierTexts: string[];
+    identifierCount: number;
+    nodeCount: number;
+    textCount: number;
+    /** Module specifiers of imports, exports, `require` calls and `import()` types, in source order. */
+    imports: Node[];
+    /** Names of `declare module "x"` augmentations and `declare global` blocks in modules. */
+    moduleAugmentations: Node[];
+    ambientModuleNames: string[];
+    commentDirectives: readonly CommentDirective[];
+    pragmas: Pragma[];
+    referencedFiles: FileReference[];
+    typeReferenceDirectives: FileReference[];
+    libReferenceDirectives: FileReference[];
+    checkJsDirective: CheckJsDirective | undefined;
+    /** The first CommonJS `module.exports`/`exports.x` use in a JavaScript file. */
+    commonJSModuleIndicator: Node | undefined;
+    /** What makes this file a module: an import or export statement, `import.meta`, a JSX tag, or the file itself when forced. */
+    externalModuleIndicator: Node | undefined;
+    /** Nodes cloned by JSDoc reparsing, sorted by position. */
+    reparsedClones: Node[];
+    /** Whether JSDoc of TypeScript files is parsed on first use. */
+    hasLazyJSDoc: boolean;
+    /**
+     * The `JSDoc` nodes attached to this file's nodes by node id (eagerly in JS files, on demand in
+     * TS files): few nodes carry JSDoc, so it lives here instead of in a field of every node.
+     */
+    jsDocs: Map<number, Node[]> | undefined;
+    private diagnosticFileCache;
+    symbol: Symbol | undefined;
+    locals: SymbolTable | undefined;
+    nextContainer: Node | undefined;
+    isBound: boolean;
+    bindDiagnostics: Diagnostic[];
+    /** The flow at the end of the file. */
+    endFlowNode: FlowNode | undefined;
+    symbolCount: number;
+    /** Ambient modules with a `*` in their name, like `declare module "*.css"`. */
+    patternAmbientModules: PatternAmbientModule[];
+    /** UMD exports from `export as namespace N`. */
+    globalExports: SymbolTable | undefined;
+    /**
+     * By name, the first property of the unions of the file's object literals that leave the name
+     * missing (checker-symbol-types.ts `scanSiblingProperties`), where a parse thread scanned the file
+     * and could resolve the enums the scan needed.
+     */
+    siblingProperties: Map<string, Node> | undefined;
+    constructor(fileName: string, path: string, text: string, externalModuleIndicatorOptions: ExternalModuleIndicatorOptions, statements: NodeList, endOfFileToken: Token);
+    forEachChild(v: NodeVisitor): boolean;
+    setParentOfChildren(): void;
+    deepClone(): Node;
+    /** UTF-16 offsets of each line start. */
+    lineStarts(): readonly number[];
+    /**
+     * Computes the line starts, which are otherwise computed on first use, so that reading them later
+     * never writes to the file (UTF-8 offsets are computed on first use, `DiagnosticFile.computeCaches`).
+     */
+    computeCaches(): void;
+    /** Like `computeCaches`, from the UTF-16 code units of the text (at least `text.length` of them). */
+    computeCachesFromUnits(units: Uint16Array): void;
+    /** The file as diagnostics see it. */
+    diagnosticFile(): DiagnosticFile;
+    isJS(): boolean;
+}
+/** A `declare module "prefix*suffix"` pattern and its symbol. */
+export declare class PatternAmbientModule {
+    /** The module name; the part before `starIndex` is the prefix and after it the suffix. */
+    readonly text: string;
+    readonly starIndex: number;
+    readonly symbol: Symbol;
+    constructor(text: string, starIndex: number, symbol: Symbol);
+    matches(candidate: string): boolean;
+}
+export declare function getName(node: Node): Node | undefined;
+export declare function getModifiers(node: Node): ModifierList | undefined;
+export declare function getTypeParameters(node: Node): NodeList | undefined;
+export declare function getParameters(node: Node): NodeList | undefined;
+export declare function getType(node: Node): Node | undefined;
+export declare function getBody(node: Node): Node | undefined;
+export declare function getExpression(node: Node): Node | undefined;
+export declare function getInitializer(node: Node): Node | undefined;
+export declare function getPostfixToken(node: Node): Node | undefined;
+export declare function getTypeArguments(node: Node): NodeList | undefined;
+export declare function getArguments(node: Node): NodeList | undefined;
+export declare function getMembers(node: Node): NodeList | undefined;
+export declare function getStatements(node: Node): NodeList | undefined;
+export declare function getElements(node: Node): NodeList | undefined;
+export declare function getProperties(node: Node): NodeList | undefined;
+export declare function getTypeExpression(node: Node): Node | undefined;
+export declare function getTagName(node: Node): Node | undefined;
+export declare function getComment(node: Node): NodeList | undefined;
+export declare function getIsTypeOnly(node: Node): boolean;
+export declare function getImportClause(node: Node): Node | undefined;
+export declare function getModuleSpecifier(node: Node): Node | undefined;
+export declare function getDotDotDotToken(node: Node): Node | undefined;
+export declare function getAsteriskToken(node: Node): Node | undefined;
+export declare function getQuestionToken(node: Node): Node | undefined;
+export declare function getText(node: Node): string;
+export declare function getHeritageClauses(node: Node): NodeList | undefined;
+export declare function getLabel(node: Node): Node | undefined;
+export declare function getStatement(node: Node): Node | undefined;
+export declare function getLiteral(node: Node): Node | undefined;
+export declare function getPropertyName(node: Node): Node | undefined;
+export declare function isDeclarationNode(node: Node): boolean;
+export declare function isLocalsContainer(node: Node): boolean;
+export declare function getSymbol(node: Node): Symbol | undefined;
+export declare function setSymbol(node: Node, value: Symbol | undefined): void;
+export declare function getLocalSymbol(node: Node): Symbol | undefined;
+export declare function setLocalSymbol(node: Node, value: Symbol | undefined): void;
+export declare function getLocals(node: Node): SymbolTable | undefined;
+export declare function setLocals(node: Node, value: SymbolTable | undefined): void;
+export declare function getNextContainer(node: Node): Node | undefined;
+export declare function setNextContainer(node: Node, value: Node | undefined): void;
+export declare function getFlowNode(node: Node): FlowNode | undefined;
+export declare function setFlowNode(node: Node, value: FlowNode | undefined): void;
+export declare function getEndFlowNode(node: Node): FlowNode | undefined;
+export declare function setEndFlowNode(node: Node, value: FlowNode | undefined): void;
+export declare function getReturnFlowNode(node: Node): FlowNode | undefined;
+export declare function setReturnFlowNode(node: Node, value: FlowNode | undefined): void;