import CodeBlockWriter from "code-block-writer";
import {ts, SyntaxKind, CompilerOptions, EmitHint, ScriptKind, NewLineKind, LanguageVariant, ScriptTarget, TypeFlags, ObjectFlags, SymbolFlags, TypeFormatFlags, DiagnosticCategory} from "./typescript/ts";

/**
 * Compiler wrapper.
 */
export declare class TsSimpleAst {
    /**
     * Initializes a new instance.
     * @param options - Optional options.
     * @param fileSystem - Optional file system host. Useful for mocking access to the file system.
     */
    constructor(options?: Options, fileSystem?: FileSystemHost);
    /** Gets the manipulation settings. */
    readonly manipulationSettings: ManipulationSettingsContainer;
    /**
     * Adds an existing directory from the path or returns undefined if it doesn't exist.
     *
     * Will return the directory if it was already added.
     * @param dirPath - Path to add the directory at.
     */
    addDirectoryIfExists(dirPath: string): Directory | undefined;
    /**
     * Adds an existing directory from the path or throws if it doesn't exist.
     *
     * Will return the directory if it was already added.
     * @param dirPath - Path to add the directory at.
     * @throws DirectoryNotFoundError when the directory does not exist.
     */
    addExistingDirectory(dirPath: string): Directory;
    /**
     * Creates a directory at the specified path.
     * Note: Will not save the directory to disk until one of its source files is saved.
     * @param dirPath - Path to create the directory at.
     * @throws - InvalidOperationError if a directory already exists at the provided file path.
     */
    createDirectory(dirPath: string): Directory;
    /**
     * Gets a directory by the specified path or throws it doesn't exist.
     * @param dirPath - Path to create the directory at.
     */
    getDirectoryOrThrow(dirPath: string): Directory;
    /**
     * Gets a directory by the specified path or returns undefined if it doesn't exist.
     * @param dirPath - Directory path.
     */
    getDirectory(dirPath: string): Directory | undefined;
    /**
     * Gets all the directories.
     */
    getDirectories(): Directory[];
    /**
     * Gets the directories without a parent.
     */
    getRootDirectories(): Directory[];
    /**
     * Add source files based on a file glob.
     * @param fileGlobs - File glob to add files based on.
     * @returns The matched source files.
     */
    addExistingSourceFiles(fileGlob: string): SourceFile[];
    /**
     * Add source files based on file globs.
     * @param fileGlobs - File globs to add files based on.
     * @returns The matched source files.
     */
    addExistingSourceFiles(fileGlobs: string[]): SourceFile[];
    /**
     * Adds a source file from a file path if it exists or returns undefined.
     *
     * Will return the source file if it was already added.
     * @param filePath - File path to get the file from.
     */
    addSourceFileIfExists(filePath: string): SourceFile | undefined;
    /**
     * Adds an existing source file from a file path or throws if it doesn't exist.
     *
     * Will return the source file if it was already added.
     * @param filePath - File path to get the file from.
     * @throws FileNotFoundError when the file is not found.
     */
    addExistingSourceFile(filePath: string): SourceFile;
    /**
     * Adds all the source files from the specified tsconfig.json.
     *
     * Note that this is done by default when specifying a tsconfig file in the constructor and not explicitly setting the
     * addFilesFromTsConfig option to false.
     * @param tsConfigFilePath - File path to the tsconfig.json file.
     */
    addSourceFilesFromTsConfig(tsConfigFilePath: string): SourceFile[];
    /**
     * Creates a source file at the specified file path.
     *
     * Note: The file will not be created and saved to the file system until .save() is called on the source file.
     * @param filePath - File path of the source file.
     * @throws - InvalidOperationError if a source file already exists at the provided file path.
     */
    createSourceFile(filePath: string): SourceFile;
    /**
     * Creates a source file at the specified file path with the specified text.
     *
     * Note: The file will not be created and saved to the file system until .save() is called on the source file.
     * @param filePath - File path of the source file.
     * @param sourceFileText - Text of the source file.
     * @throws - InvalidOperationError if a source file already exists at the provided file path.
     */
    createSourceFile(filePath: string, sourceFileText: string): SourceFile;
    /**
     * Creates a source file at the specified file path with the specified text.
     *
     * Note: The file will not be created and saved to the file system until .save() is called on the source file.
     * @param filePath - File path of the source file.
     * @param structure - Structure that represents the source file.
     * @throws - InvalidOperationError if a source file already exists at the provided file path.
     */
    createSourceFile(filePath: string, structure: SourceFileStructure): SourceFile;
    /**
     * Removes a source file from the AST.
     * @param sourceFile - Source file to remove.
     * @returns True if removed.
     */
    removeSourceFile(sourceFile: SourceFile): boolean;
    /**
     * Gets a source file by a file name or file path. Throws an error if it doesn't exist.
     * @param fileNameOrPath - File name or path that the path could end with or equal.
     */
    getSourceFileOrThrow(fileNameOrPath: string): SourceFile;
    /**
     * Gets a source file by a search function. Throws an erorr if it doesn't exist.
     * @param searchFunction - Search function.
     */
    getSourceFileOrThrow(searchFunction: (file: SourceFile) => boolean): SourceFile;
    /**
     * Gets a source file by a file name or file path. Returns undefined if none exists.
     * @param fileNameOrPath - File name or path that the path could end with or equal.
     */
    getSourceFile(fileNameOrPath: string): SourceFile | undefined;
    /**
     * Gets a source file by a search function. Returns undefined if none exists.
     * @param searchFunction - Search function.
     */
    getSourceFile(searchFunction: (file: SourceFile) => boolean): SourceFile | undefined;
    /**
     * Gets all the source files contained in the compiler wrapper.
     * @param globPattern - Glob pattern for filtering out the source files.
     */
    getSourceFiles(): SourceFile[];
    /**
     * Gets all the source files contained in the compiler wrapper that match a pattern.
     * @param globPattern - Glob pattern for filtering out the source files.
     */
    getSourceFiles(globPattern: string): SourceFile[];
    /**
     * Gets all the source files contained in the compiler wrapper that match the passed in patterns.
     * @param globPatterns - Glob patterns for filtering out the source files.
     */
    getSourceFiles(globPatterns: string[]): SourceFile[];
    /**
     * Saves all the unsaved source files.
     */
    saveUnsavedSourceFiles(): Promise<void[]>;
    /**
     * Saves all the unsaved source files synchronously.
     *
     * Remarks: This might be very slow compared to the asynchronous version if there are a lot of files.
     */
    saveUnsavedSourceFilesSync(): void;
    /**
     * Enables logging to the console.
     * @param enabled - Enabled.
     */
    enableLogging(enabled?: boolean): void;
    private getUnsavedSourceFiles();
    /**
     * Gets the compiler diagnostics.
     */
    getDiagnostics(): Diagnostic[];
    /**
     * Gets the pre-emit diagnostics.
     */
    getPreEmitDiagnostics(): Diagnostic[];
    /**
     * Gets the language service.
     */
    getLanguageService(): LanguageService;
    /**
     * Gets the program.
     */
    getProgram(): Program;
    /**
     * Gets the type checker.
     */
    getTypeChecker(): TypeChecker;
    /**
     * Gets the file system.
     */
    getFileSystem(): FileSystemHost;
    /**
     * Emits all the source files.
     * @param emitOptions - Optional emit options.
     */
    emit(emitOptions?: EmitOptions): EmitResult;
    /**
     * Gets the compiler options.
     */
    getCompilerOptions(): CompilerOptions;
    /**
     * Forgets the nodes created in the scope of the passed in block.
     *
     * This is an advanced method that can be used to easily "forget" all the nodes created within the scope of the block.
     * @param block - Block of code to run.
     */
    forgetNodesCreatedInBlock(block: (remember: (...node: Node[]) => void) => void): void;
    /**
     * Forgets the nodes created in the scope of the passed in block asynchronously.
     *
     * This is an advanced method that can be used to easily "forget" all the nodes created within the scope of the block.
     * @param block - Block of code to run.
     */
    forgetNodesCreatedInBlock(block: (remember: (...node: Node[]) => void) => Promise<void>): void;
}
export default TsSimpleAst;

export interface Options {
    /** Compiler options */
    compilerOptions?: CompilerOptions;
    /** File path to the tsconfig.json file */
    tsConfigFilePath?: string;
    /** Whether to add the source files from the specified tsconfig.json or not. Defaults to true. */
    addFilesFromTsConfig?: boolean;
    /** Manipulation settings */
    manipulationSettings?: Partial<ManipulationSettings>;
    /** Whether to use a virtual file system. */
    useVirtualFileSystem?: boolean;
}
export interface FileSystemHost {
    delete(path: string): Promise<void>;
    deleteSync(path: string): void;
    readDirSync(dirPath: string): string[];
    readFile(filePath: string, encoding?: string): Promise<string>;
    readFileSync(filePath: string, encoding?: string): string;
    writeFile(filePath: string, fileText: string): Promise<void>;
    writeFileSync(filePath: string, fileText: string): void;
    mkdir(dirPath: string): Promise<void>;
    mkdirSync(dirPath: string): void;
    fileExists(filePath: string): Promise<boolean>;
    fileExistsSync(filePath: string): boolean;
    directoryExists(dirPath: string): Promise<boolean>;
    directoryExistsSync(dirPath: string): boolean;
    getCurrentDirectory(): string;
    glob(patterns: string[]): string[];
}

export declare class Directory {
    private readonly _path;
    private _global;
    private readonly _pathParts;
    private _parent;
    private _directories;
    private _sourceFiles;
    /**
     * Checks if this directory is an ancestor of the provided directory.
     * @param possibleDescendant - Directory or source file that's a possible descendant.
     */
    isAncestorOf(possibleDescendant: Directory | SourceFile): boolean;
    /**
     * Checks if this directory is a descendant of the provided directory.
     * @param possibleAncestor - Directory or source file that's a possible ancestor.
     */
    isDescendantOf(possibleAncestor: Directory): boolean;
    /**
     * Gets the path to the directory.
     */
    getPath(): string;
    /**
     * Gets the directory path's base name.
     */
    getBaseName(): string;
    /**
     * Gets the parent directory or throws if it doesn't exist or was never added to the AST.
     */
    getParentOrThrow(): Directory;
    /**
     * Gets the parent directory if it exists and was added to the AST.
     */
    getParent(): Directory | undefined;
    /**
     * Gets a child directory with the specified path or throws if not found.
     * @param path - Relative path from this directory or absolute path.
     */
    getDirectoryOrThrow(path: string): Directory;
    /**
     * Gets a child directory by the specified condition or throws if not found.
     * @param condition - Condition to check the directory with.
     */
    getDirectoryOrThrow(condition: (directory: Directory) => boolean): Directory;
    /**
     * Gets a directory with the specified path or undefined if not found.
     * @param path - Relative path from this directory or absolute path.
     */
    getDirectory(path: string): Directory | undefined;
    /**
     * Gets a child directory by the specified condition or undefined if not found.
     * @param condition - Condition to check the directory with.
     */
    getDirectory(condition: (directory: Directory) => boolean): Directory | undefined;
    /**
     * Gets a child source file with the specified path or throws if not found.
     * @param path - Relative or absolute path to the file.
     */
    getSourceFileOrThrow(path: string): SourceFile;
    /**
     * Gets a child source file by the specified condition or throws if not found.
     * @param condition - Condition to check the source file with.
     */
    getSourceFileOrThrow(condition: (sourceFile: SourceFile) => boolean): SourceFile;
    /**
     * Gets a child source file with the specified path or undefined if not found.
     * @param path - Relative or absolute path to the file.
     */
    getSourceFile(path: string): SourceFile | undefined;
    /**
     * Gets a child source file by the specified condition or undefined if not found.
     * @param condition - Condition to check the source file with.
     */
    getSourceFile(condition: (sourceFile: SourceFile) => boolean): SourceFile | undefined;
    /**
     * Gets the child directories.
     */
    getDirectories(): Directory[];
    /**
     * Gets the source files within this directory.
     */
    getSourceFiles(): SourceFile[];
    /**
     * Gets the source files in the current directory and all the descendant directories.
     */
    getDescendantSourceFiles(): SourceFile[];
    /**
     * Gets the descendant directories.
     */
    getDescendantDirectories(): Directory[];
    /**
     * Adds an existing directory to the AST from the relative path or directory name, or returns undefined if it doesn't exist.
     *
     * Will return the directory if it was already added.
     * @param path - Directory name or path to the directory that should be added.
     */
    addDirectoryIfExists(path: string): Directory | undefined;
    /**
     * Adds an existing directory to the AST from the relative path or directory name, or throws if it doesn't exist.
     *
     * Will return the directory if it was already added.
     * @param path - Directory name or path to the directory that should be added.
     * @throws DirectoryNotFoundError if the directory does not exist.
     */
    addExistingDirectory(path: string): Directory;
    /**
     * Creates a directory if it doesn't exist.
     * @param path - Relative or absolute path to the directory that should be created.
     */
    createDirectory(path: string): Directory;
    /**
     * Creates a source file in the AST, relative to this directory.
     *
     * Note: The file will not be created and saved to the file system until .save() is called on the source file.
     * @param relativeFilePath - Relative file path of the source file to create.
     * @throws - InvalidOperationError if a source file already exists at the provided file name.
     */
    createSourceFile(relativeFilePath: string): SourceFile;
    /**
     * Creates a source file in the AST, relative to this directory.
     *
     * Note: The file will not be created and saved to the file system until .save() is called on the source file.
     * @param relativeFilePath - Relative file path of the source file to create.
     * @param sourceFileText - Text of the source file.
     * @throws - InvalidOperationError if a source file already exists at the provided file name.
     */
    createSourceFile(relativeFilePath: string, sourceFileText: string): SourceFile;
    /**
     * Creates a source file in the AST, relative to this directory.
     *
     * Note: The file will not be created and saved to the file system until .save() is called on the source file.
     * @param relativeFilePath - Relative file path of the source file to create.
     * @param structure - Structure that represents the source file.
     * @throws - InvalidOperationError if a source file already exists at the provided file name.
     */
    createSourceFile(relativeFilePath: string, structure: SourceFileStructure): SourceFile;
    /**
     * Adds an existing source file to the AST, relative to this directory, or returns undefined.
     *
     * Will return the source file if it was already added.
     * @param relativeFilePath - Relative file path to add.
     */
    addSourceFileIfExists(relativeFilePath: string): SourceFile | undefined;
    /**
     * Adds an existing source file to the AST, relative to this directory, or throws if it doesn't exist.
     *
     * Will return the source file if it was already added.
     * @param relativeFilePath - Relative file path to add.
     * @throws FileNotFoundError when the file doesn't exist.
     */
    addExistingSourceFile(relativeFilePath: string): SourceFile;
    /**
     * Emits the files in the directory.
     * @param options - Options for emitting.
     */
    emit(options?: {
        emitOnlyDtsFiles?: boolean;
        outDir?: string;
        declarationDir?: string;
    }): Promise<DirectoryEmitResult>;
    /**
     * Emits the files in the directory synchronously.
     *
     * Remarks: This might be very slow compared to the asynchronous version if there are a lot of files.
     * @param options - Options for emitting.
     */
    emitSync(options?: {
        emitOnlyDtsFiles?: boolean;
        outDir?: string;
        declarationDir?: string;
    }): DirectoryEmitResult;
    private _emitInternal(options?);
    /**
     * Copies a directory to a new directory.
     * @param relativeOrAbsolutePath - The relative or absolute path to the new directory.
     * @param options - Options.
     * @returns The directory the copy was made to.
     */
    copy(relativeOrAbsolutePath: string, options?: {
        overwrite?: boolean;
    }): Directory;
    /**
     * Asyncronously deletes the directory and all its descendants.
     *
     * WARNING: This will delete the directory from the file system.
     */
    delete(): Promise<void>;
    /**
     * Synchronously deletes the directory and all its descendants.
     *
     * WARNING: This will delete the directory from the file system.
     */
    deleteSync(): void;
    /**
     * Removes the directory and all its descendants from the AST.
     *
     * Note: Does not delete the directory from the file system.
     */
    remove(): void;
    /**
     * Saves all the unsaved descendant source files.
     */
    saveUnsavedSourceFiles(): Promise<void[]>;
    /**
     * Saves all the unsaved descendant source files synchronously.
     *
     * Remarks: This might be very slow compared to the asynchronous version if there are a lot of files.
     */
    saveUnsavedSourceFilesSync(): void;
    private throwIfDeletedOrRemoved();
    private _getUnsavedSourceFiles();
}
export declare class DirectoryEmitResult {
    private readonly _emitSkipped;
    private readonly _outputFilePaths;
    /**
     * Gets if the emit was skipped.
     */
    getEmitSkipped(): boolean;
    /**
     * Gets the output file paths.
     */
    getOutputFilePaths(): string[];
}

/**
 * Creates a wrapped node from a compiler node.
 * @param node - Node to create a wrapped node from.
 * @param info - Info for creating the wrapped node.
 */
export declare function createWrappedNode<T extends ts.Node = ts.Node>(node: T, opts?: CreateWrappedNodeOptions): Node<T>;

export interface CreateWrappedNodeOptions {
    /**
     * Compiler options.
     */
    compilerOptions?: CompilerOptions;
    /**
     * Optional source file of the node. Will make it not bother going up the tree to find the source file.
     */
    sourceFile?: ts.SourceFile;
    /**
     * Type checker.
     */
    typeChecker?: ts.TypeChecker;
}

/**
 * Gets the compiler options from a specified tsconfig.json
 * @param filePath - File path to the tsconfig.json.
 * @param fileSystemHost - Optional file system host.
 */
export declare function getCompilerOptionsFromTsConfig(filePath: string, fileSystemHost?: FileSystemHost): {
    options: CompilerOptions;
    errors: Diagnostic[];
};

/**
 * Prints the provided node using the compiler's printer.
 * @param node - Compiler node.
 * @param options - Options.
 */
export declare function printNode(node: ts.Node, options?: PrintNodeOptions): string;

/**
 * Prints the provided node using the compiler's printer.
 * @param node - Compiler node.
 * @param sourceFile - Compiler source file.
 * @param options - Options.
 */
export declare function printNode(node: ts.Node, sourceFile: ts.SourceFile, options?: PrintNodeOptions): string;

/**
 * Options for printing a node.
 */
export interface PrintNodeOptions {
    /**
     * Whether to remove comments or not.
     */
    removeComments?: boolean;
    /**
     * New line kind.
     *
     * Defaults to line feed.
     */
    newLineKind?: NewLineKind;
    /**
     * From the compiler api: "A value indicating the purpose of a node. This is primarily used to
     * distinguish between an `Identifier` used in an expression position, versus an
     * `Identifier` used as an `IdentifierName` as part of a declaration. For most nodes you
     * should just pass `Unspecified`."
     *
     * Defaults to `Unspecified`.
     */
    emitHint?: EmitHint;
    /**
     * The script kind.
     *
     * Defaults to TSX. This is only useful when not using a wrapped node and not providing a source file.
     */
    scriptKind?: ScriptKind;
}
export declare type Constructor<T> = new (...args: any[]) => T;

/**
 * Type guards for checking the type of a node.
 */
export declare class TypeGuards {
    private constructor();
    /**
     * Gets if the node has an expression.
     * @param node - Node to check.
     */
    static hasExpression(node: Node): node is Node & {
        getExpression(): Expression;
    };
    /**
     * Gets if the node has a name.
     * @param node - Node to check.
     */
    static hasName(node: Node): node is Node & {
        getName(): string;
    };
    /**
     * Gets if the node is an AbstractableNode.
     * @param node - Node to check.
     */
    static isAbstractableNode(node: Node): node is AbstractableNode & Node;
    /**
     * Gets if the node is an AmbientableNode.
     * @param node - Node to check.
     */
    static isAmbientableNode(node: Node): node is AmbientableNode & Node;
    /**
     * Gets if the node is an ArgumentedNode.
     * @param node - Node to check.
     */
    static isArgumentedNode(node: Node): node is ArgumentedNode & Node;
    /**
     * Gets if the node is an ArrayLiteralExpression.
     * @param node - Node to check.
     */
    static isArrayLiteralExpression(node: Node): node is ArrayLiteralExpression;
    /**
     * Gets if the node is an ArrayTypeNode.
     * @param node - Node to check.
     */
    static isArrayTypeNode(node: Node): node is ArrayTypeNode;
    /**
     * Gets if the node is an ArrowFunction.
     * @param node - Node to check.
     */
    static isArrowFunction(node: Node): node is ArrowFunction;
    /**
     * Gets if the node is an AsExpression.
     * @param node - Node to check.
     */
    static isAsExpression(node: Node): node is AsExpression;
    /**
     * Gets if the node is an AsyncableNode.
     * @param node - Node to check.
     */
    static isAsyncableNode(node: Node): node is AsyncableNode & Node;
    /**
     * Gets if the node is an AwaitExpression.
     * @param node - Node to check.
     */
    static isAwaitExpression(node: Node): node is AwaitExpression;
    /**
     * Gets if the node is an AwaitableNode.
     * @param node - Node to check.
     */
    static isAwaitableNode(node: Node): node is AwaitableNode & Node;
    /**
     * Gets if the node is a BinaryExpression.
     * @param node - Node to check.
     */
    static isBinaryExpression(node: Node): node is BinaryExpression;
    /**
     * Gets if the node is a BindingNamedNode.
     * @param node - Node to check.
     */
    static isBindingNamedNode(node: Node): node is BindingNamedNode & Node;
    /**
     * Gets if the node is a Block.
     * @param node - Node to check.
     */
    static isBlock(node: Node): node is Block;
    /**
     * Gets if the node is a BodiedNode.
     * @param node - Node to check.
     */
    static isBodiedNode(node: Node): node is BodiedNode & Node;
    /**
     * Gets if the node is a BodyableNode.
     * @param node - Node to check.
     */
    static isBodyableNode(node: Node): node is BodyableNode & Node;
    /**
     * Gets if the node is a BooleanLiteral.
     * @param node - Node to check.
     */
    static isBooleanLiteral(node: Node): node is BooleanLiteral;
    /**
     * Gets if the node is a BreakStatement.
     * @param node - Node to check.
     */
    static isBreakStatement(node: Node): node is BreakStatement;
    /**
     * Gets if the node is a CallExpression.
     * @param node - Node to check.
     */
    static isCallExpression(node: Node): node is CallExpression;
    /**
     * Gets if the node is a CallSignatureDeclaration.
     * @param node - Node to check.
     */
    static isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration;
    /**
     * Gets if the node is a CaseBlock.
     * @param node - Node to check.
     */
    static isCaseBlock(node: Node): node is CaseBlock;
    /**
     * Gets if the node is a CaseClause.
     * @param node - Node to check.
     */
    static isCaseClause(node: Node): node is CaseClause;
    /**
     * Gets if the node is a CatchClause.
     * @param node - Node to check.
     */
    static isCatchClause(node: Node): node is CatchClause;
    /**
     * Gets if the node is a ChildOrderableNode.
     * @param node - Node to check.
     */
    static isChildOrderableNode(node: Node): node is ChildOrderableNode & Node;
    /**
     * Gets if the node is a ClassDeclaration.
     * @param node - Node to check.
     */
    static isClassDeclaration(node: Node): node is ClassDeclaration;
    /**
     * Gets if the node is a CommaListExpression.
     * @param node - Node to check.
     */
    static isCommaListExpression(node: Node): node is CommaListExpression;
    /**
     * Gets if the node is a ComputedPropertyName.
     * @param node - Node to check.
     */
    static isComputedPropertyName(node: Node): node is ComputedPropertyName;
    /**
     * Gets if the node is a ConditionalExpression.
     * @param node - Node to check.
     */
    static isConditionalExpression(node: Node): node is ConditionalExpression;
    /**
     * Gets if the node is a ConstructSignatureDeclaration.
     * @param node - Node to check.
     */
    static isConstructSignatureDeclaration(node: Node): node is ConstructSignatureDeclaration;
    /**
     * Gets if the node is a ConstructorDeclaration.
     * @param node - Node to check.
     */
    static isConstructorDeclaration(node: Node): node is ConstructorDeclaration;
    /**
     * Gets if the node is a ConstructorTypeNode.
     * @param node - Node to check.
     */
    static isConstructorTypeNode(node: Node): node is ConstructorTypeNode;
    /**
     * Gets if the node is a ContinueStatement.
     * @param node - Node to check.
     */
    static isContinueStatement(node: Node): node is ContinueStatement;
    /**
     * Gets if the node is a DebuggerStatement.
     * @param node - Node to check.
     */
    static isDebuggerStatement(node: Node): node is DebuggerStatement;
    /**
     * Gets if the node is a DeclarationNamedNode.
     * @param node - Node to check.
     */
    static isDeclarationNamedNode(node: Node): node is DeclarationNamedNode & Node;
    /**
     * Gets if the node is a DecoratableNode.
     * @param node - Node to check.
     */
    static isDecoratableNode(node: Node): node is DecoratableNode & Node;
    /**
     * Gets if the node is a Decorator.
     * @param node - Node to check.
     */
    static isDecorator(node: Node): node is Decorator;
    /**
     * Gets if the node is a DefaultClause.
     * @param node - Node to check.
     */
    static isDefaultClause(node: Node): node is DefaultClause;
    /**
     * Gets if the node is a DeleteExpression.
     * @param node - Node to check.
     */
    static isDeleteExpression(node: Node): node is DeleteExpression;
    /**
     * Gets if the node is a DoStatement.
     * @param node - Node to check.
     */
    static isDoStatement(node: Node): node is DoStatement;
    /**
     * Gets if the node is an ElementAccessExpression.
     * @param node - Node to check.
     */
    static isElementAccessExpression(node: Node): node is ElementAccessExpression;
    /**
     * Gets if the node is an EmptyStatement.
     * @param node - Node to check.
     */
    static isEmptyStatement(node: Node): node is EmptyStatement;
    /**
     * Gets if the node is an EnumDeclaration.
     * @param node - Node to check.
     */
    static isEnumDeclaration(node: Node): node is EnumDeclaration;
    /**
     * Gets if the node is an EnumMember.
     * @param node - Node to check.
     */
    static isEnumMember(node: Node): node is EnumMember;
    /**
     * Gets if the node is an ExportAssignment.
     * @param node - Node to check.
     */
    static isExportAssignment(node: Node): node is ExportAssignment;
    /**
     * Gets if the node is an ExportDeclaration.
     * @param node - Node to check.
     */
    static isExportDeclaration(node: Node): node is ExportDeclaration;
    /**
     * Gets if the node is an ExportSpecifier.
     * @param node - Node to check.
     */
    static isExportSpecifier(node: Node): node is ExportSpecifier;
    /**
     * Gets if the node is an ExportableNode.
     * @param node - Node to check.
     */
    static isExportableNode(node: Node): node is ExportableNode & Node;
    /**
     * Gets if the node is an Expression.
     * @param node - Node to check.
     */
    static isExpression(node: Node): node is Expression;
    /**
     * Gets if the node is an ExpressionStatement.
     * @param node - Node to check.
     */
    static isExpressionStatement(node: Node): node is ExpressionStatement;
    /**
     * Gets if the node is an ExpressionWithTypeArguments.
     * @param node - Node to check.
     */
    static isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments;
    /**
     * Gets if the node is an ExpressionedNode.
     * @param node - Node to check.
     */
    static isExpressionedNode(node: Node): node is ExpressionedNode & Node;
    /**
     * Gets if the node is an ExtendsClauseableNode.
     * @param node - Node to check.
     */
    static isExtendsClauseableNode(node: Node): node is ExtendsClauseableNode & Node;
    /**
     * Gets if the node is an ExternalModuleReference.
     * @param node - Node to check.
     */
    static isExternalModuleReference(node: Node): node is ExternalModuleReference;
    /**
     * Gets if the node is a ForInStatement.
     * @param node - Node to check.
     */
    static isForInStatement(node: Node): node is ForInStatement;
    /**
     * Gets if the node is a ForOfStatement.
     * @param node - Node to check.
     */
    static isForOfStatement(node: Node): node is ForOfStatement;
    /**
     * Gets if the node is a ForStatement.
     * @param node - Node to check.
     */
    static isForStatement(node: Node): node is ForStatement;
    /**
     * Gets if the node is a FunctionDeclaration.
     * @param node - Node to check.
     */
    static isFunctionDeclaration(node: Node): node is FunctionDeclaration;
    /**
     * Gets if the node is a FunctionExpression.
     * @param node - Node to check.
     */
    static isFunctionExpression(node: Node): node is FunctionExpression;
    /**
     * Gets if the node is a FunctionLikeDeclaration.
     * @param node - Node to check.
     */
    static isFunctionLikeDeclaration(node: Node): node is FunctionLikeDeclaration & Node;
    /**
     * Gets if the node is a FunctionTypeNode.
     * @param node - Node to check.
     */
    static isFunctionTypeNode(node: Node): node is FunctionTypeNode;
    /**
     * Gets if the node is a GeneratorableNode.
     * @param node - Node to check.
     */
    static isGeneratorableNode(node: Node): node is GeneratorableNode & Node;
    /**
     * Gets if the node is a GetAccessorDeclaration.
     * @param node - Node to check.
     */
    static isGetAccessorDeclaration(node: Node): node is GetAccessorDeclaration;
    /**
     * Gets if the node is a HeritageClause.
     * @param node - Node to check.
     */
    static isHeritageClause(node: Node): node is HeritageClause;
    /**
     * Gets if the node is a HeritageClauseableNode.
     * @param node - Node to check.
     */
    static isHeritageClauseableNode(node: Node): node is HeritageClauseableNode & Node;
    /**
     * Gets if the node is a Identifier.
     * @param node - Node to check.
     */
    static isIdentifier(node: Node): node is Identifier;
    /**
     * Gets if the node is a IfStatement.
     * @param node - Node to check.
     */
    static isIfStatement(node: Node): node is IfStatement;
    /**
     * Gets if the node is a ImplementsClauseableNode.
     * @param node - Node to check.
     */
    static isImplementsClauseableNode(node: Node): node is ImplementsClauseableNode & Node;
    /**
     * Gets if the node is a ImportDeclaration.
     * @param node - Node to check.
     */
    static isImportDeclaration(node: Node): node is ImportDeclaration;
    /**
     * Gets if the node is a ImportEqualsDeclaration.
     * @param node - Node to check.
     */
    static isImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration;
    /**
     * Gets if the node is a ImportExpression.
     * @param node - Node to check.
     */
    static isImportExpression(node: Node): node is ImportExpression;
    /**
     * Gets if the node is a ImportSpecifier.
     * @param node - Node to check.
     */
    static isImportSpecifier(node: Node): node is ImportSpecifier;
    /**
     * Gets if the node is a IndexSignatureDeclaration.
     * @param node - Node to check.
     */
    static isIndexSignatureDeclaration(node: Node): node is IndexSignatureDeclaration;
    /**
     * Gets if the node is a InitializerExpressionableNode.
     * @param node - Node to check.
     */
    static isInitializerExpressionableNode(node: Node): node is InitializerExpressionableNode & Node;
    /**
     * Gets if the node is a InitializerGetExpressionableNode.
     * @param node - Node to check.
     */
    static isInitializerGetExpressionableNode(node: Node): node is InitializerGetExpressionableNode & Node;
    /**
     * Gets if the node is a InitializerSetExpressionableNode.
     * @param node - Node to check.
     */
    static isInitializerSetExpressionableNode(node: Node): node is InitializerSetExpressionableNode & Node;
    /**
     * Gets if the node is a InterfaceDeclaration.
     * @param node - Node to check.
     */
    static isInterfaceDeclaration(node: Node): node is InterfaceDeclaration;
    /**
     * Gets if the node is a IntersectionTypeNode.
     * @param node - Node to check.
     */
    static isIntersectionTypeNode(node: Node): node is IntersectionTypeNode;
    /**
     * Gets if the node is a IterationStatement.
     * @param node - Node to check.
     */
    static isIterationStatement(node: Node): node is IterationStatement;
    /**
     * Gets if the node is a JSDoc.
     * @param node - Node to check.
     */
    static isJSDoc(node: Node): node is JSDoc;
    /**
     * Gets if the node is a JSDocAugmentsTag.
     * @param node - Node to check.
     */
    static isJSDocAugmentsTag(node: Node): node is JSDocAugmentsTag;
    /**
     * Gets if the node is a JSDocClassTag.
     * @param node - Node to check.
     */
    static isJSDocClassTag(node: Node): node is JSDocClassTag;
    /**
     * Gets if the node is a JSDocParameterTag.
     * @param node - Node to check.
     */
    static isJSDocParameterTag(node: Node): node is JSDocParameterTag;
    /**
     * Gets if the node is a JSDocPropertyLikeTag.
     * @param node - Node to check.
     */
    static isJSDocPropertyLikeTag(node: Node): node is JSDocPropertyLikeTag & Node;
    /**
     * Gets if the node is a JSDocPropertyTag.
     * @param node - Node to check.
     */
    static isJSDocPropertyTag(node: Node): node is JSDocPropertyTag;
    /**
     * Gets if the node is a JSDocReturnTag.
     * @param node - Node to check.
     */
    static isJSDocReturnTag(node: Node): node is JSDocReturnTag;
    /**
     * Gets if the node is a JSDocTag.
     * @param node - Node to check.
     */
    static isJSDocTag(node: Node): node is JSDocTag;
    /**
     * Gets if the node is a JSDocTypeTag.
     * @param node - Node to check.
     */
    static isJSDocTypeTag(node: Node): node is JSDocTypeTag;
    /**
     * Gets if the node is a JSDocTypedefTag.
     * @param node - Node to check.
     */
    static isJSDocTypedefTag(node: Node): node is JSDocTypedefTag;
    /**
     * Gets if the node is a JSDocUnknownTag.
     * @param node - Node to check.
     */
    static isJSDocUnknownTag(node: Node): node is JSDocUnknownTag;
    /**
     * Gets if the node is a JSDocableNode.
     * @param node - Node to check.
     */
    static isJSDocableNode(node: Node): node is JSDocableNode & Node;
    /**
     * Gets if the node is a JsxAttribute.
     * @param node - Node to check.
     */
    static isJsxAttribute(node: Node): node is JsxAttribute;
    /**
     * Gets if the node is a JsxClosingElement.
     * @param node - Node to check.
     */
    static isJsxClosingElement(node: Node): node is JsxClosingElement;
    /**
     * Gets if the node is a JsxClosingFragment.
     * @param node - Node to check.
     */
    static isJsxClosingFragment(node: Node): node is JsxClosingFragment;
    /**
     * Gets if the node is a JsxElement.
     * @param node - Node to check.
     */
    static isJsxElement(node: Node): node is JsxElement;
    /**
     * Gets if the node is a JsxExpression.
     * @param node - Node to check.
     */
    static isJsxExpression(node: Node): node is JsxExpression;
    /**
     * Gets if the node is a JsxFragment.
     * @param node - Node to check.
     */
    static isJsxFragment(node: Node): node is JsxFragment;
    /**
     * Gets if the node is a JsxOpeningElement.
     * @param node - Node to check.
     */
    static isJsxOpeningElement(node: Node): node is JsxOpeningElement;
    /**
     * Gets if the node is a JsxOpeningFragment.
     * @param node - Node to check.
     */
    static isJsxOpeningFragment(node: Node): node is JsxOpeningFragment;
    /**
     * Gets if the node is a JsxSelfClosingElement.
     * @param node - Node to check.
     */
    static isJsxSelfClosingElement(node: Node): node is JsxSelfClosingElement;
    /**
     * Gets if the node is a JsxSpreadAttribute.
     * @param node - Node to check.
     */
    static isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute;
    /**
     * Gets if the node is a JsxText.
     * @param node - Node to check.
     */
    static isJsxText(node: Node): node is JsxText;
    /**
     * Gets if the node is a LabeledStatement.
     * @param node - Node to check.
     */
    static isLabeledStatement(node: Node): node is LabeledStatement;
    /**
     * Gets if the node is a LeftHandSideExpression.
     * @param node - Node to check.
     */
    static isLeftHandSideExpression(node: Node): node is LeftHandSideExpression;
    /**
     * Gets if the node is a LeftHandSideExpressionedNode.
     * @param node - Node to check.
     */
    static isLeftHandSideExpressionedNode(node: Node): node is LeftHandSideExpressionedNode & Node;
    /**
     * Gets if the node is a LiteralExpression.
     * @param node - Node to check.
     */
    static isLiteralExpression(node: Node): node is LiteralExpression;
    /**
     * Gets if the node is a LiteralLikeNode.
     * @param node - Node to check.
     */
    static isLiteralLikeNode(node: Node): node is LiteralLikeNode & Node;
    /**
     * Gets if the node is a LiteralTypeNode.
     * @param node - Node to check.
     */
    static isLiteralTypeNode(node: Node): node is LiteralTypeNode;
    /**
     * Gets if the node is a MemberExpression.
     * @param node - Node to check.
     */
    static isMemberExpression(node: Node): node is MemberExpression;
    /**
     * Gets if the node is a MetaProperty.
     * @param node - Node to check.
     */
    static isMetaProperty(node: Node): node is MetaProperty;
    /**
     * Gets if the node is a MethodDeclaration.
     * @param node - Node to check.
     */
    static isMethodDeclaration(node: Node): node is MethodDeclaration;
    /**
     * Gets if the node is a MethodSignature.
     * @param node - Node to check.
     */
    static isMethodSignature(node: Node): node is MethodSignature;
    /**
     * Gets if the node is a ModifierableNode.
     * @param node - Node to check.
     */
    static isModifierableNode(node: Node): node is ModifierableNode & Node;
    /**
     * Gets if the node is a NameableNode.
     * @param node - Node to check.
     */
    static isNameableNode(node: Node): node is NameableNode & Node;
    /**
     * Gets if the node is a NamedNode.
     * @param node - Node to check.
     */
    static isNamedNode(node: Node): node is NamedNode & Node;
    /**
     * Gets if the node is a NamespaceChildableNode.
     * @param node - Node to check.
     */
    static isNamespaceChildableNode(node: Node): node is NamespaceChildableNode & Node;
    /**
     * Gets if the node is a NamespaceDeclaration.
     * @param node - Node to check.
     */
    static isNamespaceDeclaration(node: Node): node is NamespaceDeclaration;
    /**
     * Gets if the node is a NewExpression.
     * @param node - Node to check.
     */
    static isNewExpression(node: Node): node is NewExpression;
    /**
     * Gets if the node is a NoSubstitutionTemplateLiteral.
     * @param node - Node to check.
     */
    static isNoSubstitutionTemplateLiteral(node: Node): node is NoSubstitutionTemplateLiteral;
    /**
     * Gets if the node is a NonNullExpression.
     * @param node - Node to check.
     */
    static isNonNullExpression(node: Node): node is NonNullExpression;
    /**
     * Gets if the node is a NotEmittedStatement.
     * @param node - Node to check.
     */
    static isNotEmittedStatement(node: Node): node is NotEmittedStatement;
    /**
     * Gets if the node is a NullLiteral.
     * @param node - Node to check.
     */
    static isNullLiteral(node: Node): node is NullLiteral;
    /**
     * Gets if the node is a NumericLiteral.
     * @param node - Node to check.
     */
    static isNumericLiteral(node: Node): node is NumericLiteral;
    /**
     * Gets if the node is a ObjectLiteralExpression.
     * @param node - Node to check.
     */
    static isObjectLiteralExpression(node: Node): node is ObjectLiteralExpression;
    /**
     * Gets if the node is a OmittedExpression.
     * @param node - Node to check.
     */
    static isOmittedExpression(node: Node): node is OmittedExpression;
    /**
     * Gets if the node is a OverloadableNode.
     * @param node - Node to check.
     */
    static isOverloadableNode(node: Node): node is OverloadableNode & Node;
    /**
     * Gets if the node is a ParameterDeclaration.
     * @param node - Node to check.
     */
    static isParameterDeclaration(node: Node): node is ParameterDeclaration;
    /**
     * Gets if the node is a ParameteredNode.
     * @param node - Node to check.
     */
    static isParameteredNode(node: Node): node is ParameteredNode & Node;
    /**
     * Gets if the node is a ParenthesizedExpression.
     * @param node - Node to check.
     */
    static isParenthesizedExpression(node: Node): node is ParenthesizedExpression;
    /**
     * Gets if the node is a PartiallyEmittedExpression.
     * @param node - Node to check.
     */
    static isPartiallyEmittedExpression(node: Node): node is PartiallyEmittedExpression;
    /**
     * Gets if the node is a PostfixUnaryExpression.
     * @param node - Node to check.
     */
    static isPostfixUnaryExpression(node: Node): node is PostfixUnaryExpression;
    /**
     * Gets if the node is a PrefixUnaryExpression.
     * @param node - Node to check.
     */
    static isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression;
    /**
     * Gets if the node is a PrimaryExpression.
     * @param node - Node to check.
     */
    static isPrimaryExpression(node: Node): node is PrimaryExpression;
    /**
     * Gets if the node is a PropertyAccessExpression.
     * @param node - Node to check.
     */
    static isPropertyAccessExpression(node: Node): node is PropertyAccessExpression;
    /**
     * Gets if the node is a PropertyAssignment.
     * @param node - Node to check.
     */
    static isPropertyAssignment(node: Node): node is PropertyAssignment;
    /**
     * Gets if the node is a PropertyDeclaration.
     * @param node - Node to check.
     */
    static isPropertyDeclaration(node: Node): node is PropertyDeclaration;
    /**
     * Gets if the node is a PropertyNamedNode.
     * @param node - Node to check.
     */
    static isPropertyNamedNode(node: Node): node is PropertyNamedNode & Node;
    /**
     * Gets if the node is a PropertySignature.
     * @param node - Node to check.
     */
    static isPropertySignature(node: Node): node is PropertySignature;
    /**
     * Gets if the node is a QualifiedName.
     * @param node - Node to check.
     */
    static isQualifiedName(node: Node): node is QualifiedName;
    /**
     * Gets if the node is a QuestionTokenableNode.
     * @param node - Node to check.
     */
    static isQuestionTokenableNode(node: Node): node is QuestionTokenableNode & Node;
    /**
     * Gets if the node is a ReadonlyableNode.
     * @param node - Node to check.
     */
    static isReadonlyableNode(node: Node): node is ReadonlyableNode & Node;
    /**
     * Gets if the node is a RegularExpressionLiteral.
     * @param node - Node to check.
     */
    static isRegularExpressionLiteral(node: Node): node is RegularExpressionLiteral;
    /**
     * Gets if the node is a ReturnStatement.
     * @param node - Node to check.
     */
    static isReturnStatement(node: Node): node is ReturnStatement;
    /**
     * Gets if the node is a ReturnTypedNode.
     * @param node - Node to check.
     */
    static isReturnTypedNode(node: Node): node is ReturnTypedNode & Node;
    /**
     * Gets if the node is a ScopeableNode.
     * @param node - Node to check.
     */
    static isScopeableNode(node: Node): node is ScopeableNode & Node;
    /**
     * Gets if the node is a ScopedNode.
     * @param node - Node to check.
     */
    static isScopedNode(node: Node): node is ScopedNode & Node;
    /**
     * Gets if the node is a SemicolonToken.
     * @param node - Node to check.
     */
    static isSemicolonToken(node: Node): node is Node;
    /**
     * Gets if the node is a SetAccessorDeclaration.
     * @param node - Node to check.
     */
    static isSetAccessorDeclaration(node: Node): node is SetAccessorDeclaration;
    /**
     * Gets if the node is a ShorthandPropertyAssignment.
     * @param node - Node to check.
     */
    static isShorthandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment;
    /**
     * Gets if the node is a SignaturedDeclaration.
     * @param node - Node to check.
     */
    static isSignaturedDeclaration(node: Node): node is SignaturedDeclaration & Node;
    /**
     * Gets if the node is a SourceFile.
     * @param node - Node to check.
     */
    static isSourceFile(node: Node): node is SourceFile;
    /**
     * Gets if the node is a SpreadAssignment.
     * @param node - Node to check.
     */
    static isSpreadAssignment(node: Node): node is SpreadAssignment;
    /**
     * Gets if the node is a SpreadElement.
     * @param node - Node to check.
     */
    static isSpreadElement(node: Node): node is SpreadElement;
    /**
     * Gets if the node is a Statement.
     * @param node - Node to check.
     */
    static isStatement(node: Node): node is Statement;
    /**
     * Gets if the node is a StatementedNode.
     * @param node - Node to check.
     */
    static isStatementedNode(node: Node): node is StatementedNode & Node;
    /**
     * Gets if the node is a StaticableNode.
     * @param node - Node to check.
     */
    static isStaticableNode(node: Node): node is StaticableNode & Node;
    /**
     * Gets if the node is a StringLiteral.
     * @param node - Node to check.
     */
    static isStringLiteral(node: Node): node is StringLiteral;
    /**
     * Gets if the node is a SuperExpression.
     * @param node - Node to check.
     */
    static isSuperExpression(node: Node): node is SuperExpression;
    /**
     * Gets if the node is a SwitchStatement.
     * @param node - Node to check.
     */
    static isSwitchStatement(node: Node): node is SwitchStatement;
    /**
     * Gets if the node is a SyntaxList.
     * @param node - Node to check.
     */
    static isSyntaxList(node: Node): node is SyntaxList;
    /**
     * Gets if the node is a TaggedTemplateExpression.
     * @param node - Node to check.
     */
    static isTaggedTemplateExpression(node: Node): node is TaggedTemplateExpression;
    /**
     * Gets if the node is a TemplateExpression.
     * @param node - Node to check.
     */
    static isTemplateExpression(node: Node): node is TemplateExpression;
    /**
     * Gets if the node is a TemplateHead.
     * @param node - Node to check.
     */
    static isTemplateHead(node: Node): node is TemplateHead;
    /**
     * Gets if the node is a TemplateMiddle.
     * @param node - Node to check.
     */
    static isTemplateMiddle(node: Node): node is TemplateMiddle;
    /**
     * Gets if the node is a TemplateSpan.
     * @param node - Node to check.
     */
    static isTemplateSpan(node: Node): node is TemplateSpan;
    /**
     * Gets if the node is a TemplateTail.
     * @param node - Node to check.
     */
    static isTemplateTail(node: Node): node is TemplateTail;
    /**
     * Gets if the node is a TextInsertableNode.
     * @param node - Node to check.
     */
    static isTextInsertableNode(node: Node): node is TextInsertableNode & Node;
    /**
     * Gets if the node is a ThisExpression.
     * @param node - Node to check.
     */
    static isThisExpression(node: Node): node is ThisExpression;
    /**
     * Gets if the node is a ThrowStatement.
     * @param node - Node to check.
     */
    static isThrowStatement(node: Node): node is ThrowStatement;
    /**
     * Gets if the node is a TryStatement.
     * @param node - Node to check.
     */
    static isTryStatement(node: Node): node is TryStatement;
    /**
     * Gets if the node is a TupleTypeNode.
     * @param node - Node to check.
     */
    static isTupleTypeNode(node: Node): node is TupleTypeNode;
    /**
     * Gets if the node is a TypeAliasDeclaration.
     * @param node - Node to check.
     */
    static isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration;
    /**
     * Gets if the node is a TypeArgumentedNode.
     * @param node - Node to check.
     */
    static isTypeArgumentedNode(node: Node): node is TypeArgumentedNode & Node;
    /**
     * Gets if the node is a TypeAssertion.
     * @param node - Node to check.
     */
    static isTypeAssertion(node: Node): node is TypeAssertion;
    /**
     * Gets if the node is a TypeNode.
     * @param node - Node to check.
     */
    static isTypeNode(node: Node): node is TypeNode;
    /**
     * Gets if the node is a TypeOfExpression.
     * @param node - Node to check.
     */
    static isTypeOfExpression(node: Node): node is TypeOfExpression;
    /**
     * Gets if the node is a TypeParameterDeclaration.
     * @param node - Node to check.
     */
    static isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration;
    /**
     * Gets if the node is a TypeParameteredNode.
     * @param node - Node to check.
     */
    static isTypeParameteredNode(node: Node): node is TypeParameteredNode & Node;
    /**
     * Gets if the node is a TypeReferenceNode.
     * @param node - Node to check.
     */
    static isTypeReferenceNode(node: Node): node is TypeReferenceNode;
    /**
     * Gets if the node is a TypedNode.
     * @param node - Node to check.
     */
    static isTypedNode(node: Node): node is TypedNode & Node;
    /**
     * Gets if the node is a UnaryExpression.
     * @param node - Node to check.
     */
    static isUnaryExpression(node: Node): node is UnaryExpression;
    /**
     * Gets if the node is a UnaryExpressionedNode.
     * @param node - Node to check.
     */
    static isUnaryExpressionedNode(node: Node): node is UnaryExpressionedNode & Node;
    /**
     * Gets if the node is a UndefinedKeyword.
     * @param node - Node to check.
     */
    static isUndefinedKeyword(node: Node): node is Node;
    /**
     * Gets if the node is a UnionTypeNode.
     * @param node - Node to check.
     */
    static isUnionTypeNode(node: Node): node is UnionTypeNode;
    /**
     * Gets if the node is a UnwrappableNode.
     * @param node - Node to check.
     */
    static isUnwrappableNode(node: Node): node is UnwrappableNode & Node;
    /**
     * Gets if the node is a UpdateExpression.
     * @param node - Node to check.
     */
    static isUpdateExpression(node: Node): node is UpdateExpression;
    /**
     * Gets if the node is a VariableDeclaration.
     * @param node - Node to check.
     */
    static isVariableDeclaration(node: Node): node is VariableDeclaration;
    /**
     * Gets if the node is a VariableDeclarationList.
     * @param node - Node to check.
     */
    static isVariableDeclarationList(node: Node): node is VariableDeclarationList;
    /**
     * Gets if the node is a VariableStatement.
     * @param node - Node to check.
     */
    static isVariableStatement(node: Node): node is VariableStatement;
    /**
     * Gets if the node is a VoidExpression.
     * @param node - Node to check.
     */
    static isVoidExpression(node: Node): node is VoidExpression;
    /**
     * Gets if the node is a WhileStatement.
     * @param node - Node to check.
     */
    static isWhileStatement(node: Node): node is WhileStatement;
    /**
     * Gets if the node is a WithStatement.
     * @param node - Node to check.
     */
    static isWithStatement(node: Node): node is WithStatement;
    /**
     * Gets if the node is a YieldExpression.
     * @param node - Node to check.
     */
    static isYieldExpression(node: Node): node is YieldExpression;
}

export declare type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;

export declare type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;

export declare type EntityName = Identifier | QualifiedName;

export declare type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement | JsxFragment;

export declare type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;

export declare type JsxTagNameExpression = PrimaryExpression | PropertyAccessExpression;

export declare type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | MethodDeclaration | AccessorDeclaration;

export declare type CaseOrDefaultClause = CaseClause | DefaultClause;

export declare type ModuleReference = EntityName | ExternalModuleReference;

export declare type AmbientableNodeExtensionType = Node & ModifierableNode;

export interface AmbientableNode {
    /**
     * If the node has the declare keyword.
     */
    hasDeclareKeyword(): boolean;
    /**
     * Gets the declare keyword or undefined if none exists.
     */
    getDeclareKeyword(): Node | undefined;
    /**
     * Gets the declare keyword or throws if it doesn't exist.
     */
    getDeclareKeywordOrThrow(): Node;
    /**
     * Gets if the node is ambient.
     */
    isAmbient(): boolean;
    /**
     * Sets if this node has a declare keyword.
     * @param value - To add the declare keyword or not.
     */
    setHasDeclareKeyword(value?: boolean): this;
}

export declare function AmbientableNode<T extends Constructor<AmbientableNodeExtensionType>>(Base: T): Constructor<AmbientableNode> & T;

export declare type ArgumentedNodeExtensionType = Node<ts.Node & {
    arguments: ts.NodeArray<ts.Node>;
}>;

export interface ArgumentedNode {
    /**
     * Gets all the arguments of the node.
     */
    getArguments(): Node[];
    /**
     * Adds an argument.
     * @param argumentText - Argument text to add.
     */
    addArgument(argumentText: string): Node;
    /**
     * Adds arguments.
     * @param argumentTexts - Argument texts to add.
     */
    addArguments(argumentTexts: string[]): Node[];
    /**
     * Inserts an argument.
     * @param index - Index to insert at.
     * @param argumentText - Argument text to insert.
     */
    insertArgument(index: number, argumentText: string): Node;
    /**
     * Inserts arguments.
     * @param index - Index to insert at.
     * @param argumentTexts - Argument texts to insert.
     */
    insertArguments(index: number, argumentTexts: string[]): Node[];
    /**
     * Removes an argument.
     * @param arg - Argument to remove.
     */
    removeArgument(arg: Node): this;
    /**
     * Removes an argument.
     * @param index - Index to remove.
     */
    removeArgument(index: number): this;
}

export declare function ArgumentedNode<T extends Constructor<ArgumentedNodeExtensionType>>(Base: T): Constructor<ArgumentedNode> & T;

export declare type AsyncableNodeExtensionType = Node & ModifierableNode;

export interface AsyncableNode {
    /**
     * If it's async.
     */
    isAsync(): boolean;
    /**
     * Gets the async keyword or undefined if none exists.
     */
    getAsyncKeyword(): Node<ts.Modifier> | undefined;
    /**
     * Gets the async keyword or throws if none exists.
     */
    getAsyncKeywordOrThrow(): Node<ts.Modifier>;
    /**
     * Sets if the node is async.
     * @param value - If it should be async or not.
     */
    setIsAsync(value: boolean): this;
}

export declare function AsyncableNode<T extends Constructor<AsyncableNodeExtensionType>>(Base: T): Constructor<AsyncableNode> & T;

export declare type AwaitableNodeExtensionType = Node<ts.Node & {
    awaitModifier?: ts.AwaitKeywordToken;
}>;

export interface AwaitableNode {
    /**
     * If it's an awaited node.
     */
    isAwaited(): boolean;
    /**
     * Gets the await token or undefined if none exists.
     */
    getAwaitKeyword(): Node<ts.AwaitKeywordToken> | undefined;
    /**
     * Gets the await token or throws if none exists.
     */
    getAwaitKeywordOrThrow(): Node<ts.AwaitKeywordToken>;
    /**
     * Sets if the node is awaited.
     * @param value - If it should be awaited or not.
     */
    setIsAwaited(value: boolean): this;
}

export declare function AwaitableNode<T extends Constructor<AwaitableNodeExtensionType>>(Base: T): Constructor<AwaitableNode> & T;

export declare type BodiedNodeExtensionType = Node<ts.Node & {
    body: ts.Node;
}>;

export interface BodiedNode {
    /**
     * Gets the body.
     */
    getBody(): Node;
    /**
     * Sets the body text.
     * @param writerFunction - Write the text using the provided writer.
     */
    setBodyText(writerFunction: (writer: CodeBlockWriter) => void): this;
    /**
     * Sets the body text.
     * @param text - Text to set as the body.
     */
    setBodyText(text: string): this;
}

export declare function BodiedNode<T extends Constructor<BodiedNodeExtensionType>>(Base: T): Constructor<BodiedNode> & T;

export declare type BodyableNodeExtensionType = Node<ts.Node & {
    body?: ts.Node;
}>;

export interface BodyableNode {
    /**
     * Gets the body or throws an error if it doesn't exist.
     */
    getBodyOrThrow(): Node;
    /**
     * Gets the body if it exists.
     */
    getBody(): Node | undefined;
    /**
     * Sets the body text. A body is required to do this operation.
     * @param writerFunction - Write the text using the provided writer.
     */
    setBodyText(writerFunction: (writer: CodeBlockWriter) => void): this;
    /**
     * Sets the body text. A body is required to do this operation.
     * @param text - Text to set as the body.
     */
    setBodyText(text: string): this;
}

export declare function BodyableNode<T extends Constructor<BodyableNodeExtensionType>>(Base: T): Constructor<BodyableNode> & T;

export interface ChildOrderableNode {
    /**
     * Sets the child order of the node within the parent.
     */
    setOrder(order: number): this;
}

export declare function ChildOrderableNode<T extends Constructor<Node>>(Base: T): Constructor<ChildOrderableNode> & T;

export declare type DecoratableNodeExtensionType = Node<ts.Node & {
    decorators: ts.NodeArray<ts.Decorator> | undefined;
}>;

export interface DecoratableNode {
    /**
     * Gets a decorator or undefined if it doesn't exist.
     * @param name - Name of the parameter.
     */
    getDecorator(name: string): Decorator | undefined;
    /**
     * Gets a decorator or undefined if it doesn't exist.
     * @param findFunction - Function to use to find the parameter.
     */
    getDecorator(findFunction: (declaration: Decorator) => boolean): Decorator | undefined;
    /**
     * Gets a decorator or throws if it doesn't exist.
     * @param name - Name of the parameter.
     */
    getDecoratorOrThrow(name: string): Decorator;
    /**
     * Gets a decorator or throws if it doesn't exist.
     * @param findFunction - Function to use to find the parameter.
     */
    getDecoratorOrThrow(findFunction: (declaration: Decorator) => boolean): Decorator;
    /**
     * Gets all the decorators of the node.
     */
    getDecorators(): Decorator[];
    /**
     * Adds a decorator.
     * @param structure - Structure of the decorator.
     */
    addDecorator(structure: DecoratorStructure): Decorator;
    /**
     * Adds decorators.
     * @param structures - Structures of the decorators.
     */
    addDecorators(structures: DecoratorStructure[]): Decorator[];
    /**
     * Inserts a decorator.
     * @param index - Index to insert at. Specify a negative index to insert from the reverse.
     * @param structure - Structure of the decorator.
     */
    insertDecorator(index: number, structure: DecoratorStructure): Decorator;
    /**
     * Insert decorators.
     * @param index - Index to insert at.
     * @param structures - Structures to insert.
     */
    insertDecorators(index: number, structures: DecoratorStructure[]): Decorator[];
}

export declare function DecoratableNode<T extends Constructor<DecoratableNodeExtensionType>>(Base: T): Constructor<DecoratableNode> & T;

export declare type ExportableNodeExtensionType = Node & ModifierableNode;

export interface ExportableNode {
    /**
     * If the node has the export keyword.
     */
    hasExportKeyword(): boolean;
    /**
     * Gets the export keyword or undefined if none exists.
     */
    getExportKeyword(): Node | undefined;
    /**
     * Gets the export keyword or throws if none exists.
     */
    getExportKeywordOrThrow(): Node;
    /**
     * If the node has the default keyword.
     */
    hasDefaultKeyword(): boolean;
    /**
     * Gets the default keyword or undefined if none exists.
     */
    getDefaultKeyword(): Node | undefined;
    /**
     * Gets the default keyword or throws if none exists.
     */
    getDefaultKeywordOrThrow(): Node;
    /**
     * Gets if the node is exported from a namespace, is a default export, or is a named export.
     */
    isExported(): boolean;
    /**
     * Gets if this node is a default export of a file.
     */
    isDefaultExport(): boolean;
    /**
     * Gets if this node is a named export of a file.
     */
    isNamedExport(): boolean;
    /**
     * Sets if this node is a default export of a file.
     * @param value - If it should be a default export or not.
     */
    setIsDefaultExport(value: boolean): this;
    /**
     * Sets if the node is exported.
     *
     * Note: Will remove the default keyword if set.
     * @param value - If it should be exported or not.
     */
    setIsExported(value: boolean): this;
}

export declare function ExportableNode<T extends Constructor<ExportableNodeExtensionType>>(Base: T): Constructor<ExportableNode> & T;

export declare type ExtendsClauseableNodeExtensionType = Node & HeritageClauseableNode;

export interface ExtendsClauseableNode {
    /**
     * Gets the extends clauses.
     */
    getExtends(): ExpressionWithTypeArguments[];
    /**
     * Adds multiple extends clauses.
     * @param texts - Texts to add for the extends clause.
     */
    addExtends(texts: string[]): ExpressionWithTypeArguments[];
    /**
     * Adds an extends clause.
     * @param text - Text to add for the extends clause.
     */
    addExtends(text: string): ExpressionWithTypeArguments;
    /**
     * Inserts multiple extends clauses.
     * @param texts - Texts to insert for the extends clause.
     */
    insertExtends(index: number, texts: string[]): ExpressionWithTypeArguments[];
    /**
     * Inserts an extends clause.
     * @param text - Text to insert for the extends clause.
     */
    insertExtends(index: number, text: string): ExpressionWithTypeArguments;
    /**
     * Removes the extends at the specified index.
     * @param index - Index to remove.
     */
    removeExtends(index: number): this;
    /**
     * Removes the specified extends.
     * @param extendsNode - Node of the extend to remove.
     */
    removeExtends(extendsNode: ExpressionWithTypeArguments): this;
}

export declare function ExtendsClauseableNode<T extends Constructor<ExtendsClauseableNodeExtensionType>>(Base: T): Constructor<ExtendsClauseableNode> & T;

export declare type GeneratorableNodeExtensionType = Node<ts.Node & {
    asteriskToken?: ts.AsteriskToken;
}>;

export interface GeneratorableNode {
    /**
     * If it's a generator function.
     */
    isGenerator(): boolean;
    /**
     * Gets the asterisk token or undefined if none exists.
     */
    getAsteriskToken(): Node<ts.AsteriskToken> | undefined;
    /**
     * Gets the asterisk token or throws if none exists.
     */
    getAsteriskTokenOrThrow(): Node<ts.AsteriskToken>;
    /**
     * Sets if the node is a generator.
     * @param value - If it should be a generator or not.
     */
    setIsGenerator(value: boolean): this;
}

export declare function GeneratorableNode<T extends Constructor<GeneratorableNodeExtensionType>>(Base: T): Constructor<GeneratorableNode> & T;

export declare type HeritageClauseableNodeExtensionType = Node<ts.Node & {
    heritageClauses?: ts.NodeArray<ts.HeritageClause>;
}>;

export interface HeritageClauseableNode {
    /**
     * Gets the heritage clauses of the node.
     */
    getHeritageClauses(): HeritageClause[];
    /**
     * Gets the heritage clause by kind.
     * @kind - Kind of heritage clause.
     */
    getHeritageClauseByKind(kind: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword): HeritageClause | undefined;
    /**
     * Gets the heritage clause by kind or throws if it doesn't exist.
     * @kind - Kind of heritage clause.
     */
    getHeritageClauseByKindOrThrow(kind: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword): HeritageClause;
}

export declare function HeritageClauseableNode<T extends Constructor<HeritageClauseableNodeExtensionType>>(Base: T): Constructor<HeritageClauseableNode> & T;

export declare type ImplementsClauseableNodeExtensionType = Node & HeritageClauseableNode;

export interface ImplementsClauseableNode {
    /**
     * Gets the implements clauses.
     */
    getImplements(): ExpressionWithTypeArguments[];
    /**
     * Adds an implements clause.
     * @param text - Text to add for the implements clause.
     */
    addImplements(text: string): ExpressionWithTypeArguments;
    /**
     * Adds multiple implements clauses.
     * @param text - Texts to add for the implements clause.
     */
    addImplements(text: string[]): ExpressionWithTypeArguments[];
    /**
     * Inserts an implements clause.
     * @param text - Text to insert for the implements clause.
     */
    insertImplements(index: number, texts: string[]): ExpressionWithTypeArguments[];
    /**
     * Inserts multiple implements clauses.
     * @param text - Texts to insert for the implements clause.
     */
    insertImplements(index: number, text: string): ExpressionWithTypeArguments;
    /**
     * Removes the implements at the specified index.
     * @param index - Index to remove.
     */
    removeImplements(index: number): this;
    /**
     * Removes the specified implements.
     * @param implementsNode - Node of the implements to remove.
     */
    removeImplements(implementsNode: ExpressionWithTypeArguments): this;
}

export declare function ImplementsClauseableNode<T extends Constructor<ImplementsClauseableNodeExtensionType>>(Base: T): Constructor<ImplementsClauseableNode> & T;

export declare type JSDocableNodeExtensionType = Node<ts.Node & {
    jsDoc?: ts.NodeArray<ts.JSDoc>;
}>;

export interface JSDocableNode {
    /**
     * Gets the JS doc nodes.
     */
    getJsDocs(): JSDoc[];
    /**
     * Adds a JS doc.
     * @param structure - Structure to add.
     */
    addJsDoc(structure: JSDocStructure): JSDoc;
    /**
     * Adds JS docs.
     * @param structures - Structures to add.
     */
    addJsDocs(structures: JSDocStructure[]): JSDoc[];
    /**
     * Inserts a JS doc.
     * @param index - Index to insert at.
     * @param structure - Structure to insert.
     */
    insertJsDoc(index: number, structure: JSDocStructure): JSDoc;
    /**
     * Inserts JS docs.
     * @param index - Index to insert at.
     * @param structures - Structures to insert.
     */
    insertJsDocs(index: number, structures: JSDocStructure[]): JSDoc[];
}

export declare function JSDocableNode<T extends Constructor<JSDocableNodeExtensionType>>(Base: T): Constructor<JSDocableNode> & T;

export declare type LiteralLikeNodeExtensionType = Node<ts.LiteralLikeNode>;

export interface LiteralLikeNode {
    /**
     * Get text of the literal.
     */
    getLiteralText(): string;
    /**
     * Gets if the literal is terminated.
     */
    isTerminated(): boolean;
    /**
     * Gets if the literal has an extended unicode escape.
     */
    hasExtendedUnicodeEscape(): boolean;
}

export declare function LiteralLikeNode<T extends Constructor<LiteralLikeNodeExtensionType>>(Base: T): Constructor<LiteralLikeNode> & T;

export declare type ModiferableNodeExtensionType = Node;

export declare type ModifierTexts = "export" | "default" | "declare" | "abstract" | "public" | "protected" | "private" | "readonly" | "static" | "async" | "const";

export interface ModifierableNode {
    /**
     * Gets the node's modifiers.
     */
    getModifiers(): Node[];
    /**
     * Gets the first modifier of the specified syntax kind or throws if none found.
     * @param kind - Syntax kind.
     */
    getFirstModifierByKindOrThrow(kind: SyntaxKind): Node<ts.Modifier>;
    /**
     * Gets the first modifier of the specified syntax kind or undefined if none found.
     * @param kind - Syntax kind.
     */
    getFirstModifierByKind(kind: SyntaxKind): Node<ts.Modifier> | undefined;
    /**
     * Gets if it has the specified modifier.
     * @param kind - Syntax kind to check for.
     */
    hasModifier(kind: SyntaxKind): boolean;
    /**
     * Gets if it has the specified modifier.
     * @param text - Text to check for.
     */
    hasModifier(text: ModifierTexts): boolean;
    /**
     * Toggles a modifier.
     * @param text - Text to toggle the modifier for.
     * @param value - Optional toggling value.
     */
    toggleModifier(text: ModifierTexts, value?: boolean): this;
}

export declare function ModifierableNode<T extends Constructor<ModiferableNodeExtensionType>>(Base: T): Constructor<ModifierableNode> & T;

export declare type ParameteredNodeExtensionType = Node<ts.Node & {
    parameters: ts.NodeArray<ts.ParameterDeclaration>;
}>;

export interface ParameteredNode {
    /**
     * Gets a parameter or undefined if it doesn't exist.
     * @param name - Name of the parameter.
     */
    getParameter(name: string): ParameterDeclaration | undefined;
    /**
     * Gets a parameter or undefined if it doesn't exist.
     * @param findFunction - Function to use to find the parameter.
     */
    getParameter(findFunction: (declaration: ParameterDeclaration) => boolean): ParameterDeclaration | undefined;
    /**
     * Gets a parameter or throws if it doesn't exist.
     * @param name - Name of the parameter.
     */
    getParameterOrThrow(name: string): ParameterDeclaration;
    /**
     * Gets a parameter or throws if it doesn't exist.
     * @param findFunction - Function to use to find the parameter.
     */
    getParameterOrThrow(findFunction: (declaration: ParameterDeclaration) => boolean): ParameterDeclaration;
    /**
     * Gets all the parameters of the node.
     */
    getParameters(): ParameterDeclaration[];
    /**
     * Adds a parameter.
     * @param structure - Structure of the parameter.
     */
    addParameter(structure: ParameterDeclarationStructure): ParameterDeclaration;
    /**
     * Adds parameters.
     * @param structures - Structures of the parameters.
     */
    addParameters(structures: ParameterDeclarationStructure[]): ParameterDeclaration[];
    /**
     * Inserts parameters.
     * @param index - Index to insert at.
     * @param structures - Parameters to insert.
     */
    insertParameters(index: number, structures: ParameterDeclarationStructure[]): ParameterDeclaration[];
    /**
     * Inserts a parameter.
     * @param index - Index to insert at.
     * @param structures - Parameter to insert.
     */
    insertParameter(index: number, structure: ParameterDeclarationStructure): ParameterDeclaration;
}

export declare function ParameteredNode<T extends Constructor<ParameteredNodeExtensionType>>(Base: T): Constructor<ParameteredNode> & T;

export declare type QuestionTokenableNodeExtensionType = Node<ts.Node & {
    questionToken?: ts.QuestionToken;
}>;

export interface QuestionTokenableNode {
    /**
     * If it has a question token.
     */
    hasQuestionToken(): boolean;
    /**
     * Gets the question token node or returns undefined if it doesn't exist.
     */
    getQuestionTokenNode(): Node<ts.QuestionToken> | undefined;
    /**
     * Gets the question token node or throws.
     */
    getQuestionTokenNodeOrThrow(): Node<ts.QuestionToken>;
    /**
     * Sets if this node has a question token.
     * @param value - If it should have a question token or not.
     */
    setHasQuestionToken(value: boolean): this;
}

export declare function QuestionTokenableNode<T extends Constructor<QuestionTokenableNodeExtensionType>>(Base: T): Constructor<QuestionTokenableNode> & T;

export declare type ReadonlyableNodeExtensionType = Node & ModifierableNode;

export interface ReadonlyableNode {
    /**
     * Gets if it's readonly.
     */
    isReadonly(): boolean;
    /**
     * Gets the readonly keyword, or undefined if none exists.
     */
    getReadonlyKeyword(): Node | undefined;
    /**
     * Gets the readonly keyword, or throws if none exists.
     */
    getReadonlyKeywordOrThrow(): Node;
    /**
     * Sets if this node is readonly.
     * @param value - If readonly or not.
     */
    setIsReadonly(value: boolean): this;
}

export declare function ReadonlyableNode<T extends Constructor<ReadonlyableNodeExtensionType>>(Base: T): Constructor<ReadonlyableNode> & T;

export declare type ReturnTypedNodeExtensionReturnType = Node<ts.SignatureDeclaration>;

export interface ReturnTypedNode {
    /**
     * Gets the return type.
     */
    getReturnType(): Type;
    /**
     * Gets the return type node or undefined if none exists.
     */
    getReturnTypeNode(): TypeNode | undefined;
    /**
     * Gets the return type node or throws if none exists.
     */
    getReturnTypeNodeOrThrow(): TypeNode;
    /**
     * Sets the return type of the node.
     * @param text - Text to set as the type.
     */
    setReturnType(text: string): this;
    /**
     * Removes the return type.
     */
    removeReturnType(): this;
}

export declare function ReturnTypedNode<T extends Constructor<ReturnTypedNodeExtensionReturnType>>(Base: T): Constructor<ReturnTypedNode> & T;

export declare type ScopeableNodeExtensionType = Node & ModifierableNode;

export interface ScopeableNode {
    /**
     * Gets the scope.
     */
    getScope(): Scope | undefined;
    /**
     * Sets the scope.
     * @param scope - Scope to set to.
     */
    setScope(scope: Scope | undefined): this;
    /**
     * Gets if the node has a scope keyword.
     */
    hasScopeKeyword(): boolean;
}

export declare function ScopeableNode<T extends Constructor<ScopeableNodeExtensionType>>(Base: T): Constructor<ScopeableNode> & T;

export declare type ScopedNodeExtensionType = Node & ModifierableNode;

export interface ScopedNode {
    /**
     * Gets the scope.
     */
    getScope(): Scope;
    /**
     * Sets the scope.
     * @param scope - Scope to set to.
     */
    setScope(scope: Scope): this;
    /**
     * Gets if the node has a scope keyword.
     */
    hasScopeKeyword(): boolean;
}

export declare function ScopedNode<T extends Constructor<ScopedNodeExtensionType>>(Base: T): Constructor<ScopedNode> & T;

export declare type SignaturedDeclarationExtensionType = Node<ts.SignatureDeclaration>;

export interface SignaturedDeclaration extends ParameteredNode, ReturnTypedNode {
}

export declare function SignaturedDeclaration<T extends Constructor<SignaturedDeclarationExtensionType>>(Base: T): Constructor<SignaturedDeclaration> & T;

export declare type StaticableNodeExtensionType = Node & ModifierableNode;

export interface StaticableNode {
    /**
     * Gets if it's static.
     */
    isStatic(): boolean;
    /**
     * Gets the static keyword, or undefined if none exists.
     */
    getStaticKeyword(): Node | undefined;
    /**
     * Gets the static keyword, or throws if none exists.
     */
    getStaticKeywordOrThrow(): Node;
    /**
     * Sets if the node is static.
     * @param value - If it should be static or not.
     */
    setIsStatic(value: boolean): this;
}

export declare function StaticableNode<T extends Constructor<StaticableNodeExtensionType>>(Base: T): Constructor<StaticableNode> & T;

export declare type TextInsertableNodeExtensionType = Node;

export interface TextInsertableNode {
    /**
     * Inserts text within the body of the node.
     *
     * WARNING: This will forget any previously navigated descendant nodes.
     * @param pos - Position to insert at.
     * @param text - Text to insert.
     */
    insertText(pos: number, text: string): this;
    /**
     * Inserts text within the body of the node using a writer.
     *
     * WARNING: This will forget any previously navigated descendant nodes.
     * @param pos - Position to insert at.
     * @param writerFunction - Write the text using the provided writer.
     */
    insertText(pos: number, writerFunction: (writer: CodeBlockWriter) => void): this;
    /**
     * Replaces text within the body of the node.
     *
     * WARNING: This will forget any previously navigated descendant nodes.
     * @param range - Start and end position of the text to replace.
     * @param text - Text to replace the range with.
     */
    replaceText(range: [number, number], text: string): this;
    /**
     * Replaces text within the body of the node using a writer function.
     *
     * WARNING: This will forget any previously navigated descendant nodes.
     * @param range - Start and end position of the text to replace.
     * @param writerFunction - Write the text using the provided writer.
     */
    replaceText(range: [number, number], writerFunction: (writer: CodeBlockWriter) => void): this;
    /**
     * Removes text within the body of the node.
     *
     * WARNING: This will forget any previously navigated descendant nodes.
     * @param pos - Start position to remove.
     * @param end - End position to remove.
     */
    removeText(pos: number, end: number): this;
}

export declare function TextInsertableNode<T extends Constructor<TextInsertableNodeExtensionType>>(Base: T): Constructor<TextInsertableNode> & T;

export declare type TypeArgumentedNodeExtensionType = Node<ts.Node & {
    typeArguments?: ts.NodeArray<ts.TypeNode>;
}>;

export interface TypeArgumentedNode {
    /**
     * Gets all the type arguments of the node.
     */
    getTypeArguments(): TypeNode[];
    /**
     * Adds a type argument.
     * @param argumentText - Argument text to add.
     */
    addTypeArgument(argumentText: string): TypeNode;
    /**
     * Adds type arguments.
     * @param argumentTexts - Argument texts to add.
     */
    addTypeArguments(argumentTexts: string[]): TypeNode[];
    /**
     * Inserts a type argument.
     * @param index - Index to insert at.
     * @param argumentText - Argument text to insert.
     */
    insertTypeArgument(index: number, argumentText: string): TypeNode;
    /**
     * Inserts type arguments.
     * @param index - Index to insert at.
     * @param argumentTexts - Argument texts to insert.
     */
    insertTypeArguments(index: number, argumentTexts: string[]): TypeNode[];
    /**
     * Removes a type argument.
     * @param typeArg - Type argument to remove.
     */
    removeTypeArgument(typeArg: Node): this;
    /**
     * Removes a type argument.
     * @param index - Index to remove.
     */
    removeTypeArgument(index: number): this;
}

export declare function TypeArgumentedNode<T extends Constructor<TypeArgumentedNodeExtensionType>>(Base: T): Constructor<TypeArgumentedNode> & T;

export declare type TypedNodeExtensionType = Node<ts.Node & {
    type?: ts.TypeNode;
}>;

export interface TypedNode {
    /**
     * Gets the type node or undefined if none exists.
     */
    getTypeNode(): TypeNode | undefined;
    /**
     * Gets the type node or throws if none exists.
     */
    getTypeNodeOrThrow(): TypeNode;
    /**
     * Sets the type.
     * @param text - Text to set the type to.
     */
    setType(text: string): this;
    /**
     * Removes the type.
     */
    removeType(): this;
}

export declare function TypedNode<T extends Constructor<TypedNodeExtensionType>>(Base: T): Constructor<TypedNode> & T;

export declare type TypeParameteredNodeExtensionType = Node<ts.Node & {
    typeParameters?: ts.NodeArray<ts.TypeParameterDeclaration>;
}>;

export interface TypeParameteredNode {
    /**
     * Gets a type parameter or undefined if it doesn't exist.
     * @param name - Name of the parameter.
     */
    getTypeParameter(name: string): TypeParameterDeclaration | undefined;
    /**
     * Gets a type parameter or undefined if it doesn't exist.
     * @param findFunction - Function to use to find the type parameter.
     */
    getTypeParameter(findFunction: (declaration: TypeParameterDeclaration) => boolean): TypeParameterDeclaration | undefined;
    /**
     * Gets a type parameter or throws if it doesn't exist.
     * @param name - Name of the parameter.
     */
    getTypeParameterOrThrow(name: string): TypeParameterDeclaration;
    /**
     * Gets a type parameter or throws if it doesn't exist.
     * @param findFunction - Function to use to find the type parameter.
     */
    getTypeParameterOrThrow(findFunction: (declaration: TypeParameterDeclaration) => boolean): TypeParameterDeclaration;
    /**
     * Gets the type parameters.
     */
    getTypeParameters(): TypeParameterDeclaration[];
    /**
     * Adds a type parameter.
     * @param structure - Structure of the type parameter.
     */
    addTypeParameter(structure: TypeParameterDeclarationStructure): TypeParameterDeclaration;
    /**
     * Adds type parameters.
     * @param structures - Structures of the type parameters.
     */
    addTypeParameters(structures: TypeParameterDeclarationStructure[]): TypeParameterDeclaration[];
    /**
     * Inserts a type parameter.
     * @param index - Index to insert at. Specify a negative index to insert from the reverse.
     * @param structure - Structure of the type parameter.
     */
    insertTypeParameter(index: number, structure: TypeParameterDeclarationStructure): TypeParameterDeclaration;
    /**
     * Inserts type parameters.
     * @param index - Index to insert at. Specify a negative index to insert from the reverse.
     * @param structures - Structures of the type parameters.
     */
    insertTypeParameters(index: number, structures: TypeParameterDeclarationStructure[]): TypeParameterDeclaration[];
}

export declare function TypeParameteredNode<T extends Constructor<TypeParameteredNodeExtensionType>>(Base: T): Constructor<TypeParameteredNode> & T;

export declare type UnwrappableNodeExtensionType = Node;

export interface UnwrappableNode {
    /**
     * Replaces the node's text with its body's statements.
     */
    unwrap(): void;
}

export declare function UnwrappableNode<T extends Constructor<UnwrappableNodeExtensionType>>(Base: T): Constructor<UnwrappableNode> & T;

export declare type InitializerExpressionableExtensionType = Node<ts.Node & {
    initializer?: ts.Expression;
}>;

export interface InitializerExpressionableNode extends InitializerGetExpressionableNode, InitializerSetExpressionableNode {
}

export declare function InitializerExpressionableNode<T extends Constructor<InitializerExpressionableExtensionType>>(Base: T): Constructor<InitializerExpressionableNode> & T;


export declare type InitializerGetExpressionableExtensionType = Node<ts.Node & {
    initializer?: ts.Expression;
}>;

export interface InitializerGetExpressionableNode {
    /**
     * Gets if node has an initializer.
     */
    hasInitializer(): boolean;
    /**
     * Gets the initializer.
     */
    getInitializer(): Expression | undefined;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the initializer if it's a certain kind or throws.
     */
    getInitializerIfKindOrThrow(kind: SyntaxKind): Expression;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the initializer if it's a certain kind.
     */
    getInitializerIfKind(kind: SyntaxKind): Expression | undefined;
    /**
     * Gets the initializer or throw.
     */
    getInitializerOrThrow(): Expression;
}

export declare function InitializerGetExpressionableNode<T extends Constructor<InitializerGetExpressionableExtensionType>>(Base: T): Constructor<InitializerGetExpressionableNode> & T;

export declare type InitializerSetExpressionableExtensionType = Node<ts.Node & {
    initializer?: ts.Expression;
}> & InitializerGetExpressionableNode;

export interface InitializerSetExpressionableNode {
    /**
     * Removes the initailizer.
     */
    removeInitializer(): this;
    /**
     * Sets the initializer.
     * @param text - New text to set for the initializer.
     */
    setInitializer(text: string): this;
}

export declare function InitializerSetExpressionableNode<T extends Constructor<InitializerSetExpressionableExtensionType>>(Base: T): Constructor<InitializerSetExpressionableNode> & T;

export declare type BindingNamedNodeExtensionType = Node<ts.Declaration & {
    name: ts.BindingName;
}>;

export interface BindingNamedNode {
    getNameNode(): Identifier;
    getName(): string;
    /**
     * Renames the name.
     * @param text - New name.
     */
    rename(text: string): this;
}

export declare function BindingNamedNode<T extends Constructor<BindingNamedNodeExtensionType>>(Base: T): Constructor<BindingNamedNode> & T;

export declare type DeclarationNamedNodeExtensionType = Node<ts.NamedDeclaration>;

export interface DeclarationNamedNode {
    /**
     * Gets the name node.
     */
    getNameNode(): Identifier | undefined;
    /**
     * Gets the name node or throws an error if it doesn't exists.
     */
    getNameNodeOrThrow(): Identifier;
    /**
     * Gets the name.
     */
    getName(): string | undefined;
    /**
     * Gets the name or throws if it doens't exist.
     */
    getNameOrThrow(): string;
    /**
     * Renames the name.
     * @param text - Text to set as the name.
     */
    rename(text: string): this;
}

export declare function DeclarationNamedNode<T extends Constructor<DeclarationNamedNodeExtensionType>>(Base: T): Constructor<DeclarationNamedNode> & T;

export declare type NameableNodeExtensionType = Node<ts.Node & {
    name?: ts.Identifier;
}>;

export interface NameableNode {
    /**
     * Gets the name node if it exists.
     */
    getNameNode(): Identifier | undefined;
    /**
     * Gets the name node if it exists, or throws.
     */
    getNameNodeOrThrow(): Identifier;
    /**
     * Gets the name if it exists.
     */
    getName(): string | undefined;
    /**
     * Gets the name if it exists, or throws.
     */
    getNameOrThrow(): string;
    /**
     * Renames the name or sets the name if it doesn't exist.
     * @param newName - New name.
     */
    rename(newName: string): this;
}

export declare function NameableNode<T extends Constructor<NameableNodeExtensionType>>(Base: T): Constructor<NameableNode> & T;

export declare type NamedNodeExtensionType = Node<ts.Node & {
    name: ts.Identifier;
}>;

export interface NamedNode {
    /**
     * Gets the name node.
     */
    getNameNode(): Identifier;
    /**
     * Gets the name.
     */
    getName(): string;
    /**
     * Renames the name.
     * @param newName - New name.
     */
    rename(newName: string): this;
}

export declare function NamedNode<T extends Constructor<NamedNodeExtensionType>>(Base: T): Constructor<NamedNode> & T;

export declare type PropertyNamedNodeExtensionType = Node<ts.Node & {
    name: ts.PropertyName;
}>;

export interface PropertyNamedNode {
    getNameNode(): PropertyName;
    getName(): string;
    rename(text: string): this;
}

export declare function PropertyNamedNode<T extends Constructor<PropertyNamedNodeExtensionType>>(Base: T): Constructor<PropertyNamedNode> & T;

export declare type AbstractableNodeExtensionType = Node & ModifierableNode;

export interface AbstractableNode {
    /**
     * Gets if the node is abstract.
     */
    isAbstract(): boolean;
    /**
     * Gets the abstract keyword or undefined if it doesn't exist.
     */
    getAbstractKeyword(): Node | undefined;
    /**
     * Gets the abstract keyword or throws if it doesn't exist.
     */
    getAbstractKeywordOrThrow(): Node;
    /**
     * Sets if the node is abstract.
     * @param isAbstract - If it should be abstract or not.
     */
    setIsAbstract(isAbstract: boolean): this;
}

export declare function AbstractableNode<T extends Constructor<AbstractableNodeExtensionType>>(Base: T): Constructor<AbstractableNode> & T;

export declare type ClassInstancePropertyTypes = PropertyDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ParameterDeclaration;

export declare type ClassInstanceMemberTypes = MethodDeclaration | ClassInstancePropertyTypes;

export declare type ClassStaticPropertyTypes = PropertyDeclaration | GetAccessorDeclaration | SetAccessorDeclaration;

export declare type ClassStaticMemberTypes = MethodDeclaration | ClassStaticPropertyTypes;

export declare type ClassMemberTypes = MethodDeclaration | PropertyDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | ParameterDeclaration;

export declare const ClassDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => ImplementsClauseableNode) & (new (...args: any[]) => HeritageClauseableNode) & (new (...args: any[]) => DecoratableNode) & (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => NamespaceChildableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => AmbientableNode) & (new (...args: any[]) => AbstractableNode) & (new (...args: any[]) => ExportableNode) & (new (...args: any[]) => ModifierableNode) & (new (...args: any[]) => NamedNode) & typeof Statement;

export declare class ClassDeclaration extends ClassDeclarationBase<ts.ClassDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<ClassDeclarationStructure>): this;
    /**
     * Sets the extends expression.
     * @param text - Text to set as the extends expression.
     */
    setExtends(text: string): this;
    /**
     * Removes the extends expression, if it exists.
     */
    removeExtends(): this;
    /**
     * Gets the extends expression or throws if it doesn't exist.
     */
    getExtendsOrThrow(): ExpressionWithTypeArguments;
    /**
     * Gets the extends expression or return sundefined if it doesn't exist.
     */
    getExtends(): ExpressionWithTypeArguments | undefined;
    /**
     * Adds a constructor. Will remove the previous constructor if it exists.
     * @param structure - Structure of the constructor.
     */
    addConstructor(structure?: ConstructorDeclarationStructure): ConstructorDeclaration;
    /**
     * Inserts a constructor. Will remove the previous constructor if it exists.
     * @param index - Index to insert at.
     * @param structure - Structure of the constructor.
     */
    insertConstructor(index: number, structure?: ConstructorDeclarationStructure): ConstructorDeclaration;
    /**
     * Gets the constructor declarations.
     */
    getConstructors(): ConstructorDeclaration[];
    /**
     * Add get accessor.
     * @param structure - Structure representing the get accessor.
     */
    addGetAccessor(structure: GetAccessorDeclarationStructure): GetAccessorDeclaration;
    /**
     * Add properties.
     * @param structures - Structures representing the properties.
     */
    addGetAccessors(structures: GetAccessorDeclarationStructure[]): GetAccessorDeclaration[];
    /**
     * Insert get accessor.
     * @param index - Index to insert at.
     * @param structure - Structure representing the get accessor.
     */
    insertGetAccessor(index: number, structure: GetAccessorDeclarationStructure): GetAccessorDeclaration;
    /**
     * Insert properties.
     * @param index - Index to insert at.
     * @param structures - Structures representing the properties.
     */
    insertGetAccessors(index: number, structures: GetAccessorDeclarationStructure[]): GetAccessorDeclaration[];
    /**
     * Add set accessor.
     * @param structure - Structure representing the set accessor.
     */
    addSetAccessor(structure: SetAccessorDeclarationStructure): SetAccessorDeclaration;
    /**
     * Add properties.
     * @param structures - Structures representing the properties.
     */
    addSetAccessors(structures: SetAccessorDeclarationStructure[]): SetAccessorDeclaration[];
    /**
     * Insert set accessor.
     * @param index - Index to insert at.
     * @param structure - Structure representing the set accessor.
     */
    insertSetAccessor(index: number, structure: SetAccessorDeclarationStructure): SetAccessorDeclaration;
    /**
     * Insert properties.
     * @param index - Index to insert at.
     * @param structures - Structures representing the properties.
     */
    insertSetAccessors(index: number, structures: SetAccessorDeclarationStructure[]): SetAccessorDeclaration[];
    /**
     * Add property.
     * @param structure - Structure representing the property.
     */
    addProperty(structure: PropertyDeclarationStructure): PropertyDeclaration;
    /**
     * Add properties.
     * @param structures - Structures representing the properties.
     */
    addProperties(structures: PropertyDeclarationStructure[]): PropertyDeclaration[];
    /**
     * Insert property.
     * @param index - Index to insert at.
     * @param structure - Structure representing the property.
     */
    insertProperty(index: number, structure: PropertyDeclarationStructure): PropertyDeclaration;
    /**
     * Insert properties.
     * @param index - Index to insert at.
     * @param structures - Structures representing the properties.
     */
    insertProperties(index: number, structures: PropertyDeclarationStructure[]): PropertyDeclaration[];
    /**
     * Gets the first instance property by name.
     * @param name - Name.
     */
    getInstanceProperty(name: string): ClassInstancePropertyTypes | undefined;
    /**
     * Gets the first instance property by a find function.
     * @param findFunction - Function to find an instance property by.
     */
    getInstanceProperty(findFunction: (prop: ClassInstancePropertyTypes) => boolean): ClassInstancePropertyTypes | undefined;
    /**
     * Gets the first instance property by name or throws if not found.
     * @param name - Name.
     */
    getInstancePropertyOrThrow(name: string): ClassInstancePropertyTypes;
    /**
     * Gets the first instance property by a find function or throws if not found.
     * @param findFunction - Function to find an instance property by.
     */
    getInstancePropertyOrThrow(findFunction: (prop: ClassInstancePropertyTypes) => boolean): ClassInstancePropertyTypes;
    /**
     * Gets the class instance property declarations.
     */
    getInstanceProperties(): ClassInstancePropertyTypes[];
    /**
     * Gets the first static property by name.
     * @param name - Name.
     */
    getStaticProperty(name: string): ClassStaticPropertyTypes | undefined;
    /**
     * Gets the first static property by a find function.
     * @param findFunction - Function to find a static property by.
     */
    getStaticProperty(findFunction: (prop: ClassStaticPropertyTypes) => boolean): ClassStaticPropertyTypes | undefined;
    /**
     * Gets the first static property by name or throws if not found.
     * @param name - Name.
     */
    getStaticPropertyOrThrow(name: string): ClassStaticPropertyTypes;
    /**
     * Gets the first static property by a find function. or throws if not found.
     * @param findFunction - Function to find a static property by.
     */
    getStaticPropertyOrThrow(findFunction: (prop: ClassStaticPropertyTypes) => boolean): ClassStaticPropertyTypes;
    /**
     * Gets the class instance property declarations.
     */
    getStaticProperties(): ClassStaticPropertyTypes[];
    /**
     * Add method.
     * @param structure - Structure representing the method.
     */
    addMethod(structure: MethodDeclarationStructure): MethodDeclaration;
    /**
     * Add methods.
     * @param structures - Structures representing the methods.
     */
    addMethods(structures: MethodDeclarationStructure[]): MethodDeclaration[];
    /**
     * Insert method.
     * @param index - Index to insert at.
     * @param structure - Structure representing the method.
     */
    insertMethod(index: number, structure: MethodDeclarationStructure): MethodDeclaration;
    /**
     * Insert methods.
     * @param index - Index to insert at.
     * @param structures - Structures representing the methods.
     */
    insertMethods(index: number, structures: MethodDeclarationStructure[]): MethodDeclaration[];
    /**
     * Gets the first instance method by name.
     * @param name - Name.
     */
    getInstanceMethod(name: string): MethodDeclaration | undefined;
    /**
     * Gets the first instance method by a find function.
     * @param findFunction - Function to find an instance method by.
     */
    getInstanceMethod(findFunction: (method: MethodDeclaration) => boolean): MethodDeclaration | undefined;
    /**
     * Gets the first instance method by name or throws if not found.
     * @param name - Name.
     */
    getInstanceMethodOrThrow(name: string): MethodDeclaration;
    /**
     * Gets the first instance method by a find function. or throws if not found.
     * @param findFunction - Function to find an instance method by.
     */
    getInstanceMethodOrThrow(findFunction: (method: MethodDeclaration) => boolean): MethodDeclaration;
    /**
     * Gets the class instance method declarations.
     */
    getInstanceMethods(): MethodDeclaration[];
    /**
     * Gets the first static method by name.
     * @param name - Name.
     */
    getStaticMethod(name: string): MethodDeclaration | undefined;
    /**
     * Gets the first static method by a find function.
     * @param findFunction - Function to find a static method by.
     */
    getStaticMethod(findFunction: (method: MethodDeclaration) => boolean): MethodDeclaration | undefined;
    /**
     * Gets the first static method by name or throws if not found.
     * @param name - Name.
     */
    getStaticMethodOrThrow(name: string): MethodDeclaration;
    /**
     * Gets the first static method by a find function. or throws if not found.
     * @param findFunction - Function to find a static method by.
     */
    getStaticMethodOrThrow(findFunction: (method: MethodDeclaration) => boolean): MethodDeclaration;
    /**
     * Gets the class instance method declarations.
     */
    getStaticMethods(): MethodDeclaration[];
    /**
     * Gets the first instance member by name.
     * @param name - Name.
     */
    getInstanceMember(name: string): ClassInstanceMemberTypes | undefined;
    /**
     * Gets the first instance member by a find function.
     * @param findFunction - Function to find the instance member by.
     */
    getInstanceMember(findFunction: (member: ClassInstanceMemberTypes) => boolean): ClassInstanceMemberTypes | undefined;
    /**
     * Gets the first instance member by name or throws if not found.
     * @param name - Name.
     */
    getInstanceMemberOrThrow(name: string): ClassInstanceMemberTypes;
    /**
     * Gets the first instance member by a find function. or throws if not found.
     * @param findFunction - Function to find the instance member by.
     */
    getInstanceMemberOrThrow(findFunction: (member: ClassInstanceMemberTypes) => boolean): ClassInstanceMemberTypes;
    /**
     * Gets the instance members.
     */
    getInstanceMembers(): (MethodDeclaration | ParameterDeclaration | GetAccessorDeclaration | PropertyDeclaration | SetAccessorDeclaration)[];
    /**
     * Gets the first static member by name.
     * @param name - Name.
     */
    getStaticMember(name: string): ClassStaticMemberTypes | undefined;
    /**
     * Gets the first static member by a find function.
     * @param findFunction - Function to find an static method by.
     */
    getStaticMember(findFunction: (member: ClassStaticMemberTypes) => boolean): ClassStaticMemberTypes | undefined;
    /**
     * Gets the first static member by name or throws if not found.
     * @param name - Name.
     */
    getStaticMemberOrThrow(name: string): ClassStaticMemberTypes;
    /**
     * Gets the first static member by a find function. or throws if not found.
     * @param findFunction - Function to find an static method by.
     */
    getStaticMemberOrThrow(findFunction: (member: ClassStaticMemberTypes) => boolean): ClassStaticMemberTypes;
    /**
     * Gets the static members.
     */
    getStaticMembers(): (MethodDeclaration | GetAccessorDeclaration | PropertyDeclaration | SetAccessorDeclaration)[];
    /**
     * Gets the constructors, methods, properties, and class parameter properties (regardless of whether an instance of static member).
     */
    getMembers(): ClassMemberTypes[];
    /**
     * Gets the base types.
     *
     * This is useful to use if the base could possibly be a mixin.
     */
    getBaseTypes(): Type[];
    /**
     * Gets the base class or throws.
     *
     * Note: Use getBaseTypes if you need to get the mixins.
     */
    getBaseClassOrThrow(): ClassDeclaration;
    /**
     * Gets the base class.
     *
     * Note: Use getBaseTypes if you need to get the mixins.
     */
    getBaseClass(): ClassDeclaration | undefined;
    /**
     * Gets all the derived classes.
     */
    getDerivedClasses(): ClassDeclaration[];
    private getImmediateDerivedClasses();
    private getBodyMembers();
}

export declare const ConstructorDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => OverloadableNode) & (new (...args: any[]) => ScopedNode) & (new (...args: any[]) => FunctionLikeDeclaration) & (new (...args: any[]) => BodyableNode) & typeof Node;

export declare class ConstructorDeclaration extends ConstructorDeclarationBase<ts.ConstructorDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<ConstructorDeclarationStructure>): this;
    /**
     * Add a constructor overload.
     * @param structure - Structure to add.
     */
    addOverload(structure: ConstructorDeclarationOverloadStructure): ConstructorDeclaration;
    /**
     * Add constructor overloads.
     * @param structures - Structures to add.
     */
    addOverloads(structures: ConstructorDeclarationOverloadStructure[]): ConstructorDeclaration[];
    /**
     * Inserts a constructor overload.
     * @param index - Index to insert at.
     * @param structure - Structures to insert.
     */
    insertOverload(index: number, structure: ConstructorDeclarationOverloadStructure): ConstructorDeclaration;
    /**
     * Inserts constructor overloads.
     * @param index - Index to insert at.
     * @param structures - Structures to insert.
     */
    insertOverloads(index: number, structures: ConstructorDeclarationOverloadStructure[]): ConstructorDeclaration[];
    /**
     * Remove the constructor.
     */
    remove(): void;
}

export declare const GetAccessorDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => DecoratableNode) & (new (...args: any[]) => AbstractableNode) & (new (...args: any[]) => ScopedNode) & (new (...args: any[]) => StaticableNode) & (new (...args: any[]) => BodiedNode) & (new (...args: any[]) => FunctionLikeDeclaration) & (new (...args: any[]) => PropertyNamedNode) & typeof Node;

export declare class GetAccessorDeclaration extends GetAccessorDeclarationBase<ts.GetAccessorDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<GetAccessorDeclarationStructure>): this;
    /**
     * Gets the corresponding set accessor if one exists.
     */
    getSetAccessor(): SetAccessorDeclaration | undefined;
    /**
     * Gets the corresponding set accessor or throws if not exists.
     */
    getSetAccessorOrThrow(): SetAccessorDeclaration;
    /**
     * Removes the get accessor.
     */
    remove(): void;
}

export declare const MethodDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => OverloadableNode) & (new (...args: any[]) => BodyableNode) & (new (...args: any[]) => DecoratableNode) & (new (...args: any[]) => AbstractableNode) & (new (...args: any[]) => ScopedNode) & (new (...args: any[]) => StaticableNode) & (new (...args: any[]) => AsyncableNode) & (new (...args: any[]) => GeneratorableNode) & (new (...args: any[]) => FunctionLikeDeclaration) & (new (...args: any[]) => PropertyNamedNode) & typeof Node;

export declare class MethodDeclaration extends MethodDeclarationBase<ts.MethodDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<MethodDeclarationStructure>): this;
    /**
     * Add a method overload.
     * @param structure - Structure to add.
     */
    addOverload(structure: MethodDeclarationOverloadStructure): MethodDeclaration;
    /**
     * Add method overloads.
     * @param structures - Structures to add.
     */
    addOverloads(structures: MethodDeclarationOverloadStructure[]): MethodDeclaration[];
    /**
     * Inserts a method overload.
     * @param index - Index to insert at.
     * @param structure - Structures to insert.
     */
    insertOverload(index: number, structure: MethodDeclarationOverloadStructure): MethodDeclaration;
    /**
     * Inserts method overloads.
     * @param index - Index to insert at.
     * @param structures - Structures to insert.
     */
    insertOverloads(index: number, structures: MethodDeclarationOverloadStructure[]): MethodDeclaration[];
    /**
     * Removes the method.
     */
    remove(): void;
}

export declare const PropertyDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => DecoratableNode) & (new (...args: any[]) => AbstractableNode) & (new (...args: any[]) => ScopedNode) & (new (...args: any[]) => StaticableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => ReadonlyableNode) & (new (...args: any[]) => QuestionTokenableNode) & (new (...args: any[]) => InitializerExpressionableNode) & (new (...args: any[]) => TypedNode) & (new (...args: any[]) => PropertyNamedNode) & (new (...args: any[]) => ModifierableNode) & typeof Node;

export declare class PropertyDeclaration extends PropertyDeclarationBase<ts.PropertyDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<PropertyDeclarationStructure>): this;
    /**
     * Removes the property.
     */
    remove(): void;
}

export declare const SetAccessorDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => DecoratableNode) & (new (...args: any[]) => AbstractableNode) & (new (...args: any[]) => ScopedNode) & (new (...args: any[]) => StaticableNode) & (new (...args: any[]) => BodiedNode) & (new (...args: any[]) => FunctionLikeDeclaration) & (new (...args: any[]) => PropertyNamedNode) & typeof Node;

export declare class SetAccessorDeclaration extends SetAccessorDeclarationBase<ts.SetAccessorDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<SetAccessorDeclarationStructure>): this;
    /**
     * Gets the corresponding get accessor if one exists.
     */
    getGetAccessor(): GetAccessorDeclaration | undefined;
    /**
     * Gets the corresponding get accessor or throws if not exists.
     */
    getGetAccessorOrThrow(): GetAccessorDeclaration;
    /**
     * Removes the set accessor.
     */
    remove(): void;
}

export declare class ComputedPropertyName extends Node<ts.ComputedPropertyName> {
    /**
     * Gets the expression.
     */
    getExpression(): Expression;
}

export declare class Identifier extends PrimaryExpression<ts.Identifier> {
    /**
     * Gets the text for the identifier.
     */
    getText(): string;
    /**
     * Renames the identifier.
     * @param newName - New name of the identifier.
     */
    rename(newName: string): void;
    /**
     * Finds all the references of this identifier.
     */
    findReferences(): ReferencedSymbol[];
    /**
     * Gets the definitions of the current identifier.
     *
     * This is similar to "go to definition."
     */
    getDefinitions(): DefinitionInfo[];
    /**
     * Gets the implementations of the current identifier.
     *
     * This is similar to "go to implementation."
     */
    getImplementations(): ImplementationLocation[];
}


export declare class Node<NodeType extends ts.Node = ts.Node> {
    /**
     * Gets the underlying compiler node.
     */
    readonly compilerNode: NodeType;
    /**
     * Releases the node and all its descendants from the underlying node cache and ast.
     *
     * This is useful if you want to improve the performance of manipulation by not tracking this node anymore.
     */
    forget(): void;
    /**
     * Gets if the node was forgotten.
     *
     * This will be true when the node was forgotten or removed.
     */
    wasForgotten(): boolean;
    /**
     * Gets the syntax kind.
     */
    getKind(): SyntaxKind;
    /**
     * Gets the syntax kind name.
     */
    getKindName(): string;
    /**
     * Prints the node using the compiler's printer.
     * @param options - Options.
     */
    print(options?: PrintNodeOptions): string;
    /**
     * Gets the symbol or throws an error if it doesn't exist.
     */
    getSymbolOrThrow(): Symbol;
    /**
     * Gets the compiler symbol or undefined if it doesn't exist.
     */
    getSymbol(): Symbol | undefined;
    /**
     * Gets the type of the node.
     */
    getType(): Type;
    /**
     * If the node contains the provided range (inclusive).
     * @param pos - Start position.
     * @param end - End position.
     */
    containsRange(pos: number, end: number): boolean;
    /**
     * Gets if the specified position is within a string.
     * @param pos - Position.
     */
    isInStringAtPos(pos: number): boolean;
    /**
     * Gets the first child by a condition or throws.
     * @param condition - Condition.
     */
    getFirstChildOrThrow(condition?: (node: Node) => boolean): Node<ts.Node>;
    /**
     * Gets the first child by a condition.
     * @param condition - Condition.
     */
    getFirstChild(condition?: (node: Node) => boolean): Node | undefined;
    /**
     * Gets the last child by a condition or throws.
     * @param condition - Condition.
     */
    getLastChildOrThrow(condition?: (node: Node) => boolean): Node<ts.Node>;
    /**
     * Gets the last child by a condition.
     * @param condition - Condition.
     */
    getLastChild(condition?: (node: Node) => boolean): Node | undefined;
    /**
     * Gets the first descendant by a condition or throws.
     * @param condition - Condition.
     */
    getFirstDescendantOrThrow(condition?: (node: Node) => boolean): Node<ts.Node>;
    /**
     * Gets the first descendant by a condition.
     * @param condition - Condition.
     */
    getFirstDescendant(condition?: (node: Node) => boolean): Node<ts.Node> | undefined;
    /**
     * Gets the previous sibling or throws.
     * @param condition - Optional condition for getting the previous sibling.
     */
    getPreviousSiblingOrThrow(condition?: (node: Node) => boolean): Node<ts.Node>;
    /**
     * Gets the previous sibling.
     * @param condition - Optional condition for getting the previous sibling.
     */
    getPreviousSibling(condition?: (node: Node) => boolean): Node | undefined;
    /**
     * Gets the next sibling or throws.
     * @param condition - Optional condition for getting the next sibling.
     */
    getNextSiblingOrThrow(condition?: (node: Node) => boolean): Node<ts.Node>;
    /**
     * Gets the next sibling.
     * @param condition - Optional condition for getting the previous sibling.
     */
    getNextSibling(condition?: (node: Node) => boolean): Node | undefined;
    /**
     * Gets the previous siblings.
     *
     * Note: Closest sibling is the zero index.
     */
    getPreviousSiblings(): Node[];
    /**
     * Gets the next siblings.
     *
     * Note: Closest sibling is the zero index.
     */
    getNextSiblings(): Node[];
    /**
     * Gets the children of the node.
     */
    getChildren(): Node[];
    /**
     * Gets the child at the specified index.
     * @param index - Index of the child.
     */
    getChildAtIndex(index: number): Node;
    /**
     * Gets the child syntax list or throws if it doesn't exist.
     */
    getChildSyntaxListOrThrow(): SyntaxList;
    /**
     * Gets the child syntax list if it exists.
     */
    getChildSyntaxList(): SyntaxList | undefined;
    /**
     * Gets the node's descendants.
     */
    getDescendants(): Node[];
    /**
     * Gets the child count.
     */
    getChildCount(): number;
    /**
     * Gets the child at the provided position, or undefined if not found.
     * @param pos - Position to search for.
     */
    getChildAtPos(pos: number): Node | undefined;
    /**
     * Gets the most specific descendant at the provided position, or undefined if not found.
     * @param pos - Position to search for.
     */
    getDescendantAtPos(pos: number): Node | undefined;
    /**
     * Gets the most specific descendant at the provided start position with the specified width, or undefined if not found.
     * @param start - Start position to search for.
     * @param width - Width of the node to search for.
     */
    getDescendantAtStartWithWidth(start: number, width: number): Node | undefined;
    /**
     * Gets the start position with leading trivia.
     */
    getPos(): number;
    /**
     * Gets the end position.
     */
    getEnd(): number;
    /**
     * Gets the start position without leading trivia.
     * @param includeJsDocComment - Whether to include the JS doc comment.
     */
    getStart(includeJsDocComment?: boolean): number;
    /**
     * Gets the end position of the last significant token.
     */
    getFullStart(): number;
    /**
     * Gets the first position from the pos that is not whitespace.
     */
    getNonWhitespaceStart(): number;
    /**
     * Gets the width of the node (length without trivia).
     */
    getWidth(): number;
    /**
     * Gets the full width of the node (length with trivia).
     */
    getFullWidth(): number;
    /**
     * Gets the text without leading trivia.
     */
    getText(): string;
    /**
     * Gets the full text with leading trivia.
     */
    getFullText(): string;
    /**
     * Gets the combined modifier flags.
     */
    getCombinedModifierFlags(): ts.ModifierFlags;
    /**
     * Gets the source file.
     */
    getSourceFile(): SourceFile;
    /**
     * Gets a compiler node property wrapped in a Node.
     * @param propertyName - Property name.
     */
    getNodeProperty<KeyType extends keyof NodeType>(propertyName: KeyType): Node;
    /**
     * Goes up the tree getting all the parents in ascending order.
     */
    getAncestors(): Node[];
    /**
     * Get the node's parent.
     */
    getParent(): Node | undefined;
    /**
     * Gets the parent or throws an error if it doesn't exist.
     */
    getParentOrThrow(): Node<ts.Node>;
    /**
     * Goes up the parents (ancestors) of the node while a condition is true.
     * Throws if the initial parent doesn't match the condition.
     * @param condition - Condition that tests the parent to see if the expression is true.
     */
    getParentWhileOrThrow(condition: (node: Node) => boolean): Node<ts.Node>;
    /**
     * Goes up the parents (ancestors) of the node while a condition is true.
     * Returns undefined if the initial parent doesn't match the condition.
     * @param condition - Condition that tests the parent to see if the expression is true.
     */
    getParentWhile(condition: (node: Node) => boolean): Node<ts.Node> | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Throws if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Goes up the parents (ancestors) of the node while the parent is the specified syntax kind.
     * Returns undefined if the initial parent is not the specified syntax kind.
     * @param kind - Syntax kind to check for.
     */
    getParentWhileKind(kind: SyntaxKind): Node<ts.Node> | undefined;
    /**
     * Gets the last token of this node. Usually this is a close brace.
     */
    getLastToken(): Node;
    /**
     * Gets if this node is in a syntax list.
     */
    isInSyntaxList(): boolean;
    /**
     * Gets the parent if it's a syntax list or throws an error otherwise.
     */
    getParentSyntaxListOrThrow(): Node<ts.Node>;
    /**
     * Gets the parent if it's a syntax list.
     */
    getParentSyntaxList(): Node | undefined;
    /**
     * Gets the child index of this node relative to the parent.
     */
    getChildIndex(): number;
    /**
     * Gets the indentation text.
     */
    getIndentationText(): string;
    /**
     * Gets the next indentation level text.
     */
    getChildIndentationText(): string;
    /**
     * Gets the position of the start of the line that this node starts on.
     * @param includeJsDocComment - Whether to include the JS doc comment or not.
     */
    getStartLinePos(includeJsDocComment?: boolean): number;
    /**
     * Gets the line number at the start of the node.
     * @param includeJsDocComment - Whether to include the JS doc comment or not.
     */
    getStartLineNumber(includeJsDocComment?: boolean): number;
    /**
     * Gets the line number of the end of the node.
     */
    getEndLineNumber(): number;
    /**
     * Gets if this is the first node on the current line.
     */
    isFirstNodeOnLine(): boolean;
    /**
     * Replaces the text of the current node with new text.
     *
     * This will forget the current node and return a new node that can be asserted or type guarded to the correct type.
     * @param writerFunction - Write the text using the provided writer.
     * @returns The new node.
     */
    replaceWithText(writerFunction: (writer: CodeBlockWriter) => void): Node;
    /**
     * Replaces the text of the current node with new text.
     *
     * This will forget the current node and return a new node that can be asserted or type guarded to the correct type.
     * @param text - Text to replace with.
     * @returns The new node.
     */
    replaceWithText(text: string): Node;
    /**
     * Formats the node's text using the internal TypeScript formatting API.
     * @param settings - Format code settings.
     */
    formatText(settings?: FormatCodeSettings): void;
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.SourceFile): SourceFile[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ArrayType): ArrayTypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ArrowFunction): ArrowFunction[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.AsExpression): AsExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.AwaitExpression): AwaitExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.BinaryExpression): BinaryExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.Block): Block[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.BreakStatement): BreakStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.CallExpression): CallExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.CaseBlock): CaseBlock[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.CaseClause): CaseClause[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.CatchClause): CatchClause[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.Constructor): ConstructorDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ContinueStatement): ContinueStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.CommaListExpression): CommaListExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.Decorator): Decorator[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.DefaultClause): DefaultClause[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.DeleteExpression): DeleteExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.DoStatement): DoStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.EmptyStatement): EmptyStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.EnumMember): EnumMember[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ExportAssignment): ExportAssignment[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.NumericLiteral): NumericLiteral[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.FirstNode): QualifiedName[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.QualifiedName): QualifiedName[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ForInStatement): ForInStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ForOfStatement): ForOfStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ForStatement): ForStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.FunctionExpression): FunctionExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.FunctionType): FunctionTypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.HeritageClause): HeritageClause[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.Identifier): Identifier[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.IfStatement): IfStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxAttribute): JsxAttribute[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxElement): JsxElement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxExpression): JsxExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxFragment): JsxFragment[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JsxText): JsxText[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.LabeledStatement): LabeledStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.LiteralType): LiteralTypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.MetaProperty): MetaProperty[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.MethodSignature): MethodSignature[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.NewExpression): NewExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.NonNullExpression): NonNullExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.OmittedExpression): OmittedExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.Parameter): ParameterDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.PropertySignature): PropertySignature[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ReturnStatement): ReturnStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.SpreadElement): SpreadElement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.StringLiteral): StringLiteral[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.SwitchStatement): SwitchStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.SyntaxList): SyntaxList[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TemplateExpression): TemplateExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TemplateHead): TemplateHead[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TemplateSpan): TemplateSpan[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TemplateTail): TemplateTail[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ThrowStatement): ThrowStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TryStatement): TryStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TupleType): TupleTypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TypeReference): TypeReferenceNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.UnionType): UnionTypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.VariableStatement): VariableStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.JSDocComment): JSDoc[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.FirstTypeNode): TypeNode[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.WhileStatement): WhileStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.WithStatement): WithStatement[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.YieldExpression): YieldExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.AnyKeyword): Expression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.BooleanKeyword): Expression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.NeverKeyword): Expression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.NumberKeyword): Expression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ObjectKeyword): Expression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.StringKeyword): Expression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.SymbolKeyword): Expression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.UndefinedKeyword): Expression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ImportKeyword): ImportExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.NullKeyword): NullLiteral[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.SuperKeyword): SuperExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.ThisKeyword): ThisExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind.VoidKeyword): VoidExpression[];
    /**
     * Gets the children based on a kind.
     * @param kind - Syntax kind.
     */
    getChildrenOfKind(kind: SyntaxKind): Node[];
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the first child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildByKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the first child by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildByKind(kind: SyntaxKind): Node | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the first child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the first child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstChildIfKind(kind: SyntaxKind): Node | undefined;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the last child by syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildByKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the last child by syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildByKind(kind: SyntaxKind): Node | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the last child if it matches the specified syntax kind or throws an error if not found.
     * @param kind - Syntax kind.
     */
    getLastChildIfKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the last child if it matches the specified syntax kind.
     * @param kind - Syntax kind.
     */
    getLastChildIfKind(kind: SyntaxKind): Node | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.Block): Block;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the child at the specified index if it's the specified kind or throws an exception.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKindOrThrow(index: number, kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the child at the specified index if it's the specified kind or returns undefined.
     * @param index - Index to get.
     * @param kind - Expected kind.
     */
    getChildAtIndexIfKind(index: number, kind: SyntaxKind): Node | undefined;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the previous sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the next sibiling if it matches the specified kind, or throws.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the previous sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getPreviousSiblingIfKind(kind: SyntaxKind): Node | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the next sibling if it matches the specified kind.
     * @param kind - Kind to check.
     */
    getNextSiblingIfKind(kind: SyntaxKind): Node | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the parent if it's a certain syntax kind.
     */
    getParentIfKind(kind: SyntaxKind): Node | undefined;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the parent if it's a certain syntax kind of throws.
     */
    getParentIfKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the first ancestor by syntax kind or throws if not found.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Get the first ancestor by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstAncestorByKind(kind: SyntaxKind): Node | undefined;
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.SourceFile): SourceFile[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ArrayType): ArrayTypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ArrowFunction): ArrowFunction[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.AsExpression): AsExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.AwaitExpression): AwaitExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.BinaryExpression): BinaryExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.Block): Block[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.BreakStatement): BreakStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.CallExpression): CallExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.CaseBlock): CaseBlock[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.CaseClause): CaseClause[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.CatchClause): CatchClause[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.Constructor): ConstructorDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ContinueStatement): ContinueStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.CommaListExpression): CommaListExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.Decorator): Decorator[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.DefaultClause): DefaultClause[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.DeleteExpression): DeleteExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.DoStatement): DoStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.EmptyStatement): EmptyStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.EnumMember): EnumMember[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ExportAssignment): ExportAssignment[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.NumericLiteral): NumericLiteral[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.FirstNode): QualifiedName[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.QualifiedName): QualifiedName[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ForInStatement): ForInStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ForOfStatement): ForOfStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ForStatement): ForStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.FunctionExpression): FunctionExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.FunctionType): FunctionTypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.HeritageClause): HeritageClause[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.Identifier): Identifier[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.IfStatement): IfStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxAttribute): JsxAttribute[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxElement): JsxElement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxExpression): JsxExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxFragment): JsxFragment[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JsxText): JsxText[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.LabeledStatement): LabeledStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.LiteralType): LiteralTypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.MetaProperty): MetaProperty[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.MethodSignature): MethodSignature[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.NewExpression): NewExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.NonNullExpression): NonNullExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.OmittedExpression): OmittedExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.Parameter): ParameterDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.PropertySignature): PropertySignature[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ReturnStatement): ReturnStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.SpreadElement): SpreadElement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.StringLiteral): StringLiteral[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.SwitchStatement): SwitchStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.SyntaxList): SyntaxList[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TemplateExpression): TemplateExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TemplateHead): TemplateHead[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TemplateSpan): TemplateSpan[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TemplateTail): TemplateTail[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ThrowStatement): ThrowStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TryStatement): TryStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TupleType): TupleTypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TypeReference): TypeReferenceNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.UnionType): UnionTypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.VariableStatement): VariableStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.JSDocComment): JSDoc[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.FirstTypeNode): TypeNode[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.WhileStatement): WhileStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.WithStatement): WithStatement[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.YieldExpression): YieldExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.AnyKeyword): Expression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.BooleanKeyword): Expression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.NeverKeyword): Expression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.NumberKeyword): Expression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ObjectKeyword): Expression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.StringKeyword): Expression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.SymbolKeyword): Expression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.UndefinedKeyword): Expression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ImportKeyword): ImportExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.NullKeyword): NullLiteral[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.SuperKeyword): SuperExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.ThisKeyword): ThisExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind.VoidKeyword): VoidExpression[];
    /**
     * Gets the descendants that match a specified syntax kind.
     * @param kind - Kind to check.
     */
    getDescendantsOfKind(kind: SyntaxKind): Node<ts.Node>[];
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.SourceFile): SourceFile;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ArrayType): ArrayTypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ArrowFunction): ArrowFunction;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.AsExpression): AsExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.AwaitExpression): AwaitExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.BinaryExpression): BinaryExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.CallExpression): CallExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.CallSignature): CallSignatureDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.CaseBlock): CaseBlock;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.CaseClause): CaseClause;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.CatchClause): CatchClause;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.Constructor): ConstructorDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ConstructorType): ConstructorTypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.CommaListExpression): CommaListExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ConditionalExpression): ConditionalExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.Decorator): Decorator;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.DefaultClause): DefaultClause;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.DeleteExpression): DeleteExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.EnumMember): EnumMember;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ExportSpecifier): ExportSpecifier;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.FirstLiteralToken): NumericLiteral;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.NumericLiteral): NumericLiteral;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.FirstNode): QualifiedName;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.QualifiedName): QualifiedName;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.FunctionExpression): FunctionExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.FunctionType): FunctionTypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.HeritageClause): HeritageClause;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.Identifier): Identifier;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ImportSpecifier): ImportSpecifier;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.IntersectionType): IntersectionTypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocTag): JSDocUnknownTag;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocClassTag): JSDocClassTag;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxAttribute): JsxAttribute;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxClosingElement): JsxClosingElement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxElement): JsxElement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxExpression): JsxExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxFragment): JsxFragment;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JsxText): JsxText;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.LiteralType): LiteralTypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.LastTypeNode): LiteralTypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.MetaProperty): MetaProperty;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.MethodDeclaration): MethodDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.MethodSignature): MethodSignature;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.NewExpression): NewExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.NonNullExpression): NonNullExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.OmittedExpression): OmittedExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.Parameter): ParameterDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.PropertyAssignment): PropertyAssignment;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.PropertySignature): PropertySignature;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.SpreadAssignment): SpreadAssignment;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.SpreadElement): SpreadElement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.StringLiteral): StringLiteral;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.SyntaxList): SyntaxList;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TemplateExpression): TemplateExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TemplateHead): TemplateHead;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TemplateMiddle): TemplateMiddle;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TemplateSpan): TemplateSpan;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TemplateTail): TemplateTail;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TupleType): TupleTypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TypeReference): TypeReferenceNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.UnionType): UnionTypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.VariableDeclaration): VariableDeclaration;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.JSDocComment): JSDoc;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.FirstTypeNode): TypeNode;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TypeOfExpression): TypeOfExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.YieldExpression): YieldExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.AnyKeyword): Expression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.BooleanKeyword): Expression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.NeverKeyword): Expression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.NumberKeyword): Expression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ObjectKeyword): Expression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.StringKeyword): Expression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.SymbolKeyword): Expression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.UndefinedKeyword): Expression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.FalseKeyword): BooleanLiteral;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.TrueKeyword): BooleanLiteral;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ImportKeyword): ImportExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.NullKeyword): NullLiteral;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.SuperKeyword): SuperExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.ThisKeyword): ThisExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind.VoidKeyword): VoidExpression;
    /**
     * Gets the first descendant by syntax kind or throws.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKindOrThrow(kind: SyntaxKind): Node<ts.Node>;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.SourceFile): SourceFile | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ArrayLiteralExpression): ArrayLiteralExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ArrayType): ArrayTypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ArrowFunction): ArrowFunction | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.AsExpression): AsExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.AwaitExpression): AwaitExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.BinaryExpression): BinaryExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.CallExpression): CallExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.CallSignature): CallSignatureDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.CaseBlock): CaseBlock | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.CaseClause): CaseClause | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.CatchClause): CatchClause | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.Constructor): ConstructorDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ConstructorType): ConstructorTypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ConstructSignature): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.CommaListExpression): CommaListExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ComputedPropertyName): ComputedPropertyName | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ConditionalExpression): ConditionalExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.Decorator): Decorator | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.DefaultClause): DefaultClause | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.DeleteExpression): DeleteExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ElementAccessExpression): ElementAccessExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.EnumMember): EnumMember | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ExportSpecifier): ExportSpecifier | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ExpressionWithTypeArguments): ExpressionWithTypeArguments | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ExternalModuleReference): ExternalModuleReference | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.FirstLiteralToken): NumericLiteral | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.NumericLiteral): NumericLiteral | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.FirstNode): QualifiedName | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.QualifiedName): QualifiedName | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.FunctionDeclaration): FunctionDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.FunctionExpression): FunctionExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.FunctionType): FunctionTypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.GetAccessor): GetAccessorDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.HeritageClause): HeritageClause | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.Identifier): Identifier | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ImportSpecifier): ImportSpecifier | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.IndexSignature): IndexSignatureDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.IntersectionType): IntersectionTypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocTag): JSDocUnknownTag | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocAugmentsTag): JSDocAugmentsTag | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocClassTag): JSDocClassTag | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocReturnTag): JSDocReturnTag | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocTypeTag): JSDocTypeTag | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocTypedefTag): JSDocTypedefTag | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocParameterTag): JSDocParameterTag | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocPropertyTag): JSDocPropertyTag | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxAttribute): JsxAttribute | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxClosingElement): JsxClosingElement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxClosingFragment): JsxClosingFragment | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxElement): JsxElement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxExpression): JsxExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxFragment): JsxFragment | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxOpeningElement): JsxOpeningElement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxOpeningFragment): JsxOpeningFragment | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxSelfClosingElement): JsxSelfClosingElement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxSpreadAttribute): JsxSpreadAttribute | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JsxText): JsxText | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.LiteralType): LiteralTypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.LastTypeNode): LiteralTypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.MetaProperty): MetaProperty | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.MethodDeclaration): MethodDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.MethodSignature): MethodSignature | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.NewExpression): NewExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.NonNullExpression): NonNullExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.NoSubstitutionTemplateLiteral): NoSubstitutionTemplateLiteral | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ObjectLiteralExpression): ObjectLiteralExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.OmittedExpression): OmittedExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.Parameter): ParameterDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ParenthesizedExpression): ParenthesizedExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.PartiallyEmittedExpression): PartiallyEmittedExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.PostfixUnaryExpression): PostfixUnaryExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.PrefixUnaryExpression): PrefixUnaryExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.PropertyAccessExpression): PropertyAccessExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.PropertyAssignment): PropertyAssignment | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.PropertyDeclaration): PropertyDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.PropertySignature): PropertySignature | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.RegularExpressionLiteral): RegularExpressionLiteral | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.SetAccessor): SetAccessorDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ShorthandPropertyAssignment): ShorthandPropertyAssignment | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.SpreadAssignment): SpreadAssignment | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.SpreadElement): SpreadElement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.StringLiteral): StringLiteral | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.SyntaxList): SyntaxList | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TaggedTemplateExpression): TaggedTemplateExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TemplateExpression): TemplateExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TemplateHead): TemplateHead | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TemplateMiddle): TemplateMiddle | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TemplateSpan): TemplateSpan | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TemplateTail): TemplateTail | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TupleType): TupleTypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TypeAssertionExpression): TypeAssertion | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TypeParameter): TypeParameterDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TypeReference): TypeReferenceNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.UnionType): UnionTypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.VariableDeclaration): VariableDeclaration | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.VariableDeclarationList): VariableDeclarationList | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.JSDocComment): JSDoc | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.FirstTypeNode): TypeNode | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TypeOfExpression): TypeOfExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.YieldExpression): YieldExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.AnyKeyword): Expression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.BooleanKeyword): Expression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.NeverKeyword): Expression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.NumberKeyword): Expression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ObjectKeyword): Expression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.StringKeyword): Expression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.SymbolKeyword): Expression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.UndefinedKeyword): Expression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.FalseKeyword): BooleanLiteral | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.TrueKeyword): BooleanLiteral | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ImportKeyword): ImportExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.NullKeyword): NullLiteral | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.SuperKeyword): SuperExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.ThisKeyword): ThisExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind.VoidKeyword): VoidExpression | undefined;
    /**
     * Gets the first descendant by syntax kind.
     * @param kind - Syntax kind.
     */
    getFirstDescendantByKind(kind: SyntaxKind): Node | undefined;
}

export declare class QualifiedName extends Node<ts.QualifiedName> {
    /**
     * Gets the left side of the qualified name.
     */
    getLeft(): EntityName;
    /**
     * Gets the right identifier of the qualified name.
     */
    getRight(): Identifier;
}
export declare enum Scope {
    Public = "public",
    Protected = "protected",
    Private = "private",
}

export declare class Signature {
    /**
     * Gets the underlying compiler signature.
     */
    readonly compilerSignature: ts.Signature;
    /**
     * Gets the type parameters.
     */
    getTypeParameters(): TypeParameter[];
    /**
     * Gets the parameters.
     */
    getParameters(): Symbol[];
    /**
     * Gets the signature return type.
     */
    getReturnType(): Type;
    /**
     * Get the documentation comments.
     */
    getDocumentationComments(): SymbolDisplayPart[];
    /**
     * Gets the JS doc tags.
     */
    getJsDocTags(): JSDocTagInfo[];
}

export declare class Symbol {
    /**
     * Gets the underlying compiler symbol.
     */
    readonly compilerSymbol: ts.Symbol;
    /**
     * Gets the symbol name.
     */
    getName(): string;
    /**
     * Gets the aliased symbol.
     */
    getAliasedSymbol(): Symbol | undefined;
    /**
     * Gets if the symbol is an alias.
     */
    isAlias(): boolean;
    /**
     * Gets the symbol flags.
     */
    getFlags(): SymbolFlags;
    /**
     * Gets if the symbol has the specified flags.
     * @param flags - Flags to check if the symbol has.
     */
    hasFlags(flags: SymbolFlags): boolean;
    /**
     * Gets if the symbols are equal.
     * @param symbol - Other symbol to check.
     */
    equals(symbol: Symbol | undefined): boolean;
    /**
     * Gets the value declaration of a symbol or throws if it doesn't exist.
     */
    getValueDeclarationOrThrow(): Node;
    /**
     * Gets the value declaration of the symbol or returns undefined if it doesn't exist.
     */
    getValueDeclaration(): Node | undefined;
    /**
     * Gets the symbol declarations.
     */
    getDeclarations(): Node[];
    /**
     * Get the exports of the symbol.
     * @param name - Name of the export.
     */
    getExportByName(name: string): Symbol | undefined;
    /**
     * Gets the exports from the symbol.
     */
    getExports(): Symbol[];
    /**
     * Gets the declared type of the symbol.
     */
    getDeclaredType(): Type;
    /**
     * Gets the type of the symbol at a location.
     * @param node - Location to get the type at for this symbol.
     */
    getTypeAtLocation(node: Node): Type<ts.Type>;
    /**
     * Gets the fully qualified name.
     */
    getFullyQualifiedName(): string;
}

export declare class SyntaxList extends Node<ts.SyntaxList> {
    /**
     * Adds text at the end of the current children.
     * @param text - Text to insert.
     * @returns The children that were added.
     */
    addChildText(text: string): Node[];
    /**
     * Adds text at the end of the current children.
     * @param writer - Write the text using the provided writer.
     * @returns The children that were added.
     */
    addChildText(writer: (writer: CodeBlockWriter) => void): Node[];
    /**
     * Inserts text at the specified child index.
     * @param index - Child index to insert at.
     * @param text - Text to insert.
     * @returns The children that were inserted.
     */
    insertChildText(index: number, text: string): Node[];
    /**
     * Inserts text at the specified child index.
     * @param index - Child index to insert at.
     * @param writer - Write the text using the provided writer.
     * @returns The children that were inserted.
     */
    insertChildText(index: number, writer: (writer: CodeBlockWriter) => void): Node[];
}

export declare const DecoratorBase: typeof Node;

export declare class Decorator extends DecoratorBase<ts.Decorator> {
    /**
     * Gets the decorator name.
     */
    getName(): string;
    /**
     * Gets the name node of the decorator.
     */
    getNameNode(): Identifier;
    /**
     * Gets the full decorator name.
     */
    getFullName(): string;
    /**
     * Gets if the decorator is a decorator factory.
     */
    isDecoratorFactory(): boolean;
    /**
     * Set if this decorator is a decorator factory.
     * @param isDecoratorFactory - If it should be a decorator factory or not.
     */
    setIsDecoratorFactory(isDecoratorFactory: boolean): this;
    /**
     * Gets the call expression if a decorator factory, or throws.
     */
    getCallExpressionOrThrow(): CallExpression;
    /**
     * Gets the call expression if a decorator factory.
     */
    getCallExpression(): CallExpression | undefined;
    /**
     * Gets the expression.
     */
    getExpression(): Expression<ts.LeftHandSideExpression>;
    /**
     * Gets the decorator's arguments from its call expression.
     */
    getArguments(): Node[];
    /**
     * Gets the decorator's type arguments from its call expression.
     */
    getTypeArguments(): TypeNode[];
    /**
     * Adds a type argument.
     * @param argumentTexts - Argument text.
     */
    addTypeArgument(argumentText: string): TypeNode<ts.TypeNode>;
    /**
     * Adds type arguments.
     * @param argumentTexts - Argument texts.
     */
    addTypeArguments(argumentTexts: string[]): TypeNode<ts.TypeNode>[];
    /**
     * Inserts a type argument.
     * @param index - Index to insert at.
     * @param argumentTexts - Argument text.
     */
    insertTypeArgument(index: number, argumentText: string): TypeNode<ts.TypeNode>;
    /**
     * Inserts type arguments.
     * @param index - Index to insert at.
     * @param argumentTexts - Argument texts.
     */
    insertTypeArguments(index: number, argumentTexts: string[]): TypeNode<ts.TypeNode>[];
    /**
     * Removes a type argument.
     * @param typeArg - Type argument to remove.
     */
    removeTypeArgument(typeArg: Node): this;
    /**
     * Removes a type argument.
     * @param index - Index to remove.
     */
    removeTypeArgument(index: number): this;
    /**
     * Adds an argument.
     * @param argumentTexts - Argument text.
     */
    addArgument(argumentText: string): Node<ts.Node>;
    /**
     * Adds arguments.
     * @param argumentTexts - Argument texts.
     */
    addArguments(argumentTexts: string[]): Node<ts.Node>[];
    /**
     * Inserts an argument.
     * @param index - Index to insert at.
     * @param argumentTexts - Argument text.
     */
    insertArgument(index: number, argumentText: string): Node<ts.Node>;
    /**
     * Inserts arguments.
     * @param index - Index to insert at.
     * @param argumentTexts - Argument texts.
     */
    insertArguments(index: number, argumentTexts: string[]): Node<ts.Node>[];
    /**
     * Removes an argument based on the node.
     * @param node - Argument's node to remove.
     */
    removeArgument(node: Node): this;
    /**
     * Removes an argument based on the specified index.
     * @param index - Index to remove.
     */
    removeArgument(index: number): this;
    /**
     * Removes this decorator.
     */
    remove(): void;
}

/**
 * JS doc node.
 */
export declare class JSDoc extends Node<ts.JSDoc> {
    /**
     * Gets the tags of the JSDoc.
     */
    getTags(): JSDocTag[];
    /**
     * Gets the comment.
     */
    getComment(): string | undefined;
    /**
     * Gets the JSDoc's text without the surrounding comment.
     */
    getInnerText(): string;
    /**
     * Sets the comment.
     * @param writerFunction - Write the text using the provided writer.
     */
    setComment(writerFunction: (writer: CodeBlockWriter) => void): this;
    /**
     * Sets the comment.
     * @param text - Text of the comment.
     */
    setComment(text: string): this;
    /**
     * Removes this JSDoc.
     */
    remove(): void;
}

/**
 * JS doc augments tag node.
 */
export declare class JSDocAugmentsTag extends JSDocTag<ts.JSDocAugmentsTag> {
}

/**
 * JS doc class tag node.
 */
export declare class JSDocClassTag extends JSDocTag<ts.JSDocClassTag> {
}

export declare const JSDocParameterTagBase: (new (...args: any[]) => JSDocPropertyLikeTag) & typeof JSDocTag;

/**
 * JS doc parameter tag node.
 */
export declare class JSDocParameterTag extends JSDocParameterTagBase<ts.JSDocParameterTag> {
}

export declare const JSDocPropertyTagBase: (new (...args: any[]) => JSDocPropertyLikeTag) & typeof JSDocTag;

/**
 * JS doc property tag node.
 */
export declare class JSDocPropertyTag extends JSDocPropertyTagBase<ts.JSDocPropertyTag> {
}

/**
 * JS doc return tag node.
 */
export declare class JSDocReturnTag extends JSDocTag<ts.JSDocReturnTag> {
}

/**
 * JS doc tag node.
 */
export declare class JSDocTag<NodeType extends ts.JSDocTag = ts.JSDocTag> extends Node<NodeType> {
    /**
     * Gets the at token.
     */
    getAtToken(): Node<ts.Node>;
    /**
     * Gets the tag name node.
     */
    getTagNameNode(): Identifier;
    /**
     * Gets the tag's comment.
     */
    getComment(): string | undefined;
}

/**
 * JS doc tag info.
 */
export declare class JSDocTagInfo {
    /** Gets the compiler JS doc tag info. */
    readonly compilerObject: ts.JSDocTagInfo;
    /**
     * Gets the name.
     */
    getName(): string;
    /**
     * Gets the text.
     */
    getText(): string | undefined;
}

/**
 * JS doc type def tag node.
 */
export declare class JSDocTypedefTag extends JSDocTag<ts.JSDocTypedefTag> {
}

/**
 * JS doc type tag node.
 */
export declare class JSDocTypeTag extends JSDocTag<ts.JSDocTypeTag> {
}

/**
 * JS doc unknown tag node.
 */
export declare class JSDocUnknownTag extends JSDocTag<ts.JSDocUnknownTag> {
}

export declare type JSDocPropertyLikeTagExtensionType = Node;

export interface JSDocPropertyLikeTag {
}

export declare function JSDocPropertyLikeTag<T extends Constructor<JSDocPropertyLikeTagExtensionType>>(Base: T): Constructor<JSDocPropertyLikeTag> & T;

export declare const EnumDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => NamespaceChildableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => AmbientableNode) & (new (...args: any[]) => ExportableNode) & (new (...args: any[]) => ModifierableNode) & (new (...args: any[]) => NamedNode) & typeof Statement;

export declare class EnumDeclaration extends EnumDeclarationBase<ts.EnumDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<EnumDeclarationStructure>): this;
    /**
     * Adds a member to the enum.
     * @param structure - Structure of the enum.
     */
    addMember(structure: EnumMemberStructure): EnumMember;
    /**
     * Adds members to the enum.
     * @param structures - Structures of the enums.
     */
    addMembers(structures: EnumMemberStructure[]): EnumMember[];
    /**
     * Inserts a member to the enum.
     * @param index - Index to insert at.
     * @param structure - Structure of the enum.
     */
    insertMember(index: number, structure: EnumMemberStructure): EnumMember;
    /**
     * Inserts members to an enum.
     * @param index - Index to insert at.
     * @param structures - Structures of the enums.
     */
    insertMembers(index: number, structures: EnumMemberStructure[]): EnumMember[];
    /**
     * Gets an enum member.
     * @param name - Name of the member.
     */
    getMember(name: string): EnumMember | undefined;
    /**
     * Gets an enum member.
     * @param findFunction - Function to use to find the member.
     */
    getMember(findFunction: (declaration: EnumMember) => boolean): EnumMember | undefined;
    /**
     * Gets an enum member or throws if not found.
     * @param name - Name of the member.
     */
    getMemberOrThrow(name: string): EnumMember;
    /**
     * Gets an enum member or throws if not found.
     * @param findFunction - Function to use to find the member.
     */
    getMemberOrThrow(findFunction: (declaration: EnumMember) => boolean): EnumMember;
    /**
     * Gets the enum's members.
     */
    getMembers(): EnumMember[];
    /**
     * Toggle if it's a const enum
     */
    setIsConstEnum(value: boolean): this;
    /**
     * Gets if it's a const enum.
     */
    isConstEnum(): boolean;
    /**
     * Gets the const enum keyword or undefined if not exists.
     */
    getConstKeyword(): Node<ts.Modifier> | undefined;
}

export declare const EnumMemberBase: (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => InitializerExpressionableNode) & (new (...args: any[]) => PropertyNamedNode) & typeof Node;

export declare class EnumMember extends EnumMemberBase<ts.EnumMember> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<EnumMemberStructure>): this;
    /**
     * Gets the constant value of the enum.
     */
    getValue(): string | number | undefined;
    /**
     * Sets the enum value.
     * @param value - Enum value.
     */
    setValue(value: string | number): this;
    /**
     * Removes this enum member.
     */
    remove(): void;
}

export declare const AsExpressionBase: (new (...args: any[]) => TypedNode) & (new (...args: any[]) => ExpressionedNode) & typeof Expression;

export declare class AsExpression extends AsExpressionBase<ts.AsExpression> {
}

export declare const AssignmentExpressionBase: typeof BinaryExpression;

export declare class AssignmentExpression<TOperator extends ts.AssignmentOperatorToken = ts.AssignmentOperatorToken, T extends ts.AssignmentExpression<TOperator> = ts.AssignmentExpression<TOperator>> extends AssignmentExpressionBase<T> {
    /**
     * Gets the operator token of the assignment expression.
     */
    getOperatorToken(): Node<TOperator>;
}

export declare const AwaitExpressionBase: (new (...args: any[]) => UnaryExpressionedNode) & typeof UnaryExpression;

export declare class AwaitExpression extends AwaitExpressionBase<ts.AwaitExpression> {
}

export declare const BinaryExpressionBase: typeof Expression;

export declare class BinaryExpression<T extends ts.BinaryExpression = ts.BinaryExpression> extends BinaryExpressionBase<T> {
    /**
     * Gets the left side of the binary expression.
     */
    getLeft(): Expression<ts.Expression>;
    /**
     * Gets the operator token of the binary expression.
     */
    getOperatorToken(): Node<ts.Token<ts.BinaryOperator>>;
    /**
     * Gets the right side of the binary expression.
     */
    getRight(): Expression<ts.Expression>;
}

export declare const CallExpressionBase: (new (...args: any[]) => TypeArgumentedNode) & (new (...args: any[]) => ArgumentedNode) & (new (...args: any[]) => LeftHandSideExpressionedNode) & typeof LeftHandSideExpression;

export declare class CallExpression<T extends ts.CallExpression = ts.CallExpression> extends CallExpressionBase<T> {
    /**
     * Gets the return type of the call expression.
     */
    getReturnType(): Type;
}

export declare const CommaListExpressionBase: typeof Expression;

export declare class CommaListExpression extends CommaListExpressionBase<ts.CommaListExpression> {
    /**
     * Gets the elements.
     */
    getElements(): Expression<ts.Expression>[];
}

export declare const ConditionalExpressionBase: typeof Expression;

export declare class ConditionalExpression extends ConditionalExpressionBase<ts.ConditionalExpression> {
    /**
     * Gets the condition of the conditional expression.
     */
    getCondition(): Expression<ts.Expression>;
    /**
     * Gets the question token of the conditional expression.
     */
    getQuestionToken(): Node<ts.Token<SyntaxKind.QuestionToken>>;
    /**
     * Gets the when true expression of the conditional expression.
     */
    getWhenTrue(): Expression<ts.Expression>;
    /**
     * Gets the colon token of the conditional expression.
     */
    getColonToken(): Node<ts.Token<SyntaxKind.ColonToken>>;
    /**
     * Gets the when false expression of the conditional expression.
     */
    getWhenFalse(): Expression<ts.Expression>;
}

export declare const DeleteExpressionBase: (new (...args: any[]) => UnaryExpressionedNode) & typeof UnaryExpression;

export declare class DeleteExpression extends DeleteExpressionBase<ts.DeleteExpression> {
}

export declare const ElementAccessExpressionBase: (new (...args: any[]) => LeftHandSideExpressionedNode) & typeof MemberExpression;

export declare class ElementAccessExpression<T extends ts.ElementAccessExpression = ts.ElementAccessExpression> extends ElementAccessExpressionBase<T> {
    /**
     * Gets this element access expression's argument expression or undefined if none exists.
     */
    getArgumentExpression(): Expression<ts.Expression> | undefined;
    /**
     * Gets this element access expression's argument expression or throws if none exists.
     */
    getArgumentExpressionOrThrow(): Expression<ts.Expression>;
}

export declare class Expression<T extends ts.Expression = ts.Expression> extends Node<T> {
    /**
     * Gets the contextual type of the expression.
     */
    getContextualType(): Type | undefined;
}

export declare const ImportExpressionBase: typeof PrimaryExpression;

export declare class ImportExpression extends ImportExpressionBase<ts.ImportExpression> {
}

export declare class LeftHandSideExpression<T extends ts.LeftHandSideExpression = ts.LeftHandSideExpression> extends UpdateExpression<T> {
}

export declare const LiteralExpressionBase: (new (...args: any[]) => LiteralLikeNode) & typeof PrimaryExpression;

export declare class LiteralExpression<T extends ts.LiteralExpression = ts.LiteralExpression> extends LiteralExpressionBase<T> {
}

export declare class MemberExpression<T extends ts.MemberExpression = ts.MemberExpression> extends LeftHandSideExpression<T> {
}

export declare const MetaPropertyBase: (new (...args: any[]) => NamedNode) & typeof PrimaryExpression;

export declare class MetaProperty extends MetaPropertyBase<ts.MetaProperty> {
    /**
     * Gets the keyword token.
     */
    getKeywordToken(): SyntaxKind;
}

export declare const NewExpressionBase: (new (...args: any[]) => TypeArgumentedNode) & (new (...args: any[]) => ArgumentedNode) & (new (...args: any[]) => LeftHandSideExpressionedNode) & typeof PrimaryExpression;

export declare class NewExpression extends NewExpressionBase<ts.NewExpression> {
}

export declare const NonNullExpressionBase: (new (...args: any[]) => ExpressionedNode) & typeof LeftHandSideExpression;

export declare class NonNullExpression extends NonNullExpressionBase<ts.NonNullExpression> {
}

export declare const OmittedExpressionBase: typeof Expression;

export declare class OmittedExpression extends OmittedExpressionBase<ts.OmittedExpression> {
}

export declare const ParenthesizedExpressionBase: (new (...args: any[]) => ExpressionedNode) & typeof Expression;

export declare class ParenthesizedExpression extends ParenthesizedExpressionBase<ts.ParenthesizedExpression> {
}

export declare const PartiallyEmittedExpressionBase: (new (...args: any[]) => ExpressionedNode) & typeof Expression;

export declare class PartiallyEmittedExpression extends PartiallyEmittedExpressionBase<ts.PartiallyEmittedExpression> {
}

export declare const PostfixUnaryExpressionBase: typeof UnaryExpression;

export declare class PostfixUnaryExpression extends PostfixUnaryExpressionBase<ts.PostfixUnaryExpression> {
    /**
     * Gets the operator token of the postfix unary expression.
     */
    getOperatorToken(): ts.PostfixUnaryOperator;
    /**
     * Gets the operand of the postfix unary expression.
     */
    getOperand(): LeftHandSideExpression<ts.LeftHandSideExpression>;
}

export declare const PrefixUnaryExpressionBase: typeof UnaryExpression;

export declare class PrefixUnaryExpression extends PrefixUnaryExpressionBase<ts.PrefixUnaryExpression> {
    /**
     * Gets the operator token of the prefix unary expression.
     */
    getOperatorToken(): ts.PrefixUnaryOperator;
    /**
     * Gets the operand of the prefix unary expression.
     */
    getOperand(): UnaryExpression<ts.UnaryExpression>;
}

export declare class PrimaryExpression<T extends ts.PrimaryExpression = ts.PrimaryExpression> extends MemberExpression<T> {
}

export declare const PropertyAccessExpressionBase: (new (...args: any[]) => NamedNode) & (new (...args: any[]) => LeftHandSideExpressionedNode) & typeof MemberExpression;

export declare class PropertyAccessExpression<T extends ts.PropertyAccessExpression = ts.PropertyAccessExpression> extends PropertyAccessExpressionBase<T> {
}

export declare const SpreadElementBase: (new (...args: any[]) => ExpressionedNode) & typeof Expression;

export declare class SpreadElement extends SpreadElementBase<ts.SpreadElement> {
}

export declare const SuperElementAccessExpressionBase: (new (...args: any[]) => SuperExpressionedNode) & typeof ElementAccessExpression;

export declare class SuperElementAccessExpression extends SuperElementAccessExpressionBase<ts.SuperElementAccessExpression> {
}

export declare const SuperExpressionBase: typeof PrimaryExpression;

export declare class SuperExpression extends SuperExpressionBase<ts.SuperExpression> {
}

export declare const SuperPropertyAccessExpressionBase: (new (...args: any[]) => SuperExpressionedNode) & typeof PropertyAccessExpression;

export declare class SuperPropertyAccessExpression extends SuperPropertyAccessExpressionBase<ts.SuperPropertyAccessExpression> {
}

export declare const ThisExpressionBase: typeof PrimaryExpression;

export declare class ThisExpression extends ThisExpressionBase<ts.ThisExpression> {
}

export declare const TypeAssertionBase: (new (...args: any[]) => TypedNode) & (new (...args: any[]) => UnaryExpressionedNode) & typeof UnaryExpression;

export declare class TypeAssertion extends TypeAssertionBase<ts.TypeAssertion> {
}

export declare const TypeOfExpressionBase: (new (...args: any[]) => UnaryExpressionedNode) & typeof UnaryExpression;

export declare class TypeOfExpression extends TypeOfExpressionBase<ts.TypeOfExpression> {
}

export declare class UnaryExpression<T extends ts.UnaryExpression = ts.UnaryExpression> extends Expression<T> {
}

export declare class UpdateExpression<T extends ts.UpdateExpression = ts.UpdateExpression> extends UnaryExpression<T> {
}

export declare const VoidExpressionBase: (new (...args: any[]) => UnaryExpressionedNode) & typeof UnaryExpression;

export declare class VoidExpression extends VoidExpressionBase<ts.VoidExpression> {
}

export declare const YieldExpressionBase: (new (...args: any[]) => GeneratorableNode) & typeof Expression;

export declare class YieldExpression extends YieldExpressionBase<ts.YieldExpression> {
    /**
     * Gets the expression or undefined of the yield expression.
     */
    getExpression(): Expression<ts.Expression> | undefined;
    /**
     * Gets the expression of the yield expression or throws if it does not exist.
     */
    getExpressionOrThrow(): Expression<ts.Expression>;
}

export declare const ArrayDestructuringAssignmentBase: typeof AssignmentExpression;

export declare class ArrayDestructuringAssignment extends ArrayDestructuringAssignmentBase<ts.EqualsToken, ts.ArrayDestructuringAssignment> {
    /**
     * Gets the left array literal expression of the array destructuring assignment.
     */
    getLeft(): ArrayLiteralExpression;
}

export declare class ArrayLiteralExpression extends PrimaryExpression<ts.ArrayLiteralExpression> {
    /**
     * Gets the array's elements.
     */
    getElements(): Expression[];
    /**
     * Adds an element to the array.
     * @param text - Text to add as an element.
     * @param options - Options.
     */
    addElement(text: string, options?: {
        useNewLines?: boolean;
    }): Expression<ts.Expression>;
    /**
     * Adds elements to the array.
     * @param texts - Texts to add as elements.
     * @param options - Options.
     */
    addElements(texts: string[], options?: {
        useNewLines?: boolean;
    }): Expression<ts.Expression>[];
    /**
     * Insert an element into the array.
     * @param index - Index to insert at.
     * @param text - Text to insert as an element.
     * @param options - Options.
     */
    insertElement(index: number, text: string, options?: {
        useNewLines?: boolean;
    }): Expression<ts.Expression>;
    /**
     * Insert elements into the array.
     * @param index - Index to insert at.
     * @param texts - Texts to insert as elements.
     * @param options - Options.
     */
    insertElements(index: number, texts: string[], options?: {
        useNewLines?: boolean;
    }): Expression[];
    /**
     * Insert elements into the array.
     * @param index - Index to insert at.
     * @param writerFunction - Write the text using the provided writer.
     * @param options - Options.
     */
    insertElements(index: number, writerFunction: (writer: CodeBlockWriter) => void, options?: {
        useNewLines?: boolean;
    }): Expression[];
    /**
     * Removes an element from the array.
     * @param index - Index to remove from.
     */
    removeElement(index: number): void;
    /**
     * Removes an element from the array.
     * @param element - Element to remove.
     */
    removeElement(element: Expression): void;
}

export declare type ExpressionedNodeExtensionType = Node<ts.Node & {
    expression: ts.Expression;
}>;

export interface ExpressionedNode {
    /**
     * Gets the expression.
     */
    getExpression(): Expression;
}

export declare function ExpressionedNode<T extends Constructor<ExpressionedNodeExtensionType>>(Base: T): Constructor<ExpressionedNode> & T;

export declare type ImportExpressionedNodeExtensionType = Node<ts.Node & {
    expression: ts.ImportExpression;
}>;

export interface ImportExpressionedNode {
    /**
     * Gets the expression.
     */
    getExpression(): ImportExpression;
}

export declare function ImportExpressionedNode<T extends Constructor<ImportExpressionedNodeExtensionType>>(Base: T): Constructor<ImportExpressionedNode> & T;

export declare type LeftHandSideExpressionedNodeExtensionType = Node<ts.Node & {
    expression: ts.LeftHandSideExpression;
}>;

export interface LeftHandSideExpressionedNode {
    /**
     * Gets the expression.
     */
    getExpression(): LeftHandSideExpression;
}

export declare function LeftHandSideExpressionedNode<T extends Constructor<LeftHandSideExpressionedNodeExtensionType>>(Base: T): Constructor<LeftHandSideExpressionedNode> & T;

export declare type SuperExpressionedNodeExtensionType = Node<ts.Node & {
    expression: ts.SuperExpression;
}>;

export interface SuperExpressionedNode {
    /**
     * Gets the expression.
     */
    getExpression(): SuperExpression;
}

export declare function SuperExpressionedNode<T extends Constructor<SuperExpressionedNodeExtensionType>>(Base: T): Constructor<SuperExpressionedNode> & T;

export declare type UnaryExpressionedNodeExtensionType = Node<ts.Node & {
    expression: ts.UnaryExpression;
}>;

export interface UnaryExpressionedNode {
    /**
     * Gets the expression.
     */
    getExpression(): UnaryExpression;
}

export declare function UnaryExpressionedNode<T extends Constructor<UnaryExpressionedNodeExtensionType>>(Base: T): Constructor<UnaryExpressionedNode> & T;

export declare const ObjectDestructuringAssignmentBase: typeof AssignmentExpression;

export declare class ObjectDestructuringAssignment extends ObjectDestructuringAssignmentBase<ts.EqualsToken, ts.ObjectDestructuringAssignment> {
    /**
     * Gets the left object literal expression of the object destructuring assignment.
     */
    getLeft(): ObjectLiteralExpression;
}

export declare const ObjectLiteralExpressionBase: typeof PrimaryExpression;

export declare class ObjectLiteralExpression extends ObjectLiteralExpressionBase<ts.ObjectLiteralExpression> {
    /**
     * Gets the first property by the provided name or throws.
     * @param name - Name of the property.
     */
    getPropertyOrThrow(name: string): ObjectLiteralElementLike;
    /**
     * Gets the first property that matches the provided find function or throws.
     * @param findFunction - Find function.
     */
    getPropertyOrThrow(findFunction: (property: ObjectLiteralElementLike) => boolean): ObjectLiteralElementLike;
    /**
     * Gets the first property by the provided name or returns undefined.
     * @param name - Name of the property.
     */
    getProperty(name: string): ObjectLiteralElementLike | undefined;
    /**
     * Gets the first property that matches the provided find function or returns undefined.
     * @param findFunction - Find function.
     */
    getProperty(findFunction: (property: ObjectLiteralElementLike) => boolean): ObjectLiteralElementLike | undefined;
    /**
     * Gets the properties.
     */
    getProperties(): ObjectLiteralElementLike[];
    /**
     * Adds a property assignment.
     * @param structure - Structure that represents the property assignment to add.
     */
    addPropertyAssignment(structure: PropertyAssignmentStructure): PropertyAssignment;
    /**
     * Adds property assignments.
     * @param structures - Structure that represents the property assignments to add.
     */
    addPropertyAssignments(structures: PropertyAssignmentStructure[]): PropertyAssignment[];
    /**
     * Inserts a property assignment at the specified index.
     * @param index - Index to insert.
     * @param structure - Structure that represents the property assignment to insert.
     */
    insertPropertyAssignment(index: number, structure: PropertyAssignmentStructure): PropertyAssignment;
    /**
     * Inserts property assignments at the specified index.
     * @param index - Index to insert.
     * @param structures - Structures that represent the property assignments to insert.
     */
    insertPropertyAssignments(index: number, structures: PropertyAssignmentStructure[]): PropertyAssignment[];
    /**
     * Adds a shorthand property assignment.
     * @param structure - Structure that represents the shorthand property assignment to add.
     */
    addShorthandPropertyAssignment(structure: ShorthandPropertyAssignmentStructure): ShorthandPropertyAssignment;
    /**
     * Adds shorthand property assignments.
     * @param structures - Structure that represents the shorthand property assignments to add.
     */
    addShorthandPropertyAssignments(structures: ShorthandPropertyAssignmentStructure[]): ShorthandPropertyAssignment[];
    /**
     * Inserts a shorthand property assignment at the specified index.
     * @param index - Index to insert.
     * @param structure - Structure that represents the shorthand property assignment to insert.
     */
    insertShorthandPropertyAssignment(index: number, structure: ShorthandPropertyAssignmentStructure): ShorthandPropertyAssignment;
    /**
     * Inserts shorthand property assignments at the specified index.
     * @param index - Index to insert.
     * @param structures - Structures that represent the shorthand property assignments to insert.
     */
    insertShorthandPropertyAssignments(index: number, structures: ShorthandPropertyAssignmentStructure[]): ShorthandPropertyAssignment[];
    /**
     * Adds a spread assignment.
     * @param structure - Structure that represents the spread assignment to add.
     */
    addSpreadAssignment(structure: SpreadAssignmentStructure): SpreadAssignment;
    /**
     * Adds spread assignments.
     * @param structures - Structure that represents the spread assignments to add.
     */
    addSpreadAssignments(structures: SpreadAssignmentStructure[]): SpreadAssignment[];
    /**
     * Inserts a spread assignment at the specified index.
     * @param index - Index to insert.
     * @param structure - Structure that represents the spread assignment to insert.
     */
    insertSpreadAssignment(index: number, structure: SpreadAssignmentStructure): SpreadAssignment;
    /**
     * Inserts spread assignments at the specified index.
     * @param index - Index to insert.
     * @param structures - Structures that represent the spread assignments to insert.
     */
    insertSpreadAssignments(index: number, structures: SpreadAssignmentStructure[]): SpreadAssignment[];
    /**
     * Adds a method.
     * @param structure - Structure that represents the method to add.
     */
    addMethod(structure: MethodDeclarationStructure): MethodDeclaration;
    /**
     * Adds methods.
     * @param structures - Structure that represents the methods to add.
     */
    addMethods(structures: MethodDeclarationStructure[]): MethodDeclaration[];
    /**
     * Inserts a method at the specified index.
     * @param index - Index to insert.
     * @param structure - Structure that represents the method to insert.
     */
    insertMethod(index: number, structure: MethodDeclarationStructure): MethodDeclaration;
    /**
     * Inserts methods at the specified index.
     * @param index - Index to insert.
     * @param structures - Structures that represent the methods to insert.
     */
    insertMethods(index: number, structures: MethodDeclarationStructure[]): MethodDeclaration[];
    /**
     * Adds a get accessor.
     * @param structure - Structure that represents the property assignment to add.
     */
    addGetAccessor(structure: GetAccessorDeclarationStructure): GetAccessorDeclaration;
    /**
     * Adds get accessors.
     * @param structures - Structure that represents the get accessors to add.
     */
    addGetAccessors(structures: GetAccessorDeclarationStructure[]): GetAccessorDeclaration[];
    /**
     * Inserts a get accessor at the specified index.
     * @param index - Index to insert.
     * @param structure - Structure that represents the get accessor to insert.
     */
    insertGetAccessor(index: number, structure: GetAccessorDeclarationStructure): GetAccessorDeclaration;
    /**
     * Inserts get accessors at the specified index.
     * @param index - Index to insert.
     * @param structures - Structures that represent the get accessors to insert.
     */
    insertGetAccessors(index: number, structures: GetAccessorDeclarationStructure[]): GetAccessorDeclaration[];
    /**
     * Adds a set accessor.
     * @param structure - Structure that represents the property assignment to add.
     */
    addSetAccessor(structure: SetAccessorDeclarationStructure): SetAccessorDeclaration;
    /**
     * Adds set accessors.
     * @param structures - Structure that represents the set accessors to add.
     */
    addSetAccessors(structures: SetAccessorDeclarationStructure[]): SetAccessorDeclaration[];
    /**
     * Inserts a set accessor at the specified index.
     * @param index - Index to insert.
     * @param structure - Structure that represents the set accessor to insert.
     */
    insertSetAccessor(index: number, structure: SetAccessorDeclarationStructure): SetAccessorDeclaration;
    /**
     * Inserts set accessors at the specified index.
     * @param index - Index to insert.
     * @param structures - Structures that represent the set accessors to insert.
     */
    insertSetAccessors(index: number, structures: SetAccessorDeclarationStructure[]): SetAccessorDeclaration[];
}

export declare const PropertyAssignmentBase: (new (...args: any[]) => InitializerGetExpressionableNode) & (new (...args: any[]) => QuestionTokenableNode) & (new (...args: any[]) => PropertyNamedNode) & typeof Node;

export declare class PropertyAssignment extends PropertyAssignmentBase<ts.PropertyAssignment> {
    /**
     * Removes the initailizer and returns the new shorthand property assignment.
     *
     * Note: The current node will no longer be valid because it's no longer a property assignment.
     */
    removeInitializer(): ShorthandPropertyAssignment;
    /**
     * Sets the initializer.
     * @param text - New text to set for the initializer.
     */
    setInitializer(text: string): this;
}

export declare const ShorthandPropertyAssignmentBase: (new (...args: any[]) => InitializerGetExpressionableNode) & (new (...args: any[]) => QuestionTokenableNode) & (new (...args: any[]) => NamedNode) & typeof Node;

export declare class ShorthandPropertyAssignment extends ShorthandPropertyAssignmentBase<ts.ShorthandPropertyAssignment> {
    /**
     * Gets if the shorthand property assignment has an object assignment initializer.
     */
    hasObjectAssignmentInitializer(): boolean;
    /**
     * Gets the object assignment initializer or throws if it doesn't exist.
     */
    getObjectAssignmentInitializerOrThrow(): Expression<ts.Expression>;
    /**
     * Gets the object assignment initializer if it exists.
     */
    getObjectAssignmentInitializer(): Expression<ts.Expression> | undefined;
    /**
     * Gets the equals token or throws if it doesn't exist.
     */
    getEqualsTokenOrThrow(): Node<ts.Token<SyntaxKind.EqualsToken>>;
    /**
     * Gets the equals token if it exists.
     */
    getEqualsToken(): Node<ts.Token<SyntaxKind.EqualsToken>> | undefined;
    /**
     * Remove the object assignment initializer.
     *
     * This is only useful to remove bad code.
     */
    removeObjectAssignmentInitializer(): this;
    /**
     * Sets the initializer.
     *
     * Note: The current node will no longer be valid because it's no longer a shorthand property assignment.
     * @param text - New text to set for the initializer.
     */
    setInitializer(text: string): PropertyAssignment;
}

export declare const SpreadAssignmentBase: (new (...args: any[]) => ExpressionedNode) & typeof Node;

export declare class SpreadAssignment extends SpreadAssignmentBase<ts.SpreadAssignment> {
}

export declare class ExportAssignment extends Statement<ts.ExportAssignment> {
    /**
     * Gets if this is an export equals assignemnt.
     *
     * If this is false, then it's `export default`.
     */
    isExportEquals(): boolean;
    /**
     * Gets the export assignment expression.
     */
    getExpression(): Expression;
}

export declare class ExportDeclaration extends Statement<ts.ExportDeclaration> {
    /**
     * Sets the import specifier.
     * @param text - Text to set as the import specifier.
     */
    setModuleSpecifier(text: string): this;
    /**
     * Gets the module specifier or undefined if it doesn't exist.
     */
    getModuleSpecifier(): string | undefined;
    /**
     * Gets the source file referenced in the module specifier or throws if it can't find it or it doesn't exist.
     */
    getModuleSpecifierSourceFileOrThrow(): SourceFile;
    /**
     * Gets the source file referenced in the module specifier.
     */
    getModuleSpecifierSourceFile(): SourceFile | undefined;
    /**
     * Gets if the module specifier exists
     */
    hasModuleSpecifier(): boolean;
    /**
     * Gets if this export declaration is a namespace export.
     */
    isNamespaceExport(): boolean;
    /**
     * Gets if the export declaration has named exports.
     */
    hasNamedExports(): boolean;
    /**
     * Add a named export.
     * @param structure - Structure that represents the named export.
     */
    addNamedExport(structure: ExportSpecifierStructure): ExportSpecifier;
    /**
     * Add named exports.
     * @param structures - Structures that represent the named exports.
     */
    addNamedExports(structures: ExportSpecifierStructure[]): ExportSpecifier[];
    /**
     * Insert a named export.
     * @param index - Index to insert at.
     * @param structure - Structure that represents the named export.
     */
    insertNamedExport(index: number, structure: ExportSpecifierStructure): ExportSpecifier;
    /**
     * Inserts named exports into the export declaration.
     * @param index - Index to insert at.
     * @param structures - Structures that represent the named exports.
     */
    insertNamedExports(index: number, structures: ExportSpecifierStructure[]): ExportSpecifier[];
    /**
     * Gets the named exports.
     */
    getNamedExports(): ExportSpecifier[];
    /**
     * Changes the export declaration to namespace export. Removes all the named exports.
     */
    toNamespaceExport(): this;
}

export declare class ExportSpecifier extends Node<ts.ExportSpecifier> {
    /**
     * Sets the name of what's being exported.
     */
    setName(name: string): this;
    /**
     * Renames the name of what's being exported.
     */
    renameName(name: string): this;
    /**
     * Gets the name node of what's being exported.
     */
    getNameNode(): Identifier;
    /**
     * Sets the alias for the name being exported.
     * @param alias - Alias to set.
     */
    setAlias(alias: string): this;
    /**
     * Gets the alias identifier, if it exists.
     */
    getAliasIdentifier(): Identifier | undefined;
    /**
     * Gets the export declaration associated with this export specifier.
     */
    getExportDeclaration(): ExportDeclaration;
    /**
     * Gets the local target symbol of the export specifier or throws if it doesn't exist.
     */
    getLocalTargetSymbolOrThrow(): Symbol;
    /**
     * Gets the local target symbol of the export specifier or undefined if it doesn't exist.
     */
    getLocalTargetSymbol(): Symbol | undefined;
    /**
     * Gets all the declarations referenced by the export specifier.
     */
    getLocalTargetDeclarations(): Node[];
    /**
     * Removes the export specifier.
     */
    remove(): void;
}

export declare class ExternalModuleReference extends Node<ts.ExternalModuleReference> {
    /**
     * Gets the expression or undefined of the yield expression.
     */
    getExpression(): Expression<ts.Expression> | undefined;
    /**
     * Gets the expression of the yield expression or throws if it does not exist.
     */
    getExpressionOrThrow(): Expression<ts.Expression>;
}
/**
 * Result of refreshing a source file from the file system.
 */
export declare enum FileSystemRefreshResult {
    /** The source file did not change. */
    NoChange = 0,
    /** The source file was updated from the file system. */
    Updated = 1,
    /** The source file was deleted. */
    Deleted = 2,
}

export declare class ImportDeclaration extends Statement<ts.ImportDeclaration> {
    /**
     * Sets the import specifier.
     * @param text - Text to set as the import specifier.
     */
    setModuleSpecifier(text: string): this;
    /**
     * Gets the module specifier.
     */
    getModuleSpecifier(): string;
    /**
     * Gets the source file referenced in the module specifier or throws if it can't find it.
     */
    getModuleSpecifierSourceFileOrThrow(): SourceFile;
    /**
     * Gets the source file referenced in the module specifier or returns undefined if it can't find it.
     */
    getModuleSpecifierSourceFile(): SourceFile | undefined;
    /**
     * Sets the default import.
     * @param text - Text to set as the default import.
     */
    setDefaultImport(text: string): this;
    /**
     * Gets the default import, if it exists.
     */
    getDefaultImport(): Identifier | undefined;
    /**
     * Sets the namespace import.
     * @param text - Text to set as the namespace import.
     * @throws - InvalidOperationError if a named import exists.
     */
    setNamespaceImport(text: string): this;
    /**
     * Gets the namespace import, if it exists.
     */
    getNamespaceImport(): Identifier | undefined;
    /**
     * Add a named import.
     * @param structure - Structure that represents the named import.
     */
    addNamedImport(structure: ImportSpecifierStructure): ImportSpecifier;
    /**
     * Add named imports.
     * @param structures - Structures that represent the named imports.
     */
    addNamedImports(structures: ImportSpecifierStructure[]): ImportSpecifier[];
    /**
     * Insert a named import.
     * @param index - Index to insert at.
     * @param structure - Structure that represents the named import.
     */
    insertNamedImport(index: number, structure: ImportSpecifierStructure): ImportSpecifier;
    /**
     * Inserts named imports into the import declaration.
     * @param index - Index to insert at.
     * @param structures - Structures that represent the named imports.
     */
    insertNamedImports(index: number, structures: ImportSpecifierStructure[]): ImportSpecifier[];
    /**
     * Gets the named imports.
     */
    getNamedImports(): ImportSpecifier[];
    /**
     * Removes all the named imports.
     */
    removeNamedImports(): this;
    private getImportClause();
}

export declare const ImportEqualsDeclarationBase: (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => NamedNode) & typeof Statement;

export declare class ImportEqualsDeclaration extends ImportEqualsDeclarationBase<ts.ImportEqualsDeclaration> {
    /**
     * Gets the module reference of the import equals declaration.
     */
    getModuleReference(): ModuleReference;
}

export declare class ImportSpecifier extends Node<ts.ImportSpecifier> {
    /**
     * Sets the identifier being imported.
     * @param name - Name being imported.
     */
    setName(name: string): this;
    /**
     * Renames the identifier being imported.
     * @param name - New name.
     */
    renameName(name: string): this;
    /**
     * Gets the name of the import specifier.
     */
    getName(): string;
    /**
     * Gets the name node of what's being imported.
     */
    getNameNode(): Identifier;
    /**
     * Sets the alias for the name being imported.
     * @param alias - Alias to set.
     */
    setAlias(alias: string): this;
    /**
     * Gets the alias identifier, if it exists.
     */
    getAliasIdentifier(): Identifier | undefined;
    /**
     * Gets the import declaration associated with this import specifier.
     */
    getImportDeclaration(): ImportDeclaration;
    /**
     * Remove the import specifier.
     */
    remove(): void;
}

export declare const SourceFileBase: Constructor<StatementedNode> & Constructor<TextInsertableNode> & typeof Node;

export declare class SourceFile extends SourceFileBase<ts.SourceFile> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<SourceFileStructure>): this;
    /**
     * Gets the file path.
     */
    getFilePath(): string;
    /**
     * Gets the file path's base name.
     */
    getBaseName(): string;
    /**
     * Gets the directory that the source file is contained in.
     */
    getDirectory(): Directory;
    /**
     * Gets the directory path that the source file is contained in.
     */
    getDirectoryPath(): string;
    /**
     * Gets the line number of the provided position.
     * @param pos - Position
     */
    getLineNumberFromPos(pos: number): number;
    /**
     * Copy this source file to a new file.
     * @param filePath - A new file path. Can be relative to the original file or an absolute path.
     * @param options - Options for copying.
     */
    copy(filePath: string, options?: {
        overwrite?: boolean;
    }): SourceFile;
    /**
     * Asynchronously deletes the file from the file system.
     */
    delete(): Promise<void>;
    /**
     * Synchronously deletes the file from the file system.
     */
    deleteSync(): void;
    /**
     * Asynchronously saves this file with any changes.
     */
    save(): Promise<void>;
    /**
     * Synchronously saves this file with any changes.
     */
    saveSync(): void;
    /**
     * Gets any referenced files.
     */
    getReferencedFiles(): SourceFile[];
    /**
     * Gets the source files for any type reference directives.
     */
    getTypeReferenceDirectives(): SourceFile[];
    /**
     * Gets the source file language variant.
     */
    getLanguageVariant(): LanguageVariant;
    /**
     * Gets if this is a declaration file.
     */
    isDeclarationFile(): boolean;
    /**
     * Gets if this source file has been saved or if the latest changes have been saved.
     */
    isSaved(): boolean;
    /**
     * Add an import.
     * @param structure - Structure that represents the import.
     */
    addImportDeclaration(structure: ImportDeclarationStructure): ImportDeclaration;
    /**
     * Add imports.
     * @param structures - Structures that represent the imports.
     */
    addImportDeclarations(structures: ImportDeclarationStructure[]): ImportDeclaration[];
    /**
     * Insert an import.
     * @param index - Index to insert at.
     * @param structure - Structure that represents the import.
     */
    insertImportDeclaration(index: number, structure: ImportDeclarationStructure): ImportDeclaration;
    /**
     * Insert imports into a file.
     * @param index - Index to insert at.
     * @param structures - Structures that represent the imports to insert.
     */
    insertImportDeclarations(index: number, structures: ImportDeclarationStructure[]): ImportDeclaration[];
    /**
     * Gets the first import declaration that matches a condition, or undefined if it doesn't exist.
     * @param condition - Condition to get the import by.
     */
    getImportDeclaration(condition: (importDeclaration: ImportDeclaration) => boolean): ImportDeclaration | undefined;
    /**
     * Gets the first import declaration that matches a condition, or throws if it doesn't exist.
     * @param condition - Condition to get the import by.
     */
    getImportDeclarationOrThrow(condition: (importDeclaration: ImportDeclaration) => boolean): ImportDeclaration;
    /**
     * Get the file's import declarations.
     */
    getImportDeclarations(): ImportDeclaration[];
    /**
     * Add export declarations.
     * @param structure - Structure that represents the export.
     */
    addExportDeclaration(structure: ExportDeclarationStructure): ExportDeclaration;
    /**
     * Add export declarations.
     * @param structures - Structures that represent the exports.
     */
    addExportDeclarations(structures: ExportDeclarationStructure[]): ExportDeclaration[];
    /**
     * Insert an export declaration.
     * @param index - Index to insert at.
     * @param structure - Structure that represents the export.
     */
    insertExportDeclaration(index: number, structure: ExportDeclarationStructure): ExportDeclaration;
    /**
     * Insert export declarations into a file.
     * @param index - Index to insert at.
     * @param structures - Structures that represent the exports to insert.
     */
    insertExportDeclarations(index: number, structures: ExportDeclarationStructure[]): ExportDeclaration[];
    /**
     * Gets the first export declaration that matches a condition, or undefined if it doesn't exist.
     * @param condition - Condition to get the export declaration by.
     */
    getExportDeclaration(condition: (exportDeclaration: ExportDeclaration) => boolean): ExportDeclaration | undefined;
    /**
     * Gets the first export declaration that matches a condition, or throws if it doesn't exist.
     * @param condition - Condition to get the export declaration by.
     */
    getExportDeclarationOrThrow(condition: (exportDeclaration: ExportDeclaration) => boolean): ExportDeclaration;
    /**
     * Get the file's export declarations.
     */
    getExportDeclarations(): ExportDeclaration[];
    /**
     * Gets the export symbols of the source file.
     */
    getExportSymbols(): Symbol[];
    /**
     * Gets all the declarations exported from the file.
     */
    getExportedDeclarations(): Node[];
    /**
     * Add export assignments.
     * @param structure - Structure that represents the export.
     */
    addExportAssignment(structure: ExportAssignmentStructure): ExportAssignment;
    /**
     * Add export assignments.
     * @param structures - Structures that represent the exports.
     */
    addExportAssignments(structures: ExportAssignmentStructure[]): ExportAssignment[];
    /**
     * Insert an export assignment.
     * @param index - Index to insert at.
     * @param structure - Structure that represents the export.
     */
    insertExportAssignment(index: number, structure: ExportAssignmentStructure): ExportAssignment;
    /**
     * Insert export assignments into a file.
     * @param index - Index to insert at.
     * @param structures - Structures that represent the exports to insert.
     */
    insertExportAssignments(index: number, structures: ExportAssignmentStructure[]): ExportAssignment[];
    /**
     * Gets the first export assignment that matches a condition, or undefined if it doesn't exist.
     * @param condition - Condition to get the export assignment by.
     */
    getExportAssignment(condition: (exportAssignment: ExportAssignment) => boolean): ExportAssignment | undefined;
    /**
     * Gets the first export assignment that matches a condition, or throws if it doesn't exist.
     * @param condition - Condition to get the export assignment by.
     */
    getExportAssignmentOrThrow(condition: (exportAssignment: ExportAssignment) => boolean): ExportAssignment;
    /**
     * Get the file's export assignments.
     */
    getExportAssignments(): ExportAssignment[];
    /**
     * Gets the default export symbol of the file.
     */
    getDefaultExportSymbol(): Symbol | undefined;
    /**
     * Gets the default export symbol of the file or throws if it doesn't exist.
     */
    getDefaultExportSymbolOrThrow(): Symbol;
    /**
     * Gets the syntactic, semantic, and declaration diagnostics.
     */
    getDiagnostics(): Diagnostic[];
    /**
     * Gets the pre-emit diagnostics.
     */
    getPreEmitDiagnostics(): Diagnostic[];
    /**
     * Removes any "export default";
     */
    removeDefaultExport(defaultExportSymbol?: Symbol | undefined): this;
    /**
     * Deindents the line at the specified position.
     * @param pos - Position.
     * @param times - Times to unindent. Specify a negative value to indent.
     */
    unindent(pos: number, times?: number): this;
    /**
     * Deindents the lines within the specified range.
     * @param positionRange - Position range.
     * @param times - Times to unindent. Specify a negative value to indent.
     */
    unindent(positionRange: [number, number], times?: number): this;
    /**
     * Indents the line at the specified position.
     * @param pos - Position.
     * @param times - Times to indent. Specify a negative value to unindent.
     */
    indent(pos: number, times?: number): this;
    /**
     * Indents the lines within the specified range.
     * @param positionRange - Position range.
     * @param times - Times to indent. Specify a negative value to unindent.
     */
    indent(positionRange: [number, number], times?: number): this;
    /**
     * Emits the source file.
     */
    emit(options?: {
        emitOnlyDtsFiles?: boolean;
    }): EmitResult;
    /**
     * Gets the emit output of this source file.
     * @param options - Emit options.
     */
    getEmitOutput(options?: {
        emitOnlyDtsFiles?: boolean;
    }): EmitOutput;
    /**
     * Formats the source file text using the internal TypeScript formatting API.
     * @param settings - Format code settings.
     */
    formatText(settings?: FormatCodeSettings): void;
    /**
     * Refresh the source file from the file system.
     *
     * WARNING: When updating from the file system, this will "forget" any previously navigated nodes.
     * @returns What action ended up taking place.
     */
    refreshFromFileSystem(): Promise<FileSystemRefreshResult>;
    /**
     * Synchronously refreshes the source file from the file system.
     *
     * WARNING: When updating from the file system, this will "forget" any previously navigated nodes.
     * @returns What action ended up taking place.
     */
    refreshFromFileSystemSync(): FileSystemRefreshResult;
    /**
     * Gets the relative path to another source file.
     * @param sourceFile - Source file.
     */
    getRelativePathToSourceFile(sourceFile: SourceFile): string;
    /**
     * Gets the relative path to the specified source file as a module specifier.
     * @param sourceFile - Source file.
     */
    getRelativePathToSourceFileAsModuleSpecifier(sourceFile: SourceFile): string;
    private _refreshFromFileSystemInternal(fileReadResult);
}

export declare const ArrowFunctionBase: (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => BodiedNode) & (new (...args: any[]) => AsyncableNode) & (new (...args: any[]) => StatementedNode) & (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => SignaturedDeclaration) & (new (...args: any[]) => ModifierableNode) & typeof Expression;

export declare class ArrowFunction extends ArrowFunctionBase<ts.ArrowFunction> {
    /**
     * Gets the equals greater than token of the arrow function.
     */
    getEqualsGreaterThan(): Node<ts.Token<SyntaxKind.EqualsGreaterThanToken>>;
}

export declare const FunctionDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => UnwrappableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => OverloadableNode) & (new (...args: any[]) => BodyableNode) & (new (...args: any[]) => AsyncableNode) & (new (...args: any[]) => GeneratorableNode) & (new (...args: any[]) => FunctionLikeDeclaration) & (new (...args: any[]) => StatementedNode) & (new (...args: any[]) => AmbientableNode) & (new (...args: any[]) => NamespaceChildableNode) & (new (...args: any[]) => ExportableNode) & (new (...args: any[]) => ModifierableNode) & (new (...args: any[]) => NamedNode) & typeof Node;

export declare class FunctionDeclaration extends FunctionDeclarationBase<ts.FunctionDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<FunctionDeclarationStructure>): this;
    /**
     * Adds a function overload.
     * @param structure - Structure of the overload.
     */
    addOverload(structure: FunctionDeclarationOverloadStructure): FunctionDeclaration;
    /**
     * Adds function overloads.
     * @param structures - Structures of the overloads.
     */
    addOverloads(structures: FunctionDeclarationOverloadStructure[]): FunctionDeclaration[];
    /**
     * Inserts a function overload.
     * @param index - Index to insert.
     * @param structure - Structure of the overload.
     */
    insertOverload(index: number, structure: FunctionDeclarationOverloadStructure): FunctionDeclaration;
    /**
     * Inserts function overloads.
     * @param index - Index to insert.
     * @param structure - Structures of the overloads.
     */
    insertOverloads(index: number, structures: FunctionDeclarationOverloadStructure[]): FunctionDeclaration[];
    /**
     * Removes this function declaration.
     */
    remove(): void;
}

export declare const FunctionExpressionBase: (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => BodiedNode) & (new (...args: any[]) => AsyncableNode) & (new (...args: any[]) => GeneratorableNode) & (new (...args: any[]) => StatementedNode) & (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => SignaturedDeclaration) & (new (...args: any[]) => ModifierableNode) & (new (...args: any[]) => NameableNode) & typeof PrimaryExpression;

export declare class FunctionExpression extends FunctionExpressionBase<ts.FunctionExpression> {
}

export declare type FunctionLikeDeclarationExtensionType = Node<ts.FunctionLikeDeclaration>;

export interface FunctionLikeDeclaration extends JSDocableNode, TypeParameteredNode, SignaturedDeclaration, StatementedNode, ModifierableNode {
}

export declare function FunctionLikeDeclaration<T extends Constructor<FunctionLikeDeclarationExtensionType>>(Base: T): Constructor<FunctionLikeDeclaration> & T;

export declare type OverloadableNodeExtensionType = Node & BodyableNode;

/**
 * Node that supports overloads.
 */
export interface OverloadableNode {
    /**
     * Gets all the overloads associated with this node.
     */
    getOverloads(): this[];
    /**
     * Gets the implementation or undefined if it doesn't exist.
     */
    getImplementation(): this | undefined;
    /**
     * Gets the implementation or throws if it doesn't exist.
     */
    getImplementationOrThrow(): this;
    /**
     * Gets if this is an overload.
     */
    isOverload(): boolean;
    /**
     * Gets if this is the implementation.
     */
    isImplementation(): boolean;
}

export declare function OverloadableNode<T extends Constructor<OverloadableNodeExtensionType>>(Base: T): Constructor<OverloadableNode> & T;

export declare const ParameterDeclarationBase: (new (...args: any[]) => QuestionTokenableNode) & (new (...args: any[]) => DecoratableNode) & (new (...args: any[]) => ScopeableNode) & (new (...args: any[]) => ReadonlyableNode) & (new (...args: any[]) => ModifierableNode) & (new (...args: any[]) => TypedNode) & (new (...args: any[]) => InitializerExpressionableNode) & (new (...args: any[]) => DeclarationNamedNode) & typeof Node;

export declare class ParameterDeclaration extends ParameterDeclarationBase<ts.ParameterDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<ParameterDeclarationStructure>): this;
    /**
     * Gets the dot dot dot token (...) for a rest parameter.
     */
    getDotDotDotToken(): Node<ts.Token<SyntaxKind.DotDotDotToken>> | undefined;
    /**
     * Gets if it's a rest parameter.
     */
    isRestParameter(): boolean;
    /**
     * Gets if this is a parameter property.
     */
    isParameterProperty(): boolean;
    /**
     * Sets if it's a rest parameter.
     * @param value - Sets if it's a rest parameter or not.
     */
    setIsRestParameter(value: boolean): this;
    /**
     * Gets if it's optional.
     */
    isOptional(): boolean;
    /**
     * Remove this parameter.
     */
    remove(): void;
}

export declare class HeritageClause extends Node<ts.HeritageClause> {
    /**
     * Gets all the type nodes for the heritage clause.
     */
    getTypeNodes(): ExpressionWithTypeArguments[];
    /**
     * Gets the heritage clause token.
     */
    getToken(): SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword;
    /**
     * Remove the expression from the heritage clause.
     * @param index - Index of the expression to remove.
     */
    removeExpression(index: number): this;
    /**
     * Removes the expression from the heritage clause.
     * @param expressionNode - Expression to remove.
     */
    removeExpression(expressionNode: ExpressionWithTypeArguments): this;
}

export declare const CallSignatureDeclarationBase: (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => SignaturedDeclaration) & typeof Node;

export declare class CallSignatureDeclaration extends CallSignatureDeclarationBase<ts.CallSignatureDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<CallSignatureDeclarationStructure>): this;
    /**
     * Removes this call signature.
     */
    remove(): void;
}

export declare const ConstructSignatureDeclarationBase: (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => SignaturedDeclaration) & typeof Node;

export declare class ConstructSignatureDeclaration extends ConstructSignatureDeclarationBase<ts.ConstructSignatureDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<ConstructSignatureDeclarationStructure>): this;
    /**
     * Removes this construct signature.
     */
    remove(): void;
}

export declare const IndexSignatureDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => ReadonlyableNode) & (new (...args: any[]) => ModifierableNode) & typeof Node;

export declare class IndexSignatureDeclaration extends IndexSignatureDeclarationBase<ts.IndexSignatureDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<IndexSignatureDeclarationStructure>): this;
    /**
     * Gets the key name.
     */
    getKeyName(): string;
    /**
     * Sets the key name.
     * @param name - New name.
     */
    setKeyName(name: string): void;
    /**
     * Gets the key name node.
     */
    getKeyNameNode(): Identifier;
    /**
     * Gets the key type.
     */
    getKeyType(): Type;
    /**
     * Sets the key type.
     * @param type - Type.
     */
    setKeyType(type: string): void;
    /**
     * Gets the key type node.
     */
    getKeyTypeNode(): TypeNode<ts.TypeNode>;
    /**
     * Gets the return type.
     */
    getReturnType(): Type<ts.Type>;
    /**
     * Gets the return type node.
     */
    getReturnTypeNode(): TypeNode<ts.TypeNode>;
    /**
     * Sets the return type.
     * @param text
     */
    setReturnType(text: string): this;
    /**
     * Removes this index signature.
     */
    remove(): void;
}

export declare type InterfaceMemberTypes = PropertySignature | MethodSignature | ConstructSignatureDeclaration | CallSignatureDeclaration | IndexSignatureDeclaration;

export declare const InterfaceDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => ExtendsClauseableNode) & (new (...args: any[]) => HeritageClauseableNode) & (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => AmbientableNode) & (new (...args: any[]) => NamespaceChildableNode) & (new (...args: any[]) => ExportableNode) & (new (...args: any[]) => ModifierableNode) & (new (...args: any[]) => NamedNode) & typeof Statement;

export declare class InterfaceDeclaration extends InterfaceDeclarationBase<ts.InterfaceDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<InterfaceDeclarationStructure>): this;
    /**
     * Gets the base types.
     */
    getBaseTypes(): Type[];
    /**
     * Gets the base declarations.
     */
    getBaseDeclarations(): (TypeAliasDeclaration | InterfaceDeclaration | ClassDeclaration)[];
    /**
     * Add construct signature.
     * @param structure - Structure representing the construct signature.
     */
    addConstructSignature(structure: ConstructSignatureDeclarationStructure): ConstructSignatureDeclaration;
    /**
     * Add construct signatures.
     * @param structures - Structures representing the construct signatures.
     */
    addConstructSignatures(structures: ConstructSignatureDeclarationStructure[]): ConstructSignatureDeclaration[];
    /**
     * Insert construct signature.
     * @param index - Index to insert at.
     * @param structure - Structure representing the construct signature.
     */
    insertConstructSignature(index: number, structure: ConstructSignatureDeclarationStructure): ConstructSignatureDeclaration;
    /**
     * Insert properties.
     * @param index - Index to insert at.
     * @param structures - Structures representing the construct signatures.
     */
    insertConstructSignatures(index: number, structures: ConstructSignatureDeclarationStructure[]): ConstructSignatureDeclaration[];
    /**
     * Gets the first construct signature by a find function.
     * @param findFunction - Function to find the construct signature by.
     */
    getConstructSignature(findFunction: (member: ConstructSignatureDeclaration) => boolean): ConstructSignatureDeclaration | undefined;
    /**
     * Gets the first construct signature by a find function or throws if not found.
     * @param findFunction - Function to find the construct signature by.
     */
    getConstructSignatureOrThrow(findFunction: (member: ConstructSignatureDeclaration) => boolean): ConstructSignatureDeclaration;
    /**
     * Gets the interface construct signatures.
     */
    getConstructSignatures(): ConstructSignatureDeclaration[];
    /**
     * Add call signature.
     * @param structure - Structure representing the call signature.
     */
    addCallSignature(structure: CallSignatureDeclarationStructure): CallSignatureDeclaration;
    /**
     * Add call signatures.
     * @param structures - Structures representing the call signatures.
     */
    addCallSignatures(structures: CallSignatureDeclarationStructure[]): CallSignatureDeclaration[];
    /**
     * Insert call signature.
     * @param index - Index to insert at.
     * @param structure - Structure representing the call signature.
     */
    insertCallSignature(index: number, structure: CallSignatureDeclarationStructure): CallSignatureDeclaration;
    /**
     * Insert properties.
     * @param index - Index to insert at.
     * @param structures - Structures representing the call signatures.
     */
    insertCallSignatures(index: number, structures: CallSignatureDeclarationStructure[]): CallSignatureDeclaration[];
    /**
     * Gets the first call signature by a find function.
     * @param findFunction - Function to find the call signature by.
     */
    getCallSignature(findFunction: (member: CallSignatureDeclaration) => boolean): CallSignatureDeclaration | undefined;
    /**
     * Gets the first call signature by a find function or throws if not found.
     * @param findFunction - Function to find the call signature by.
     */
    getCallSignatureOrThrow(findFunction: (member: CallSignatureDeclaration) => boolean): CallSignatureDeclaration;
    /**
     * Gets the interface call signatures.
     */
    getCallSignatures(): CallSignatureDeclaration[];
    /**
     * Add index signature.
     * @param structure - Structure representing the index signature.
     */
    addIndexSignature(structure: IndexSignatureDeclarationStructure): IndexSignatureDeclaration;
    /**
     * Add index signatures.
     * @param structures - Structures representing the index signatures.
     */
    addIndexSignatures(structures: IndexSignatureDeclarationStructure[]): IndexSignatureDeclaration[];
    /**
     * Insert index signature.
     * @param index - Index to insert at.
     * @param structure - Structure representing the index signature.
     */
    insertIndexSignature(index: number, structure: IndexSignatureDeclarationStructure): IndexSignatureDeclaration;
    /**
     * Insert properties.
     * @param index - Index to insert at.
     * @param structures - Structures representing the index signatures.
     */
    insertIndexSignatures(index: number, structures: IndexSignatureDeclarationStructure[]): IndexSignatureDeclaration[];
    /**
     * Gets the first index signature by a find function.
     * @param findFunction - Function to find the index signature by.
     */
    getIndexSignature(findFunction: (member: IndexSignatureDeclaration) => boolean): IndexSignatureDeclaration | undefined;
    /**
     * Gets the first index signature by a find function or throws if not found.
     * @param findFunction - Function to find the index signature by.
     */
    getIndexSignatureOrThrow(findFunction: (member: IndexSignatureDeclaration) => boolean): IndexSignatureDeclaration;
    /**
     * Gets the interface index signatures.
     */
    getIndexSignatures(): IndexSignatureDeclaration[];
    /**
     * Add method.
     * @param structure - Structure representing the method.
     */
    addMethod(structure: MethodSignatureStructure): MethodSignature;
    /**
     * Add methods.
     * @param structures - Structures representing the methods.
     */
    addMethods(structures: MethodSignatureStructure[]): MethodSignature[];
    /**
     * Insert method.
     * @param index - Index to insert at.
     * @param structure - Structure representing the method.
     */
    insertMethod(index: number, structure: MethodSignatureStructure): MethodSignature;
    /**
     * Insert methods.
     * @param index - Index to insert at.
     * @param structures - Structures representing the methods.
     */
    insertMethods(index: number, structures: MethodSignatureStructure[]): MethodSignature[];
    /**
     * Gets the first method by name.
     * @param name - Name.
     */
    getMethod(name: string): MethodSignature | undefined;
    /**
     * Gets the first method by a find function.
     * @param findFunction - Function to find the method by.
     */
    getMethod(findFunction: (member: MethodSignature) => boolean): MethodSignature | undefined;
    /**
     * Gets the first method by name or throws if not found.
     * @param name - Name.
     */
    getMethodOrThrow(name: string): MethodSignature;
    /**
     * Gets the first method by a find function or throws if not found.
     * @param findFunction - Function to find the method by.
     */
    getMethodOrThrow(findFunction: (member: MethodSignature) => boolean): MethodSignature;
    /**
     * Gets the interface method signatures.
     */
    getMethods(): MethodSignature[];
    /**
     * Add property.
     * @param structure - Structure representing the property.
     */
    addProperty(structure: PropertySignatureStructure): PropertySignature;
    /**
     * Add properties.
     * @param structures - Structures representing the properties.
     */
    addProperties(structures: PropertySignatureStructure[]): PropertySignature[];
    /**
     * Insert property.
     * @param index - Index to insert at.
     * @param structure - Structure representing the property.
     */
    insertProperty(index: number, structure: PropertySignatureStructure): PropertySignature;
    /**
     * Insert properties.
     * @param index - Index to insert at.
     * @param structures - Structures representing the properties.
     */
    insertProperties(index: number, structures: PropertySignatureStructure[]): PropertySignature[];
    /**
     * Gets the first property by name.
     * @param name - Name.
     */
    getProperty(name: string): PropertySignature | undefined;
    /**
     * Gets the first property by a find function.
     * @param findFunction - Function to find the property by.
     */
    getProperty(findFunction: (member: PropertySignature) => boolean): PropertySignature | undefined;
    /**
     * Gets the first property by name or throws if not found.
     * @param name - Name.
     */
    getPropertyOrThrow(name: string): PropertySignature;
    /**
     * Gets the first property by a find function or throws if not found.
     * @param findFunction - Function to find the property by.
     */
    getPropertyOrThrow(findFunction: (member: PropertySignature) => boolean): PropertySignature;
    /**
     * Gets the interface property signatures.
     */
    getProperties(): PropertySignature[];
    /**
     * Gets all members.
     */
    getMembers(): InterfaceMemberTypes[];
    /**
     * Gets all the implementations of the interface.
     *
     * This is similar to "go to implementation."
     */
    getImplementations(): ImplementationLocation[];
}

export declare const MethodSignatureBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => QuestionTokenableNode) & (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => SignaturedDeclaration) & (new (...args: any[]) => PropertyNamedNode) & typeof Node;

export declare class MethodSignature extends MethodSignatureBase<ts.MethodSignature> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<MethodSignatureStructure>): this;
    /**
     * Removes this method signature.
     */
    remove(): void;
}

export declare const PropertySignatureBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => ReadonlyableNode) & (new (...args: any[]) => QuestionTokenableNode) & (new (...args: any[]) => InitializerExpressionableNode) & (new (...args: any[]) => TypedNode) & (new (...args: any[]) => PropertyNamedNode) & (new (...args: any[]) => ModifierableNode) & typeof Node;

export declare class PropertySignature extends PropertySignatureBase<ts.PropertySignature> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<PropertySignatureStructure>): this;
    /**
     * Removes this property signature.
     */
    remove(): void;
}

declare const JsxAttribute_base: (new (...args: any[]) => NamedNode) & typeof Node;

export declare class JsxAttribute extends JsxAttribute_base<ts.JsxAttribute> {
    /**
     * Gets the JSX attribute's initializer or throws if it doesn't exist.
     */
    getInitializerOrThrow(): StringLiteral | JsxExpression;
    /**
     * Gets the JSX attribute's initializer or returns undefined if it doesn't exist.
     */
    getInitializer(): StringLiteral | JsxExpression | undefined;
}

export declare class JsxClosingElement extends Node<ts.JsxClosingElement> {
    /**
     * Gets the tag name of the JSX closing element.
     */
    getTagName(): JsxTagNameExpression;
}

export declare class JsxClosingFragment extends Expression<ts.JsxClosingFragment> {
}

export declare class JsxElement extends PrimaryExpression<ts.JsxElement> {
    /**
     * Gets the children of the JSX element.
     */
    getJsxChildren(): JsxChild[];
    /**
     * Gets the opening element.
     */
    getOpeningElement(): JsxOpeningElement;
    /**
     * Gets the closing element.
     */
    getClosingElement(): JsxClosingElement;
}

export declare class JsxExpression extends Expression<ts.JsxExpression> {
    /**
     * Gets the dot dot dot token (...) or throws if it doesn't exist.
     */
    getDotDotDotTokenOrThrow(): Node<ts.Token<SyntaxKind.DotDotDotToken>>;
    /**
     * Gets the dot dot dot token (...) or returns undefined if it doesn't exist.
     */
    getDotDotDotToken(): Node<ts.Token<SyntaxKind.DotDotDotToken>> | undefined;
    /**
     * Gets the expression or throws if it doesn't exist.
     */
    getExpressionOrThrow(): Expression<ts.Expression>;
    /**
     * Gets the expression or returns undefined if it doesn't exist
     */
    getExpression(): Expression<ts.Expression> | undefined;
}

export declare class JsxFragment extends PrimaryExpression<ts.JsxFragment> {
    /**
     * Gets the children of the JSX fragment.
     */
    getJsxChildren(): JsxChild[];
    /**
     * Gets the opening fragment.
     */
    getOpeningFragment(): JsxOpeningFragment;
    /**
     * Gets the closing fragment.
     */
    getClosingFragment(): JsxClosingFragment;
}

export declare class JsxOpeningElement extends Expression<ts.JsxOpeningElement> {
    /**
     * Gets the tag name of the JSX closing element.
     */
    getTagName(): JsxTagNameExpression;
    /**
     * Gets the JSX element's attributes.
     */
    getAttributes(): JsxAttributeLike[];
}

export declare class JsxOpeningFragment extends Expression<ts.JsxOpeningFragment> {
}

export declare class JsxSelfClosingElement extends PrimaryExpression<ts.JsxSelfClosingElement> {
    /**
     * Gets the tag name of the JSX closing element.
     */
    getTagName(): JsxTagNameExpression;
    /**
     * Gets the JSX element's attributes.
     */
    getAttributes(): JsxAttributeLike[];
}

export declare class JsxSpreadAttribute extends Node<ts.JsxSpreadAttribute> {
    /**
     * Gets the JSX spread attribute's expression.
     */
    getExpression(): Node<ts.Expression>;
}

export declare class JsxText extends Node<ts.JsxText> {
    /**
     * Gets if the JSX text contains only white spaces.
     */
    containsOnlyWhiteSpaces(): boolean;
}

export declare const BooleanLiteralBase: typeof PrimaryExpression;

export declare class BooleanLiteral extends BooleanLiteralBase<ts.BooleanLiteral> {
    /**
     * Gets the literal value.
     */
    getLiteralValue(): boolean;
}

export declare const NullLiteralBase: typeof PrimaryExpression;

export declare class NullLiteral extends NullLiteralBase<ts.NullLiteral> {
}

export declare const NumericLiteralBase: typeof LiteralExpression;

export declare class NumericLiteral extends NumericLiteralBase<ts.NumericLiteral> {
    /**
     * Gets the literal value.
     */
    getLiteralValue(): number;
}
/** Quote type for a string literal. */
export declare enum QuoteType {
    /** Single quote */
    Single = "'",
    /** Double quote */
    Double = "\"",
}

export declare const RegularExpressionLiteralBase: typeof LiteralExpression;

export declare class RegularExpressionLiteral extends RegularExpressionLiteralBase<ts.RegularExpressionLiteral> {
    /**
     * Gets the literal value.
     */
    getLiteralValue(): RegExp;
}

export declare const StringLiteralBase: typeof LiteralExpression;

export declare class StringLiteral extends StringLiteralBase<ts.StringLiteral> {
    /**
     * Gets the literal value.
     */
    getLiteralValue(): string;
    /**
     * Gets the quote type.
     */
    getQuoteType(): QuoteType;
}

export declare const NoSubstitutionTemplateLiteralBase: typeof LiteralExpression;

export declare class NoSubstitutionTemplateLiteral extends NoSubstitutionTemplateLiteralBase<ts.NoSubstitutionTemplateLiteral> {
    /**
     * Gets the literal value.
     */
    getLiteralValue(): string;
}

export declare const TaggedTemplateExpressionBase: typeof MemberExpression;

export declare class TaggedTemplateExpression extends TaggedTemplateExpressionBase<ts.TaggedTemplateExpression> {
    /**
     * Gets the tag.
     */
    getTag(): LeftHandSideExpression<ts.LeftHandSideExpression>;
    /**
     * Gets the template literal.
     */
    getTemplate(): TemplateExpression;
}

export declare const TemplateExpressionBase: typeof PrimaryExpression;

export declare class TemplateExpression extends TemplateExpressionBase<ts.TemplateExpression> {
    /**
     * Gets the template head.
     */
    getHead(): TemplateHead;
    /**
     * Gets the template spans.
     */
    getTemplateSpans(): TemplateSpan[];
}

export declare const TemplateHeadBase: (new (...args: any[]) => LiteralLikeNode) & typeof Node;

export declare class TemplateHead extends TemplateHeadBase<ts.TemplateHead> {
}

export declare const TemplateMiddleBase: (new (...args: any[]) => LiteralLikeNode) & typeof Node;

export declare class TemplateMiddle extends TemplateMiddleBase<ts.TemplateMiddle> {
}

export declare const TemplateSpanBase: (new (...args: any[]) => ExpressionedNode) & typeof Node;

export declare class TemplateSpan extends TemplateSpanBase<ts.TemplateSpan> {
    /**
     * Gets the template literal.
     */
    getLiteral(): TemplateMiddle | TemplateTail;
}

export declare const TemplateTailBase: (new (...args: any[]) => LiteralLikeNode) & typeof Node;

export declare class TemplateTail extends TemplateTailBase<ts.TemplateTail> {
}

export declare type NamespaceChildableNodeExtensionType = Node;

export interface NamespaceChildableNode {
    /**
     * Gets the parent namespace or undefined if it doesn't exist.
     */
    getParentNamespace(): NamespaceDeclaration | undefined;
}

export declare function NamespaceChildableNode<T extends Constructor<NamespaceChildableNodeExtensionType>>(Base: T): Constructor<NamespaceChildableNode> & T;

export declare const NamespaceDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => UnwrappableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => BodiedNode) & (new (...args: any[]) => NamespaceChildableNode) & (new (...args: any[]) => StatementedNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => AmbientableNode) & (new (...args: any[]) => ExportableNode) & (new (...args: any[]) => ModifierableNode) & (new (...args: any[]) => NamedNode) & typeof Statement;

export declare class NamespaceDeclaration extends NamespaceDeclarationBase<ts.NamespaceDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<NamespaceDeclarationStructure>): this;
    /**
     * Gets the full name of the namespace.
     */
    getName(): string;
    /**
     * Sets the name without renaming references.
     * @param newName - New full namespace name.
     */
    setName(newName: string): this;
    /**
     * Renames the name.
     * @param newName - New name.
     */
    rename(newName: string): this;
    /**
     * Gets the name nodes.
     */
    getNameNodes(): Identifier[];
    /**
     * Gets if this namespace has a namespace keyword.
     */
    hasNamespaceKeyword(): boolean;
    /**
     * Gets if this namespace has a namespace keyword.
     */
    hasModuleKeyword(): boolean;
    /**
     * Set if this namespace has a namespace keyword.
     * @param value - Whether to set it or not.
     */
    setHasNamespaceKeyword(value?: boolean): this;
    /**
     * Set if this namespace has a namepsace keyword.
     * @param value - Whether to set it or not.
     */
    setHasModuleKeyword(value?: boolean): this;
    /**
     * Gets the namespace or module keyword.
     */
    getDeclarationTypeKeyword(): Node<ts.Node> | undefined;
}

export declare const BlockBase: (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => StatementedNode) & typeof Statement;

export declare class Block extends BlockBase<ts.Block> {
}

export declare const BreakStatementBase: (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class BreakStatement extends BreakStatementBase<ts.BreakStatement> {
    /**
     * Gets this break statement's label or undefined if it does not exist.
     */
    getLabel(): Identifier | undefined;
    /**
     * Gets this break statement's label or throw if it does not exist.
     */
    getLabelOrThrow(): Identifier;
}

export declare const CaseBlockBase: (new (...args: any[]) => TextInsertableNode) & typeof Node;

export declare class CaseBlock extends CaseBlockBase<ts.CaseBlock> {
    /**
     * Gets the clauses.
     */
    getClauses(): (CaseClause | DefaultClause)[];
    /**
     * Removes the clause at the specified index.
     * @param index - Index.
     */
    removeClause(index: number): this;
    /**
     * Removes the clauses in the specified range.
     * @param indexRange - Index range.
     */
    removeClauses(indexRange: [number, number]): this;
}

export declare const CaseClauseBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => StatementedNode) & typeof Node;

export declare class CaseClause extends CaseClauseBase<ts.CaseClause> {
    /**
     * Gets this switch statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
    /**
     * Removes this case clause.
     */
    remove(): void;
}

export declare const ContinueStatementBase: (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class ContinueStatement extends ContinueStatementBase<ts.ContinueStatement> {
    /**
     * Gets this continue statement's label or undefined if it does not exist.
     */
    getLabel(): Identifier | undefined;
    /**
     * Gets this continue statement's label or throw if it does not exist.
     */
    getLabelOrThrow(): Identifier;
}

export declare const DefaultClauseBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TextInsertableNode) & (new (...args: any[]) => StatementedNode) & typeof Node;

export declare class DefaultClause extends DefaultClauseBase<ts.DefaultClause> {
    /**
     * Removes the default clause.
     */
    remove(): void;
}

export declare const DoStatementBase: typeof IterationStatement;

export declare class DoStatement extends DoStatementBase<ts.DoStatement> {
    /**
     * Gets this do statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
}

export declare const CatchClauseBase: typeof Node;

export declare class CatchClause extends CatchClauseBase<ts.CatchClause> {
    /**
     * Gets this catch clause's block.
     */
    getBlock(): Block;
    /**
     * Gets this catch clause's variable declaration or undefined if none exists.
     */
    getVariableDeclaration(): VariableDeclaration | undefined;
    /**
     * Gets this catch clause's variable declaration or throws if none exists.
     */
    getVariableDeclarationOrThrow(): VariableDeclaration;
}

export declare const ExpressionStatementBase: (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class ExpressionStatement extends ExpressionStatementBase<ts.ExpressionStatement> {
    /**
     * Gets this expression statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
}

export declare const DebuggerStatementBase: typeof Statement;

export declare class DebuggerStatement extends DebuggerStatementBase<ts.DebuggerStatement> {
}

export declare const EmptyStatementBase: typeof Statement;

export declare class EmptyStatement extends EmptyStatementBase<ts.EmptyStatement> {
}

export declare const ForInStatementBase: typeof IterationStatement;

export declare class ForInStatement extends ForInStatementBase<ts.ForInStatement> {
    /**
     * Gets this for in statement's initializer.
     */
    getInitializer(): Expression<ts.Expression> | VariableDeclarationList;
    /**
     * Gets this for in statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
}

export declare const ForOfStatementBase: (new (...args: any[]) => AwaitableNode) & typeof IterationStatement;

export declare class ForOfStatement extends ForOfStatementBase<ts.ForOfStatement> {
    /**
     * Gets this for of statement's initializer.
     */
    getInitializer(): Expression<ts.Expression> | VariableDeclarationList;
    /**
     * Gets this for of statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
}

export declare const ForStatementBase: typeof IterationStatement;

export declare class ForStatement extends ForStatementBase<ts.ForStatement> {
    /**
     * Gets this for statement's initializer or undefined if none exists.
     */
    getInitializer(): Expression<ts.Expression> | VariableDeclarationList | undefined;
    /**
     * Gets this for statement's initializer or throws if none exists.
     */
    getInitializerOrThrow(): Expression<ts.Expression> | VariableDeclarationList;
    /**
     * Gets this for statement's condition or undefined if none exists.
     */
    getCondition(): Expression<ts.Expression> | undefined;
    /**
     * Gets this for statement's condition or throws if none exists.
     */
    getConditionOrThrow(): Expression<ts.Expression>;
    /**
     * Gets this for statement's incrementor.
     */
    getIncrementor(): Expression<ts.Expression> | undefined;
    /**
     * Gets this for statement's incrementor or throws if none exists.
     */
    getIncrementorOrThrow(): Expression<ts.Expression>;
}

export declare const IfStatementBase: (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class IfStatement extends IfStatementBase<ts.IfStatement> {
    /**
     * Gets this if statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
    /**
     * Gets this if statement's then statement.
     */
    getThenStatement(): Statement<ts.Statement>;
    /**
     * Gets this if statement's else statement.
     */
    getElseStatement(): Statement<ts.Statement> | undefined;
}

export declare const IterationStatementBase: (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class IterationStatement<T extends ts.IterationStatement = ts.IterationStatement> extends IterationStatementBase<T> {
    /**
     * Gets this iteration statement's statement.
     */
    getStatement(): Statement<ts.Statement>;
}

export declare const LabeledStatementBase: (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class LabeledStatement extends LabeledStatementBase<ts.LabeledStatement> {
    /**
     * Gets this labeled statement's label
     */
    getLabel(): Identifier;
    /**
     * Gets this labeled statement's statement
     */
    getStatement(): Statement<ts.Statement>;
}

export declare const NotEmittedStatementBase: typeof Statement;

export declare class NotEmittedStatement extends NotEmittedStatementBase<ts.NotEmittedStatement> {
}

export declare const ReturnStatementBase: (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class ReturnStatement extends ReturnStatementBase<ts.ReturnStatement> {
    /**
     * Gets this return statement's expression if it exists or throws.
     */
    getExpressionOrThrow(): Expression<ts.Expression>;
    /**
     * Gets this return statement's expression if it exists.
     */
    getExpression(): Expression<ts.Expression> | undefined;
}

export declare class Statement<T extends ts.Statement = ts.Statement> extends Node<T> {
    /**
     * Removes the statement.
     */
    remove(): void;
}


export declare type StatementedNodeExtensionType = Node<ts.SourceFile | ts.FunctionDeclaration | ts.ModuleDeclaration | ts.FunctionLikeDeclaration | ts.CaseClause | ts.DefaultClause>;

export interface StatementedNode {
    /**
     * Gets the node's statements.
     */
    getStatements(): Statement[];
    /**
     * Gets the first statement that matches the provided condition or returns undefined if it doesn't exist.
     * @param findFunction - Function to find the statement by.
     */
    getStatement(findFunction: (statement: Node) => boolean): Statement | undefined;
    /**
     * Gets the first statement that matches the provided condition or throws if it doesn't exist.
     * @param findFunction - Function to find the statement by.
     */
    getStatementOrThrow(findFunction: (statement: Node) => boolean): Statement;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.Block): Block | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.BreakStatement): BreakStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ClassDeclaration): ClassDeclaration | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ContinueStatement): ContinueStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.DebuggerStatement): DebuggerStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.DoStatement): DoStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.EmptyStatement): EmptyStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.EnumDeclaration): EnumDeclaration | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ExportAssignment): ExportAssignment | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ExportDeclaration): ExportDeclaration | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ExpressionStatement): ExpressionStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ForInStatement): ForInStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ForOfStatement): ForOfStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ForStatement): ForStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.IfStatement): IfStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ImportDeclaration): ImportDeclaration | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.LabeledStatement): LabeledStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ReturnStatement): ReturnStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.SwitchStatement): SwitchStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.ThrowStatement): ThrowStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.TryStatement): TryStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.VariableStatement): VariableStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.WhileStatement): WhileStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind.WithStatement): WithStatement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or returns undefined if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKind(kind: SyntaxKind): Statement | undefined;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.Block): Block;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.BreakStatement): BreakStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ClassDeclaration): ClassDeclaration;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ContinueStatement): ContinueStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.DebuggerStatement): DebuggerStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.DoStatement): DoStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.EmptyStatement): EmptyStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.EnumDeclaration): EnumDeclaration;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ExportAssignment): ExportAssignment;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ExportDeclaration): ExportDeclaration;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ExpressionStatement): ExpressionStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ForInStatement): ForInStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ForOfStatement): ForOfStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ForStatement): ForStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.IfStatement): IfStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ImportDeclaration): ImportDeclaration;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ImportEqualsDeclaration): ImportEqualsDeclaration;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.InterfaceDeclaration): InterfaceDeclaration;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.LabeledStatement): LabeledStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ModuleDeclaration): NamespaceDeclaration;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.NotEmittedStatement): NotEmittedStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ReturnStatement): ReturnStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.SwitchStatement): SwitchStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.ThrowStatement): ThrowStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.TryStatement): TryStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.TypeAliasDeclaration): TypeAliasDeclaration;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.VariableStatement): VariableStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.WhileStatement): WhileStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind.WithStatement): WithStatement;
    /**
     * Gets the first statement that matches the provided syntax kind or throws if it doesn't exist.
     * @param kind - Syntax kind to find the node by.
     */
    getStatementByKindOrThrow(kind: SyntaxKind): Statement;
    /**
     * Adds statements.
     * @param text - Text of the statement or statements to add.
     * @returns The statements that were added.
     */
    addStatements(text: string): Statement[];
    /**
     * Add statements.
     * @param writerFunction - Write the text using the provided writer.
     * @returns The statements that were added.
     */
    addStatements(writerFunction: (writer: CodeBlockWriter) => void): Statement[];
    /**
     * Inserts statements at the specified index.
     * @param index - Index to insert at.
     * @param text - Text of the statement or statements to insert.
     * @returns The statements that were inserted.
     */
    insertStatements(index: number, text: string): Statement[];
    /**
     * Inserts statements at the specified index.
     * @param index - Index to insert at.
     * @param writerFunction - Write the text using the provided writer.
     * @returns The statements that were inserted.
     */
    insertStatements(index: number, writerFunction: (writer: CodeBlockWriter) => void): Statement[];
    /**
     * Removes the statement at the specified index.
     * @param index - Index to remove the statement at.
     */
    removeStatement(index: number): this;
    /**
     * Removes the statements at the specified index range.
     * @param indexRange - The start and end inclusive index range to remove.
     */
    removeStatements(indexRange: [number, number]): this;
    /**
     * Adds an class declaration as a child.
     * @param structure - Structure of the class declaration to add.
     */
    addClass(structure: ClassDeclarationStructure): ClassDeclaration;
    /**
     * Adds class declarations as a child.
     * @param structures - Structures of the class declarations to add.
     */
    addClasses(structures: ClassDeclarationStructure[]): ClassDeclaration[];
    /**
     * Inserts an class declaration as a child.
     * @param index - Index to insert at.
     * @param structure - Structure of the class declaration to insert.
     */
    insertClass(index: number, structure: ClassDeclarationStructure): ClassDeclaration;
    /**
     * Inserts class declarations as a child.
     * @param index - Index to insert at.
     * @param structures - Structures of the class declarations to insert.
     */
    insertClasses(index: number, structures: ClassDeclarationStructure[]): ClassDeclaration[];
    /**
     * Gets the direct class declaration children.
     */
    getClasses(): ClassDeclaration[];
    /**
     * Gets a class.
     * @param name - Name of the class.
     */
    getClass(name: string): ClassDeclaration | undefined;
    /**
     * Gets a class.
     * @param findFunction - Function to use to find the class.
     */
    getClass(findFunction: (declaration: ClassDeclaration) => boolean): ClassDeclaration | undefined;
    /**
     * Gets a class or throws if it doesn't exist.
     * @param name - Name of the class.
     */
    getClassOrThrow(name: string): ClassDeclaration;
    /**
     * Gets a class or throws if it doesn't exist.
     * @param findFunction - Function to use to find the class.
     */
    getClassOrThrow(findFunction: (declaration: ClassDeclaration) => boolean): ClassDeclaration;
    /**
     * Adds an enum declaration as a child.
     * @param structure - Structure of the enum declaration to add.
     */
    addEnum(structure: EnumDeclarationStructure): EnumDeclaration;
    /**
     * Adds enum declarations as a child.
     * @param structures - Structures of the enum declarations to add.
     */
    addEnums(structures: EnumDeclarationStructure[]): EnumDeclaration[];
    /**
     * Inserts an enum declaration as a child.
     * @param index - Index to insert at.
     * @param structure - Structure of the enum declaration to insert.
     */
    insertEnum(index: number, structure: EnumDeclarationStructure): EnumDeclaration;
    /**
     * Inserts enum declarations as a child.
     * @param index - Index to insert at.
     * @param structures - Structures of the enum declarations to insert.
     */
    insertEnums(index: number, structures: EnumDeclarationStructure[]): EnumDeclaration[];
    /**
     * Gets the direct enum declaration children.
     */
    getEnums(): EnumDeclaration[];
    /**
     * Gets an enum.
     * @param name - Name of the enum.
     */
    getEnum(name: string): EnumDeclaration | undefined;
    /**
     * Gets an enum.
     * @param findFunction - Function to use to find the enum.
     */
    getEnum(findFunction: (declaration: EnumDeclaration) => boolean): EnumDeclaration | undefined;
    /**
     * Gets an enum or throws if it doesn't exist.
     * @param name - Name of the enum.
     */
    getEnumOrThrow(name: string): EnumDeclaration;
    /**
     * Gets an enum or throws if it doesn't exist.
     * @param findFunction - Function to use to find the enum.
     */
    getEnumOrThrow(findFunction: (declaration: EnumDeclaration) => boolean): EnumDeclaration;
    /**
     * Adds a function declaration as a child.
     * @param structure - Structure of the function declaration to add.
     */
    addFunction(structure: FunctionDeclarationStructure): FunctionDeclaration;
    /**
     * Adds function declarations as a child.
     * @param structures - Structures of the function declarations to add.
     */
    addFunctions(structures: FunctionDeclarationStructure[]): FunctionDeclaration[];
    /**
     * Inserts an function declaration as a child.
     * @param index - Index to insert at.
     * @param structure - Structure of the function declaration to insert.
     */
    insertFunction(index: number, structure: FunctionDeclarationStructure): FunctionDeclaration;
    /**
     * Inserts function declarations as a child.
     * @param index - Index to insert at.
     * @param structures - Structures of the function declarations to insert.
     */
    insertFunctions(index: number, structures: FunctionDeclarationStructure[]): FunctionDeclaration[];
    /**
     * Gets the direct function declaration children.
     */
    getFunctions(): FunctionDeclaration[];
    /**
     * Gets a function.
     * @param name - Name of the function.
     */
    getFunction(name: string): FunctionDeclaration | undefined;
    /**
     * Gets a function.
     * @param findFunction - Function to use to find the function.
     */
    getFunction(findFunction: (declaration: FunctionDeclaration) => boolean): FunctionDeclaration | undefined;
    /**
     * Gets a function or throws if it doesn't exist.
     * @param name - Name of the function.
     */
    getFunctionOrThrow(name: string): FunctionDeclaration;
    /**
     * Gets a function or throws if it doesn't exist.
     * @param findFunction - Function to use to find the function.
     */
    getFunctionOrThrow(findFunction: (declaration: FunctionDeclaration) => boolean): FunctionDeclaration;
    /**
     * Adds a interface declaration as a child.
     * @param structure - Structure of the interface declaration to add.
     */
    addInterface(structure: InterfaceDeclarationStructure): InterfaceDeclaration;
    /**
     * Adds interface declarations as a child.
     * @param structures - Structures of the interface declarations to add.
     */
    addInterfaces(structures: InterfaceDeclarationStructure[]): InterfaceDeclaration[];
    /**
     * Inserts an interface declaration as a child.
     * @param index - Index to insert at.
     * @param structure - Structure of the interface declaration to insert.
     */
    insertInterface(index: number, structure: InterfaceDeclarationStructure): InterfaceDeclaration;
    /**
     * Inserts interface declarations as a child.
     * @param index - Index to insert at.
     * @param structures - Structures of the interface declarations to insert.
     */
    insertInterfaces(index: number, structures: InterfaceDeclarationStructure[]): InterfaceDeclaration[];
    /**
     * Gets the direct interface declaration children.
     */
    getInterfaces(): InterfaceDeclaration[];
    /**
     * Gets an interface.
     * @param name - Name of the interface.
     */
    getInterface(name: string): InterfaceDeclaration | undefined;
    /**
     * Gets an interface.
     * @param findFunction - Function to use to find the interface.
     */
    getInterface(findFunction: (declaration: InterfaceDeclaration) => boolean): InterfaceDeclaration | undefined;
    /**
     * Gets an interface or throws if it doesn't exist.
     * @param name - Name of the interface.
     */
    getInterfaceOrThrow(name: string): InterfaceDeclaration;
    /**
     * Gets an interface or throws if it doesn't exist.
     * @param findFunction - Function to use to find the interface.
     */
    getInterfaceOrThrow(findFunction: (declaration: InterfaceDeclaration) => boolean): InterfaceDeclaration;
    /**
     * Adds a namespace declaration as a child.
     * @param structure - Structure of the namespace declaration to add.
     */
    addNamespace(structure: NamespaceDeclarationStructure): NamespaceDeclaration;
    /**
     * Adds namespace declarations as a child.
     * @param structures - Structures of the namespace declarations to add.
     */
    addNamespaces(structures: NamespaceDeclarationStructure[]): NamespaceDeclaration[];
    /**
     * Inserts an namespace declaration as a child.
     * @param index - Index to insert at.
     * @param structure - Structure of the namespace declaration to insert.
     */
    insertNamespace(index: number, structure: NamespaceDeclarationStructure): NamespaceDeclaration;
    /**
     * Inserts namespace declarations as a child.
     * @param index - Index to insert at.
     * @param structures - Structures of the namespace declarations to insert.
     */
    insertNamespaces(index: number, structures: NamespaceDeclarationStructure[]): NamespaceDeclaration[];
    /**
     * Gets the direct namespace declaration children.
     */
    getNamespaces(): NamespaceDeclaration[];
    /**
     * Gets a namespace.
     * @param name - Name of the namespace.
     */
    getNamespace(name: string): NamespaceDeclaration | undefined;
    /**
     * Gets a namespace.
     * @param findFunction - Function to use to find the namespace.
     */
    getNamespace(findFunction: (declaration: NamespaceDeclaration) => boolean): NamespaceDeclaration | undefined;
    /**
     * Gets a namespace or throws if it doesn't exist.
     * @param name - Name of the namespace.
     */
    getNamespaceOrThrow(name: string): NamespaceDeclaration;
    /**
     * Gets a namespace or throws if it doesn't exist.
     * @param findFunction - Function to use to find the namespace.
     */
    getNamespaceOrThrow(findFunction: (declaration: NamespaceDeclaration) => boolean): NamespaceDeclaration;
    /**
     * Adds a type alias declaration as a child.
     * @param structure - Structure of the type alias declaration to add.
     */
    addTypeAlias(structure: TypeAliasDeclarationStructure): TypeAliasDeclaration;
    /**
     * Adds type alias declarations as a child.
     * @param structures - Structures of the type alias declarations to add.
     */
    addTypeAliases(structures: TypeAliasDeclarationStructure[]): TypeAliasDeclaration[];
    /**
     * Inserts an type alias declaration as a child.
     * @param index - Index to insert at.
     * @param structure - Structure of the type alias declaration to insert.
     */
    insertTypeAlias(index: number, structure: TypeAliasDeclarationStructure): TypeAliasDeclaration;
    /**
     * Inserts type alias declarations as a child.
     * @param index - Index to insert at.
     * @param structures - Structures of the type alias declarations to insert.
     */
    insertTypeAliases(index: number, structures: TypeAliasDeclarationStructure[]): TypeAliasDeclaration[];
    /**
     * Gets the direct type alias declaration children.
     */
    getTypeAliases(): TypeAliasDeclaration[];
    /**
     * Gets a type alias.
     * @param name - Name of the type alias.
     */
    getTypeAlias(name: string): TypeAliasDeclaration | undefined;
    /**
     * Gets a type alias.
     * @param findFunction - Function to use to find the type alias.
     */
    getTypeAlias(findFunction: (declaration: TypeAliasDeclaration) => boolean): TypeAliasDeclaration | undefined;
    /**
     * Gets a type alias or throws if it doesn't exist.
     * @param name - Name of the type alias.
     */
    getTypeAliasOrThrow(name: string): TypeAliasDeclaration;
    /**
     * Gets a type alias or throws if it doesn't exist.
     * @param findFunction - Function to use to find the type alias.
     */
    getTypeAliasOrThrow(findFunction: (declaration: TypeAliasDeclaration) => boolean): TypeAliasDeclaration;
    /**
     * Adds a variable statement.
     * @param structure - Structure of the variable statement.
     */
    addVariableStatement(structure: VariableStatementStructure): VariableStatement;
    /**
     * Adds variable statements.
     * @param structures - Structures of the variable statements.
     */
    addVariableStatements(structures: VariableStatementStructure[]): VariableStatement[];
    /**
     * Inserts a variable statement.
     * @param structure - Structure of the variable statement.
     */
    insertVariableStatement(index: number, structure: VariableStatementStructure): VariableStatement;
    /**
     * Inserts variable statements.
     * @param structures - Structures of the variable statements.
     */
    insertVariableStatements(index: number, structures: VariableStatementStructure[]): VariableStatement[];
    /**
     * Gets the direct variable statement children.
     */
    getVariableStatements(): VariableStatement[];
    /**
     * Gets a variable statement.
     * @param findFunction - Function to use to find the variable statement.
     */
    getVariableStatement(findFunction: (declaration: VariableStatement) => boolean): VariableStatement | undefined;
    /**
     * Gets a variable statement or throws if it doesn't exist.
     * @param findFunction - Function to use to find the variable statement.
     */
    getVariableStatementOrThrow(findFunction: (declaration: VariableStatement) => boolean): VariableStatement;
    /**
     * Gets all the variable declarations within all the variable declarations of the direct variable statement children.
     */
    getVariableDeclarations(): VariableDeclaration[];
    /**
     * Gets a variable declaration.
     * @param name - Name of the variable declaration.
     */
    getVariableDeclaration(name: string): VariableDeclaration | undefined;
    /**
     * Gets a variable declaration.
     * @param findFunction - Function to use to find the variable declaration.
     */
    getVariableDeclaration(findFunction: (declaration: VariableDeclaration) => boolean): VariableDeclaration | undefined;
    /**
     * Gets a variable declaration or throws if it doesn't exist.
     * @param name - Name of the variable declaration.
     */
    getVariableDeclarationOrThrow(name: string): VariableDeclaration;
    /**
     * Gets a variable declaration or throws if it doesn't exist.
     * @param findFunction - Function to use to find the variable declaration.
     */
    getVariableDeclarationOrThrow(findFunction: (declaration: VariableDeclaration) => boolean): VariableDeclaration;
}

export declare function StatementedNode<T extends Constructor<StatementedNodeExtensionType>>(Base: T): Constructor<StatementedNode> & T;

export declare const SwitchStatementBase: (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class SwitchStatement extends SwitchStatementBase<ts.SwitchStatement> {
    /**
     * Gets this switch statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
    /**
     * Gets this switch statement's case block.
     */
    getCaseBlock(): CaseBlock;
    /**
     * Gets the switch statement's case block's clauses.
     */
    getClauses(): CaseOrDefaultClause[];
    /**
     * Removes the specified clause based on the provided index.
     * @param index - Index.
     */
    removeClause(index: number): CaseBlock;
    /**
     * Removes the specified clauses based on the provided index range.
     * @param indexRange - Index range.
     */
    removeClauses(indexRange: [number, number]): CaseBlock;
}

export declare const ThrowStatementBase: typeof Statement;

export declare class ThrowStatement extends ThrowStatementBase<ts.ThrowStatement> {
    /**
     * Gets this do statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
}

export declare const TryStatementBase: typeof Statement;

export declare class TryStatement extends TryStatementBase<ts.TryStatement> {
    /**
     * Gets this try statement's try block.
     */
    getTryBlock(): Block;
    /**
     * Gets this try statement's catch clause or undefined if none exists.
     */
    getCatchClause(): CatchClause | undefined;
    /**
     * Gets this try statement's catch clause or throws if none exists.
     */
    getCatchClauseOrThrow(): CatchClause;
    /**
     * Gets this try statement's finally block or undefined if none exists.
     */
    getFinallyBlock(): Block | undefined;
    /**
     * Gets this try statement's finally block or throws if none exists.
     */
    getFinallyBlockOrThrow(): Block;
}

export declare const VariableDeclarationBase: (new (...args: any[]) => TypedNode) & (new (...args: any[]) => InitializerExpressionableNode) & (new (...args: any[]) => BindingNamedNode) & typeof Node;

export declare class VariableDeclaration extends VariableDeclarationBase<ts.VariableDeclaration> {
    /**
     * Fills this node with the specified structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<VariableDeclarationStructure>): this;
    /**
     * Removes this variable declaration.
     */
    remove(): void;
}

export declare const VariableDeclarationListBase: (new (...args: any[]) => ModifierableNode) & typeof Node;

export declare class VariableDeclarationList extends VariableDeclarationListBase<ts.VariableDeclarationList> {
    /**
     * Get the variable declarations.
     */
    getDeclarations(): VariableDeclaration[];
    /**
     * Gets the variable declaration type.
     */
    getDeclarationType(): VariableDeclarationType;
    /**
     * Gets the variable declaration type keyword.
     */
    getDeclarationTypeKeyword(): Node;
    /**
     * Sets the variable declaration type.
     * @param type - Type to set.
     */
    setDeclarationType(type: VariableDeclarationType): this;
    /**
     * Add a variable declaration to the statement.
     * @param structure - Structure representing the variable declaration to add.
     */
    addDeclaration(structure: VariableDeclarationStructure): VariableDeclaration;
    /**
     * Adds variable declarations to the statement.
     * @param structures - Structures representing the variable declarations to add.
     */
    addDeclarations(structures: VariableDeclarationStructure[]): VariableDeclaration[];
    /**
     * Inserts a variable declaration at the specified index within the statement.
     * @param index - Index to insert.
     * @param structure - Structure representing the variable declaration to insert.
     */
    insertDeclaration(index: number, structure: VariableDeclarationStructure): VariableDeclaration;
    /**
     * Inserts variable declarations at the specified index within the statement.
     * @param index - Index to insert.
     * @param structures - Structures representing the variable declarations to insert.
     */
    insertDeclarations(index: number, structures: VariableDeclarationStructure[]): VariableDeclaration[];
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<VariableDeclarationListStructure>): this;
}
export declare enum VariableDeclarationType {
    Var = "var",
    Let = "let",
    Const = "const",
}

export declare const VariableStatementBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => NamespaceChildableNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => AmbientableNode) & (new (...args: any[]) => ExportableNode) & (new (...args: any[]) => ModifierableNode) & typeof Statement;

export declare class VariableStatement extends VariableStatementBase<ts.VariableStatement> {
    /**
     * Get variable declaration list.
     */
    getDeclarationList(): VariableDeclarationList;
    /**
     * Get the variable declarations.
     */
    getDeclarations(): VariableDeclaration[];
    /**
     * Gets the variable declaration type.
     */
    getDeclarationType(): VariableDeclarationType;
    /**
     * Gets the variable declaration type keyword.
     */
    getDeclarationTypeKeyword(): Node;
    /**
     * Sets the variable declaration type.
     * @param type - Type to set.
     */
    setDeclarationType(type: VariableDeclarationType): VariableDeclarationList;
    /**
     * Add a variable declaration to the statement.
     * @param structure - Structure representing the variable declaration to add.
     */
    addDeclaration(structure: VariableDeclarationStructure): VariableDeclaration;
    /**
     * Adds variable declarations to the statement.
     * @param structures - Structures representing the variable declarations to add.
     */
    addDeclarations(structures: VariableDeclarationStructure[]): VariableDeclaration[];
    /**
     * Inserts a variable declaration at the specified index within the statement.
     * @param index - Index to insert.
     * @param structure - Structure representing the variable declaration to insert.
     */
    insertDeclaration(index: number, structure: VariableDeclarationStructure): VariableDeclaration;
    /**
     * Inserts variable declarations at the specified index within the statement.
     * @param index - Index to insert.
     * @param structures - Structures representing the variable declarations to insert.
     */
    insertDeclarations(index: number, structures: VariableDeclarationStructure[]): VariableDeclaration[];
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<VariableStatementStructure>): this;
}

export declare const WhileStatementBase: typeof IterationStatement;

export declare class WhileStatement extends WhileStatementBase<ts.WhileStatement> {
    /**
     * Gets this while statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
}

export declare const WithStatementBase: (new (...args: any[]) => ChildOrderableNode) & typeof Statement;

export declare class WithStatement extends WithStatementBase<ts.WithStatement> {
    /**
     * Gets this with statement's expression.
     */
    getExpression(): Expression<ts.Expression>;
    /**
     * Gets this with statement's statement.
     */
    getStatement(): Statement<ts.Statement>;
}

export declare class LanguageService {
    private readonly _compilerObject;
    private readonly compilerHost;
    private program;
    /**
     * Gets the compiler language service.
     */
    readonly compilerObject: ts.LanguageService;
    /**
     * Gets the language service's program.
     */
    getProgram(): Program;
    /**
     * Rename the specified node.
     * @param node - Node to rename.
     * @param newName - New name for the node.
     */
    renameNode(node: Node, newName: string): void;
    /**
     * Rename the provided rename locations.
     * @param renameLocations - Rename locations.
     * @param newName - New name for the node.
     */
    renameLocations(renameLocations: RenameLocation[], newName: string): void;
    /**
     * Gets the definitions for the specified node.
     * @param node - Node.
     */
    getDefinitions(node: Node): DefinitionInfo[];
    /**
     * Gets the definitions at the specified position.
     * @param sourceFile - Source file.
     * @param pos - Position.
     */
    getDefinitionsAtPosition(sourceFile: SourceFile, pos: number): DefinitionInfo[];
    /**
     * Gets the implementations for the specified node.
     * @param node - Node.
     */
    getImplementations(node: Node): ImplementationLocation[];
    /**
     * Gets the implementations at the specified position.
     * @param sourceFile - Source file.
     * @param pos - Position.
     */
    getImplementationsAtPosition(sourceFile: SourceFile, pos: number): ImplementationLocation[];
    /**
     * Finds references based on the specified node.
     * @param node - Node to find references for.
     */
    findReferences(node: Node): ReferencedSymbol[];
    /**
     * Finds references based on the specified position.
     * @param sourceFile - Source file.
     * @param pos - Position to find the reference at.
     */
    findReferencesAtPosition(sourceFile: SourceFile, pos: number): ReferencedSymbol[];
    /**
     * Find the rename locations for the specified node.
     * @param node - Node to get the rename locations for.
     */
    findRenameLocations(node: Node): RenameLocation[];
    /**
     * Gets the formatting edits for a range.
     * @param filePath - File path.
     * @param range - Position range.
     * @param settings - Settings.
     */
    getFormattingEditsForRange(filePath: string, range: [number, number], settings: FormatCodeSettings): TextChange[];
    /**
     * Gets the formatting edits for a document.
     * @param filePath - File path of the source file.
     * @param settings - Format code settings.
     */
    getFormattingEditsForDocument(filePath: string, settings: FormatCodeSettings): TextChange[];
    /**
     * Gets the formatted text for a document.
     * @param filePath - File path of the source file.
     * @param settings - Format code settings.
     */
    getFormattedDocumentText(filePath: string, settings: FormatCodeSettings): string;
    /**
     * Gets the emit output of a source file.
     * @param sourceFile - Source file.
     * @param emitOnlyDtsFiles - Whether to only emit the d.ts files.
     */
    getEmitOutput(sourceFile: SourceFile, emitOnlyDtsFiles?: boolean): EmitOutput;
    /**
     * Gets the emit output of a source file.
     * @param filePath - File path.
     * @param emitOnlyDtsFiles - Whether to only emit the d.ts files.
     */
    getEmitOutput(filePath: string, emitOnlyDtsFiles?: boolean): EmitOutput;
}

/**
 * Options for emitting.
 */
export interface EmitOptions {
    /**
     * Optional source file to only emit.
     */
    targetSourceFile?: SourceFile;
    /**
     * Whether only .d.ts files should be emitted.
     */
    emitOnlyDtsFiles?: boolean;
}

/**
 * Wrapper around Program.
 */
export declare class Program {
    /**
     * Gets the underlying compiler program.
     */
    readonly compilerObject: ts.Program;
    /**
     * Get the program's type checker.
     */
    getTypeChecker(): TypeChecker;
    /**
     * Emits the TypeScript files to the specified target.
     */
    emit(options?: EmitOptions): EmitResult;
    /**
     * Gets the syntactic diagnostics.
     * @param sourceFile - Optional source file.
     */
    getSyntacticDiagnostics(sourceFile?: SourceFile): Diagnostic[];
    /**
     * Gets the semantic diagnostics.
     * @param sourceFile - Optional source file.
     */
    getSemanticDiagnostics(sourceFile?: SourceFile): Diagnostic[];
    /**
     * Gets the declaration diagnostics.
     * @param sourceFile - Optional source file.
     */
    getDeclarationDiagnostics(sourceFile?: SourceFile): Diagnostic[];
    /**
     * Gets the pre-emit diagnostics.
     * @param sourceFile - Source file.
     */
    getPreEmitDiagnostics(sourceFile?: SourceFile): Diagnostic[];
}

/**
 * Wrapper around the TypeChecker.
 */
export declare class TypeChecker {
    /**
     * Gets the compiler's TypeChecker.
     */
    readonly compilerObject: ts.TypeChecker;
    /**
     * Gets the apparent type of a type.
     * @param type - Type to get the apparent type of.
     */
    getApparentType(type: Type): Type<ts.Type>;
    /**
     * Gets the constant value of a declaration.
     * @param node - Node to get the constant value from.
     */
    getConstantValue(node: EnumMember): string | number | undefined;
    /**
     * Gets the fully qualified name of a symbol.
     * @param symbol - Symbol to get the fully qualified name of.
     */
    getFullyQualifiedName(symbol: Symbol): string;
    /**
     * Gets the type at the specified location.
     * @param node - Node to get the type for.
     */
    getTypeAtLocation(node: Node): Type;
    /**
     * Gets the contextual type of an expression.
     * @param expression - Expression.
     */
    getContextualType(expression: Expression): Type | undefined;
    /**
     * Gets the type of a symbol at the specified location.
     * @param symbol - Symbol to get the type for.
     * @param node - Location to get the type for.
     */
    getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
    /**
     * Gets the declared type of a symbol.
     * @param symbol - Symbol to get the type for.
     */
    getDeclaredTypeOfSymbol(symbol: Symbol): Type;
    /**
     * Gets the symbol at the specified location or undefined if none exists.
     * @param node - Node to get the symbol for.
     */
    getSymbolAtLocation(node: Node): Symbol | undefined;
    /**
     * Gets the aliased symbol of a symbol.
     * @param symbol - Symbol to get the alias symbol of.
     */
    getAliasedSymbol(symbol: Symbol): Symbol | undefined;
    /**
     * Gets the properties of a type.
     * @param type - Type.
     */
    getPropertiesOfType(type: Type): Symbol[];
    /**
     * Gets the type text
     * @param type - Type to get the text of.
     * @param enclosingNode - Enclosing node.
     * @param typeFormatFlags - Type format flags.
     */
    getTypeText(type: Type, enclosingNode?: Node, typeFormatFlags?: TypeFormatFlags): string;
    /**
     * Gets the return type of a signature.
     * @param signature - Signature to get the return type of.
     */
    getReturnTypeOfSignature(signature: Signature): Type;
    /**
     * Gets a signature from a node.
     * @param node - Node to get the signature from.
     */
    getSignatureFromNode(node: Node<ts.SignatureDeclaration>): Signature | undefined;
    /**
     * Gets the exports of a module.
     * @param moduleSymbol - Module symbol.
     */
    getExportsOfModule(moduleSymbol: Symbol): Symbol[];
    /**
     * Gets the local target symbol of the provided export specifier.
     * @param exportSpecifier - Export specifier.
     */
    getExportSpecifierLocalTargetSymbol(exportSpecifier: ExportSpecifier): Symbol | undefined;
    private getDefaultTypeFormatFlags(enclosingNode?);
}

export interface FormatCodeSettings extends ts.FormatCodeSettings {
    ensureNewLineAtEndOfFile?: boolean;
}

/**
 * Definition info.
 */
export declare class DefinitionInfo<TCompilerObject extends ts.DefinitionInfo = ts.DefinitionInfo> {
    /**
     * Gets the compiler object.
     */
    readonly compilerObject: TCompilerObject;
    /**
     * Gets the source file this reference is in.
     */
    getSourceFile(): SourceFile;
    /**
     * Gets the text span.
     */
    getTextSpan(): TextSpan;
    /**
     * Gets the kind.
     */
    getKind(): ts.ScriptElementKind;
    /**
     * Gets the name.
     */
    getName(): string;
    /**
     * Gets the container kind.
     */
    getContainerKind(): ts.ScriptElementKind;
    /**
     * Gets the container name.
     */
    getContainerName(): string;
    /**
     * Gets the definition node.
     */
    getNode(): Node | undefined;
}

/**
 * Diagnostic.
 */
export declare class Diagnostic {
    /**
     * Gets the underlying compiler diagnostic.
     */
    readonly compilerObject: ts.Diagnostic;
    /**
     * Gets the source file.
     */
    getSourceFile(): SourceFile | undefined;
    /**
     * Gets the message text.
     */
    getMessageText(): string | DiagnosticMessageChain;
    /**
     * Gets the start.
     */
    getStart(): number | undefined;
    /**
     * Gets the length.
     */
    getLength(): number | undefined;
    /**
     * Gets the diagnostic category.
     */
    getCategory(): DiagnosticCategory;
    /**
     * Gets the code of the diagnostic.
     */
    getCode(): number;
    /**
     * Gets the source.
     */
    getSource(): string | undefined;
}

/**
 * Diagnostic message chain.
 */
export declare class DiagnosticMessageChain {
    /**
     * Gets the underlying compiler object.
     */
    readonly compilerObject: ts.DiagnosticMessageChain;
    /**
     * Gets the message text.
     */
    getMessageText(): string;
    /**
     * Gets th enext diagnostic message chain in the chain.
     */
    getNext(): DiagnosticMessageChain | undefined;
    /**
     * Gets the code of the diagnostic message chain.
     */
    getCode(): number;
    /**
     * Gets the category of the diagnostic message chain.
     */
    getCategory(): DiagnosticCategory;
}

/**
 * Document span.
 */
export declare class DocumentSpan<TCompilerObject extends ts.DocumentSpan = ts.DocumentSpan> {
    /**
     * Gets the compiler object.
     */
    readonly compilerObject: TCompilerObject;
    /**
     * Gets the source file this reference is in.
     */
    getSourceFile(): SourceFile;
    /**
     * Gets the text span.
     */
    getTextSpan(): TextSpan;
    /**
     * Gets the node at the start of the text span.
     */
    getNode(): Node<ts.Node>;
}

/**
 * Output of an emit on a single file.
 */
export declare class EmitOutput {
    private readonly filePath;
    /**
     * TypeScript compiler emit result.
     */
    readonly compilerObject: ts.EmitOutput;
    /**
     * Gets if the emit was skipped.
     */
    getEmitSkipped(): boolean;
    /**
     * Gets the output files.
     */
    getOutputFiles(): OutputFile[];
}

/**
 * Result of an emit.
 */
export declare class EmitResult {
    /**
     * TypeScript compiler emit result.
     */
    readonly compilerObject: ts.EmitResult;
    /**
     * If the emit was skipped.
     */
    getEmitSkipped(): boolean;
    /**
     * Contains declaration emit diagnostics.
     */
    getDiagnostics(): Diagnostic[];
}

export declare class ImplementationLocation extends DocumentSpan<ts.ImplementationLocation> {
    /**
     * Gets the kind.
     */
    getKind(): ts.ScriptElementKind;
    /**
     * Gets the display parts.
     */
    getDisplayParts(): SymbolDisplayPart[];
}

/**
 * Output file of an emit.
 */
export declare class OutputFile {
    /**
     * TypeScript compiler emit result.
     */
    readonly compilerObject: ts.OutputFile;
    /**
     * Gets the file path.
     */
    getFilePath(): string;
    /**
     * Gets whether the byte order mark should be written.
     */
    getWriteByteOrderMark(): boolean;
    /**
     * Gets the file text.
     */
    getText(): string;
}

/**
 * Referenced symbol.
 */
export declare class ReferencedSymbol {
    /**
     * Gets the compiler referenced symbol.
     */
    readonly compilerObject: ts.ReferencedSymbol;
    /**
     * Gets the definition.
     */
    getDefinition(): ReferencedSymbolDefinitionInfo;
    /**
     * Gets the references.
     */
    getReferences(): ReferenceEntry[];
}

export declare class ReferencedSymbolDefinitionInfo extends DefinitionInfo<ts.ReferencedSymbolDefinitionInfo> {
    /**
     * Gets the display parts.
     */
    getDisplayParts(): SymbolDisplayPart[];
}

export declare class ReferenceEntry extends DocumentSpan<ts.ReferenceEntry> {
    isWriteAccess(): boolean;
    /**
     * If this is the definition reference.
     */
    isDefinition(): boolean;
    isInString(): true | undefined;
}

/**
 * Rename location.
 */
export declare class RenameLocation extends DocumentSpan<ts.RenameLocation> {
}

/**
 * Symbol display part.
 */
export declare class SymbolDisplayPart {
    /** Gets the compiler symbol display part. */
    readonly compilerObject: ts.SymbolDisplayPart;
    /**
     * Gets the text.
     */
    getText(): string;
    /**
     * Gets the kind.
     *
     * Examples: "text", "lineBreak"
     */
    getKind(): string;
}

/**
 * Represents a text change.
 */
export declare class TextChange {
    private _span;
    /** Gets the compiler text change. */
    readonly compilerObject: ts.TextChange;
    /**
     * Gets the text span.
     */
    getSpan(): TextSpan;
    /**
     * Gets the new text.
     */
    getNewText(): string;
}

/**
 * Represents a span of text.
 */
export declare class TextSpan {
    /** Gets the compiler text span. */
    readonly compilerObject: ts.TextSpan;
    /**
     * Gets the start.
     */
    getStart(): number;
    /**
     * Gets the start + length.
     */
    getEnd(): number;
    /**
     * Gets the length.
     */
    getLength(): number;
}

export declare class ArrayTypeNode extends TypeNode<ts.ArrayTypeNode> {
    /**
     * Gets the array type node's element type node.
     */
    getElementTypeNode(): TypeNode<ts.TypeNode>;
}

declare const ConstructorTypeNode_base: (new (...args: any[]) => SignaturedDeclaration) & typeof TypeNode;

export declare class ConstructorTypeNode extends ConstructorTypeNode_base<ts.ConstructorTypeNode> {
}

export declare const ExpressionWithTypeArgumentsBase: (new (...args: any[]) => LeftHandSideExpressionedNode) & typeof TypeNode;

export declare class ExpressionWithTypeArguments extends ExpressionWithTypeArgumentsBase<ts.ExpressionWithTypeArguments> {
    /**
     * Gets the type arguments.
     */
    getTypeArguments(): TypeNode[];
}

declare const FunctionTypeNode_base: (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => SignaturedDeclaration) & typeof TypeNode;

export declare class FunctionTypeNode extends FunctionTypeNode_base<ts.FunctionTypeNode> {
}

export declare class IntersectionTypeNode extends TypeNode<ts.IntersectionTypeNode> {
    /**
     * Gets the intersection type nodes.
     */
    getTypeNodes(): TypeNode<ts.TypeNode>[];
}

export declare class LiteralTypeNode extends TypeNode<ts.LiteralTypeNode> {
    /**
     * Gets the literal type node's literal.
     */
    getLiteral(): PrefixUnaryExpression | BooleanLiteral | LiteralExpression<ts.LiteralExpression>;
}

export declare class TupleTypeNode extends TypeNode<ts.TupleTypeNode> {
    /**
     * Gets the tuple element type nodes.
     */
    getElementTypeNodes(): TypeNode<ts.TypeNode>[];
}

export declare class Type<TType extends ts.Type = ts.Type> {
    /**
     * Gets the underlying compiler type.
     */
    readonly compilerType: TType;
    /**
     * Gets the type text.
     * @param enclosingNode - The enclosing node.
     * @param typeFormatFlags - Format flags for the type text.
     */
    getText(enclosingNode?: Node, typeFormatFlags?: TypeFormatFlags): string;
    /**
     * Gets the alias symbol if it exists.
     */
    getAliasSymbol(): Symbol | undefined;
    /**
     * Gets the alias symbol if it exists, or throws.
     */
    getAliasSymbolOrThrow(): Symbol;
    /**
     * Gets the alias type arguments.
     */
    getAliasTypeArguments(): Type[];
    /**
     * Gets the apparent type.
     */
    getApparentType(): Type;
    /**
     * Gets the array type
     */
    getArrayType(): Type<ts.Type> | undefined;
    /**
     * Gets the base types.
     */
    getBaseTypes(): Type<ts.BaseType>[];
    /**
     * Gets the call signatures.
     */
    getCallSignatures(): Signature[];
    /**
     * Gets the construct signatures.
     */
    getConstructSignatures(): Signature[];
    /**
     * Gets the properties of the type.
     */
    getProperties(): Symbol[];
    /**
     * Gets a property.
     * @param name - By a name.
     * @param findFunction - Function for searching for a property.
     */
    getProperty(name: string): Symbol | undefined;
    getProperty(findFunction: (declaration: Symbol) => boolean): Symbol | undefined;
    /**
     * Gets the apparent properties of the type.
     */
    getApparentProperties(): Symbol[];
    /**
     * Gets an apparent property.
     * @param name - By a name.
     * @param findFunction - Function for searching for an apparent property.
     */
    getApparentProperty(name: string): Symbol | undefined;
    getApparentProperty(findFunction: (declaration: Symbol) => boolean): Symbol | undefined;
    /**
     * Gets the non-nullable type.
     */
    getNonNullableType(): Type;
    /**
     * Gets the number index type.
     */
    getNumberIndexType(): Type | undefined;
    /**
     * Gets the string index type.
     */
    getStringIndexType(): Type | undefined;
    /**
     * Gets the target type of a type reference if it exists.
     */
    getTargetType(): Type<ts.GenericType> | undefined;
    /**
     * Gets the target type of a type reference or throws if it doesn't exist.
     */
    getTargetTypeOrThrow(): Type<ts.GenericType>;
    /**
     * Gets type arguments.
     */
    getTypeArguments(): Type[];
    /**
     * Gets the union types.
     */
    getUnionTypes(): Type[];
    /**
     * Gets the intersection types.
     */
    getIntersectionTypes(): Type[];
    /**
     * Gets the symbol of the type.
     */
    getSymbol(): Symbol | undefined;
    /**
     * Gets the symbol of the type or throws.
     */
    getSymbolOrThrow(): Symbol;
    /**
     * Gets if this is an anonymous type.
     */
    isAnonymousType(): boolean;
    /**
     * Gets if this is an array type.
     */
    isArrayType(): boolean;
    /**
     * Gets if this is a boolean type.
     */
    isBooleanType(): boolean;
    /**
     * Gets if this is an enum type.
     */
    isEnumType(): boolean;
    /**
     * Gets if this is an interface type.
     */
    isInterfaceType(): boolean;
    /**
     * Gets if this is an intersection type.
     */
    isIntersectionType(): boolean;
    /**
     * Gets if this is an object type.
     */
    isObjectType(): boolean;
    /**
     * Gets if this is a type parameter.
     */
    isTypeParameter(): this is TypeParameter;
    /**
     * Gets if this is a union type.
     */
    isUnionType(): boolean;
    /**
     * Gets if this is the undefined type.
     */
    isUndefinedType(): boolean;
    /**
     * Gets the type flags.
     */
    getFlags(): TypeFlags;
    /**
     * Gets the object flags.
     */
    getObjectFlags(): 0 | ObjectFlags;
}

export declare const TypeAliasDeclarationBase: (new (...args: any[]) => ChildOrderableNode) & (new (...args: any[]) => TypeParameteredNode) & (new (...args: any[]) => TypedNode) & (new (...args: any[]) => JSDocableNode) & (new (...args: any[]) => AmbientableNode) & (new (...args: any[]) => ExportableNode) & (new (...args: any[]) => ModifierableNode) & (new (...args: any[]) => NamedNode) & typeof Statement;

export declare class TypeAliasDeclaration extends TypeAliasDeclarationBase<ts.TypeAliasDeclaration> {
    /**
     * Fills the node from a structure.
     * @param structure - Structure to fill.
     */
    fill(structure: Partial<TypeAliasDeclarationStructure>): this;
}

export declare class TypeNode<T extends ts.TypeNode = ts.TypeNode> extends Node<T> {
}

export declare class TypeParameter extends Type<ts.TypeParameter> {
    /**
     * Gets the constraint or throws if it doesn't exist.
     */
    getConstraintOrThrow(): Type;
    /**
     * Gets the constraint type.
     */
    getConstraint(): Type | undefined;
    /**
     * Gets the default type or throws if it doesn't exist.
     */
    getDefaultOrThrow(): Type;
    /**
     * Gets the default type or undefined if it doesn't exist.
     */
    getDefault(): Type | undefined;
}

export declare const TypeParameterDeclarationBase: (new (...args: any[]) => NamedNode) & typeof Node;

export declare class TypeParameterDeclaration extends TypeParameterDeclarationBase<ts.TypeParameterDeclaration> {
    /**
     * Gets the constraint node of the type parameter.
     */
    getConstraintNode(): TypeNode | undefined;
    /**
     * Gets the default node of the type parameter.
     */
    getDefaultNode(): TypeNode | undefined;
    /**
     * Removes this type parameter.
     */
    remove(): void;
}

export declare class TypeReferenceNode extends TypeNode<ts.TypeReferenceNode> {
    /**
     * Gets the type name.
     */
    getTypeName(): EntityName;
    /**
     * Gets the type arguments.
     */
    getTypeArguments(): TypeNode<ts.TypeNode>[];
}

export declare class UnionTypeNode extends TypeNode<ts.UnionTypeNode> {
    /**
     * Gets the union type nodes.
     */
    getTypeNodes(): TypeNode<ts.TypeNode>[];
}
export interface AbstractableNodeStructure {
    isAbstract?: boolean;
}
export interface AmbientableNodeStructure {
    hasDeclareKeyword?: boolean;
}
export interface AsyncableNodeStructure {
    isAsync?: boolean;
}
export interface AwaitableNodeStructure {
    isAwaited?: boolean;
}

export interface BodiedNodeStructure {
    bodyText?: string | ((writer: CodeBlockWriter) => void);
}

export interface BodyableNodeStructure {
    bodyText?: string | ((writer: CodeBlockWriter) => void);
}

export interface DecoratableNodeStructure {
    decorators?: DecoratorStructure[];
}
export interface ExportableNodeStructure {
    isExported?: boolean;
    isDefaultExport?: boolean;
}
export interface ExtendsClauseableNodeStructure {
    extends?: string[];
}
export interface GeneratorableNodeStructure {
    isGenerator?: boolean;
}
export interface ImplementsClauseableNodeStructure {
    implements?: string[];
}

export interface InitializerExpressionableNodeStructure extends InitializerSetExpressionableNodeStructure {
}
export interface InitializerSetExpressionableNodeStructure {
    initializer?: string;
}

export interface JSDocableNodeStructure {
    docs?: JSDocStructure[];
}

export interface ParameteredNodeStructure {
    parameters?: ParameterDeclarationStructure[];
}
export interface QuestionTokenableNodeStructure {
    hasQuestionToken?: boolean;
}
export interface ReadonlyableNodeStructure {
    isReadonly?: boolean;
}
export interface ReturnTypedNodeStructure {
    returnType?: string;
}

export interface ScopeableNodeStructure {
    scope?: Scope;
}

export interface ScopedNodeStructure {
    scope?: Scope;
}

export interface SignaturedDeclarationStructure extends ParameteredNodeStructure, ReturnTypedNodeStructure {
}
export interface StaticableNodeStructure {
    isStatic?: boolean;
}
export interface TypedNodeStructure {
    type?: string;
}

export interface TypeParameteredNodeStructure {
    typeParameters?: TypeParameterDeclarationStructure[];
}
export interface BindingNamedNodeStructure {
    name: string;
}
export interface DeclarationNamedNodeStructure {
    name: string;
}
export interface NamedNodeStructure {
    name: string;
}
export interface PropertyNameableNodeStructure {
    name?: string;
}
export interface PropertyNamedNodeStructure {
    name: string;
}

export interface ClassDeclarationStructure extends NamedNodeStructure, ClassDeclarationSpecificStructure, ImplementsClauseableNodeStructure, DecoratableNodeStructure, TypeParameteredNodeStructure, JSDocableNodeStructure, AmbientableNodeStructure, AbstractableNodeStructure, ExportableNodeStructure {
}

export interface ClassDeclarationSpecificStructure {
    extends?: string;
    ctor?: ConstructorDeclarationStructure;
    properties?: PropertyDeclarationStructure[];
    getAccessors?: GetAccessorDeclarationStructure[];
    setAccessors?: SetAccessorDeclarationStructure[];
    methods?: MethodDeclarationStructure[];
}

export interface ConstructorDeclarationStructure extends ConstructorDeclarationSpecificStructure, ScopedNodeStructure, FunctionLikeDeclarationStructure, BodyableNodeStructure {
}

export interface ConstructorDeclarationSpecificStructure {
    overloads?: ConstructorDeclarationOverloadStructure[];
}

export interface ConstructorDeclarationOverloadStructure extends ScopedNodeStructure, SignaturedDeclarationStructure, TypeParameteredNodeStructure, JSDocableNodeStructure {
}

export interface GetAccessorDeclarationStructure extends GetAccessorDeclarationSpecificStructure, PropertyNamedNodeStructure, StaticableNodeStructure, DecoratableNodeStructure, AbstractableNodeStructure, ScopedNodeStructure, FunctionLikeDeclarationStructure, BodiedNodeStructure {
}

export interface GetAccessorDeclarationSpecificStructure {
}

export interface MethodDeclarationStructure extends MethodDeclarationSpecificStructure, PropertyNamedNodeStructure, StaticableNodeStructure, DecoratableNodeStructure, AbstractableNodeStructure, ScopedNodeStructure, AsyncableNodeStructure, GeneratorableNodeStructure, FunctionLikeDeclarationStructure, BodyableNodeStructure {
}

export interface MethodDeclarationSpecificStructure {
    overloads?: MethodDeclarationOverloadStructure[];
}

export interface MethodDeclarationOverloadStructure extends StaticableNodeStructure, DecoratableNodeStructure, AbstractableNodeStructure, ScopedNodeStructure, AsyncableNodeStructure, GeneratorableNodeStructure, SignaturedDeclarationStructure, TypeParameteredNodeStructure, JSDocableNodeStructure {
}

export interface PropertyDeclarationStructure extends PropertyNamedNodeStructure, TypedNodeStructure, QuestionTokenableNodeStructure, StaticableNodeStructure, ScopedNodeStructure, JSDocableNodeStructure, ReadonlyableNodeStructure, InitializerExpressionableNodeStructure, DecoratableNodeStructure, AbstractableNodeStructure {
}

export interface SetAccessorDeclarationStructure extends SetAccessorDeclarationSpecificStructure, PropertyNamedNodeStructure, StaticableNodeStructure, DecoratableNodeStructure, AbstractableNodeStructure, ScopedNodeStructure, FunctionLikeDeclarationStructure, BodiedNodeStructure {
}

export interface SetAccessorDeclarationSpecificStructure {
}

export declare type ObjectLiteralElementLikeStructures = PropertyAssignmentStructure | ShorthandPropertyAssignmentStructure | SpreadAssignmentStructure | MethodDeclarationStructure | GetAccessorDeclarationStructure | SetAccessorDeclarationStructure;

export interface ObjectLiteralExpressionStructure {
    properties: ObjectLiteralElementLikeStructures[];
}

export interface PropertyAssignmentStructure extends PropertyNamedNodeStructure {
    initializer: string;
}

export interface ShorthandPropertyAssignmentStructure extends NamedNodeStructure {
}
export interface SpreadAssignmentStructure {
    expression: string;
}
export interface DecoratorStructure {
    name: string;
    arguments?: string[];
}
export interface JSDocStructure {
    description: string;
}

export interface EnumDeclarationStructure extends NamedNodeStructure, EnumDeclarationSpecificStructure, JSDocableNodeStructure, AmbientableNodeStructure, ExportableNodeStructure {
}

export interface EnumDeclarationSpecificStructure {
    isConst?: boolean;
    members?: EnumMemberStructure[];
}

export interface EnumMemberStructure extends EnumMemberSpecificStructure, PropertyNamedNodeStructure, JSDocableNodeStructure, InitializerExpressionableNodeStructure {
}

export interface EnumMemberSpecificStructure {
    value?: number | string;
}

export interface ExportAssignmentStructure {
    isEqualsExport?: boolean;
    expression: string | ((writer: CodeBlockWriter) => void);
}

export interface ExportDeclarationStructure {
    namedExports?: ExportSpecifierStructure[];
    moduleSpecifier?: string;
}
export interface ExportSpecifierStructure {
    name: string;
    alias?: string;
}

export interface ImportDeclarationStructure {
    defaultImport?: string;
    namespaceImport?: string;
    namedImports?: ImportSpecifierStructure[];
    moduleSpecifier: string;
}
export interface ImportSpecifierStructure {
    name: string;
    alias?: string;
}

export interface SourceFileStructure extends SourceFileSpecificStructure, StatementedNodeStructure {
}

export interface SourceFileSpecificStructure {
    imports?: ImportDeclarationStructure[];
    exports?: ExportDeclarationStructure[];
}

export interface FunctionDeclarationStructure extends FunctionDeclarationSpecificStructure, NamedNodeStructure, FunctionLikeDeclarationStructure, StatementedNodeStructure, AsyncableNodeStructure, GeneratorableNodeStructure, AmbientableNodeStructure, ExportableNodeStructure, BodyableNodeStructure {
}

export interface FunctionDeclarationSpecificStructure {
    overloads?: FunctionDeclarationOverloadStructure[];
}

export interface FunctionDeclarationOverloadStructure extends SignaturedDeclarationStructure, TypeParameteredNodeStructure, JSDocableNodeStructure, AsyncableNodeStructure, GeneratorableNodeStructure, AmbientableNodeStructure, ExportableNodeStructure {
}

export interface FunctionLikeDeclarationStructure extends SignaturedDeclarationStructure, TypeParameteredNodeStructure, JSDocableNodeStructure, StatementedNodeStructure {
}

export interface ParameterDeclarationStructure extends DeclarationNamedNodeStructure, TypedNodeStructure, ReadonlyableNodeStructure, DecoratableNodeStructure, QuestionTokenableNodeStructure, ScopeableNodeStructure, InitializerExpressionableNodeStructure, ParameterDeclarationSpecificStructure {
}

export interface ParameterDeclarationSpecificStructure {
    isRestParameter?: boolean;
}

export interface CallSignatureDeclarationStructure extends JSDocableNodeStructure, SignaturedDeclarationStructure, TypeParameteredNodeStructure {
}

export interface ConstructSignatureDeclarationStructure extends JSDocableNodeStructure, SignaturedDeclarationStructure, TypeParameteredNodeStructure {
}

export interface IndexSignatureDeclarationStructure extends JSDocableNodeStructure, ReadonlyableNodeStructure {
    keyName?: string;
    keyType?: string;
    returnType: string;
}

export interface InterfaceDeclarationStructure extends NamedNodeStructure, InterfaceDeclarationSpecificStructure, ExtendsClauseableNodeStructure, TypeParameteredNodeStructure, JSDocableNodeStructure, AmbientableNodeStructure, ExportableNodeStructure {
}

export interface InterfaceDeclarationSpecificStructure {
    callSignatures?: CallSignatureDeclarationStructure[];
    constructSignatures?: ConstructSignatureDeclarationStructure[];
    indexSignatures?: IndexSignatureDeclarationStructure[];
    methods?: MethodSignatureStructure[];
    properties?: PropertySignatureStructure[];
}

export interface MethodSignatureStructure extends PropertyNamedNodeStructure, QuestionTokenableNodeStructure, JSDocableNodeStructure, SignaturedDeclarationStructure, TypeParameteredNodeStructure {
}

export interface PropertySignatureStructure extends PropertyNamedNodeStructure, TypedNodeStructure, QuestionTokenableNodeStructure, JSDocableNodeStructure, ReadonlyableNodeStructure, InitializerExpressionableNodeStructure {
}

export interface NamespaceDeclarationStructure extends NamedNodeStructure, NamespaceDeclarationSpecificStructure, JSDocableNodeStructure, AmbientableNodeStructure, ExportableNodeStructure, StatementedNodeStructure, BodiedNodeStructure {
}

export interface NamespaceDeclarationSpecificStructure {
    /**
     * If the namespace has the module keyword.
     */
    hasModuleKeyword?: boolean;
}

export interface StatementedNodeStructure {
    classes?: ClassDeclarationStructure[];
    enums?: EnumDeclarationStructure[];
    functions?: FunctionDeclarationStructure[];
    interfaces?: InterfaceDeclarationStructure[];
    namespaces?: NamespaceDeclarationStructure[];
    typeAliases?: TypeAliasDeclarationStructure[];
}

export interface VariableDeclarationListStructure extends VariableDeclarationListSpecificStructure {
}

export interface VariableDeclarationListSpecificStructure {
    declarationType?: VariableDeclarationType;
    declarations: VariableDeclarationStructure[];
}

export interface VariableDeclarationStructure extends BindingNamedNodeStructure, InitializerExpressionableNodeStructure, TypedNodeStructure {
}

export interface VariableStatementStructure extends VariableStatementSpecificStructure, JSDocableNodeStructure, AmbientableNodeStructure, ExportableNodeStructure {
}

export interface VariableStatementSpecificStructure {
    declarationType?: VariableDeclarationType;
    declarations: VariableDeclarationStructure[];
}

export interface TypeAliasDeclarationStructure extends NamedNodeStructure, TypedNodeStructure, TypeParameteredNodeStructure, JSDocableNodeStructure, AmbientableNodeStructure, ExportableNodeStructure {
    type: string;
}

export interface TypeParameterDeclarationStructure extends NamedNodeStructure {
    constraint?: string;
}

/** Kinds of indentation */
export declare enum IndentationText {
    /** Two spaces */
    TwoSpaces = "  ",
    /** Four spaces */
    FourSpaces = "    ",
    /** Eight spaces */
    EightSpaces = "        ",
    /** Tab */
    Tab = "\t",
}

/**
 * Manipulation settings.
 */
export interface ManipulationSettings {
    /** Indentation text */
    indentationText: IndentationText;
    /** New line kind */
    newLineKind: NewLineKind;
    /** Script target. */
    scriptTarget: ScriptTarget;
    /** Quote type used for string literals. */
    quoteType: QuoteType;
}

/**
 * Holds the manipulation settings.
 */
export declare class ManipulationSettingsContainer {
    private readonly settings;
    /**
     * Gets the quote type used for string literals.
     */
    getQuoteType(): QuoteType;
    /**
     * Gets the new line kind.
     */
    getNewLineKind(): NewLineKind;
    /**
     * Gets the new line kind as a string.
     */
    getNewLineKindAsString(): "\r\n" | "\n";
    /**
     * Gets the indentation text;
     */
    getIndentationText(): IndentationText;
    /**
     * Gets the script target.
     */
    getScriptTarget(): ScriptTarget;
    /**
     * Gets a copy of the manipulations settings as an object.
     */
    get(): ManipulationSettings;
    /**
     * Sets one or all of the settings.
     * @param settings - Settings to set.
     */
    set(settings: Partial<ManipulationSettings>): void;
}