Genese complexity report

<- ts-morph.d.ts
Methods : 1681
Complexity index : 876.6
Cyclomatic complexity : 1638
Cognitive complexity
100 % Correct 1681/1681
0 % Warning 0/1681 (threshold : 10)
0 % Error 0/1681 (threshold : 20)
Cyclomatic complexity
100 % Correct 1681/1681
0 % Warning 0/1681 (threshold : 5)
0 % Error 0/1681 (threshold : 10)
Methods of ts-morph.d.ts
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                constructor();
            
                            
                        
set Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets one or all of the compiler options.
                 *
                 * WARNING: Setting the compiler options will cause a complete reparse of all the source files.
                 * @param settings - Compiler options to set.
                 */
                set(settings: Partial<ts.CompilerOptions>): void; // ----------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getEncoding Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the encoding from the compiler options or returns utf-8. */
                getEncoding(): string; // ----------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Constructor.
                 * @param defaultSettings - The settings to use by default.
                 */
                constructor(defaultSettings: T); // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
reset Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Resets the settings to the default. */
                reset(): void; // ----------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
get Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets a copy of the settings as an object. */
                get(): T; // ---------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets one or all of the settings.
                 * @param settings - Settings to set.
                 */
                set(settings: Partial<T>): void; // ------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
onModified Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Subscribe to modifications in the settings container.
                 * @param action - Action to execute when the settings change.
                 */
                onModified(action: () => void): void; // -------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
            
                /**
                 * Constructor.
                 * @param options - Options for creating the file system.
                 */
                constructor(options?: InMemoryFileSystemHostOptions); // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isCaseSensitive Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                isCaseSensitive(): boolean; // --------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
delete Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                delete(path: string): Promise<void>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
deleteSync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                deleteSync(path: string): void; // ------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
readDirSync Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                readDirSync(dirPath: string): string[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
readFile Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                readFile(filePath: string, encoding?: string): Promise<string>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
readFileSync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                readFileSync(filePath: string, encoding?: string): string; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
writeFile Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                writeFile(filePath: string, fileText: string): Promise<void>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
writeFileSync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                writeFileSync(filePath: string, fileText: string): void; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
mkdir Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                mkdir(dirPath: string): Promise<void>; // ------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
mkdirSync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                mkdirSync(dirPath: string): void; // ------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
move Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                move(srcPath: string, destPath: string): Promise<void>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
moveSync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                moveSync(srcPath: string, destPath: string): void; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
copy Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                copy(srcPath: string, destPath: string): Promise<void>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
copySync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                copySync(srcPath: string, destPath: string): void; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
fileExists Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                fileExists(filePath: string): Promise<boolean>; // ---------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
fileExistsSync Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                fileExistsSync(filePath: string): boolean; // ------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
directoryExists Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                directoryExists(dirPath: string): Promise<boolean>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
directoryExistsSync Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                directoryExistsSync(dirPath: string): boolean; // ------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
realpathSync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                realpathSync(path: string): string; // ------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getCurrentDirectory Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                getCurrentDirectory(): string; // ------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
glob Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                glob(patterns: ReadonlyArray<string>): Promise<string[]>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
globSync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                globSync(patterns: ReadonlyArray<string>): string[]; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                
                private constructor();
            
                            
                        
isAncestorOf Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // -------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isDescendantOf Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ----------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getPath Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the path to the directory. */
                getPath(): StandardizedFilePath; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getBaseName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the directory path's base name. */
                getBaseName(): string; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent directory or throws if it doesn't exist or was never added to the project. */
                getParentOrThrow(): Directory; // -------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent directory if it exists and was added to the project. */
                getParent(): Directory | undefined; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDirectoryOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getDirectoryOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDirectory Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ---------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDirectory Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getSourceFileOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getSourceFileOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getSourceFile Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getSourceFile Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getDirectories Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the child directories. */
                getDirectories(): Directory[]; // --------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source files within this directory. */
                getSourceFiles(): SourceFile[]; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSourceFiles Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets all the source files added to the project relative to the directory that match a pattern.
                 * @param globPattern - Glob pattern for filtering out the source files.
                 */
                getSourceFiles(globPattern: string): SourceFile[]; // ------------------------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getSourceFiles Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets all the source files added to the project relative to the directory that match the provided patterns.
                 * @param globPatterns - Glob patterns for filtering out the source files.
                 */
                getSourceFiles(globPatterns: ReadonlyArray<string>): SourceFile[]; // -------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getDescendantSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source files in the current directory and all the descendant directories. */
                getDescendantSourceFiles(): SourceFile[]; // ------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDescendantDirectories Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the descendant directories. */
                getDescendantDirectories(): Directory[]; // -------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
addSourceFilesAtPaths Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Add source files based on file globs.
                 * @param fileGlobs - File glob or globs to add files based on.
                 * @returns The matched source files.
                 */
                addSourceFilesAtPaths(fileGlobs: string | ReadonlyArray<string>): SourceFile[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addDirectoryAtPathIfExists Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds an existing directory 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 relativeOrAbsoluteDirPath - Directory name or path to the directory that should be added.
                 * @param options - Options.
                 */
                addDirectoryAtPathIfExists(relativeOrAbsoluteDirPath: string, options?: DirectoryAddOptions): Directory | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
addDirectoryAtPath Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds an existing directory from the relative path or directory name, or throws if it doesn't exist.
                 *
                 * Will return the directory if it was already added.
                 * @param relativeOrAbsoluteDirPath - Directory name or path to the directory that should be added.
                 * @throws DirectoryNotFoundError if the directory does not exist.
                 */
                addDirectoryAtPath(relativeOrAbsoluteDirPath: string, options?: DirectoryAddOptions): Directory; // --------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
createDirectory Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a directory if it doesn't exist.
                 * @param relativeOrAbsoluteDirPath - Relative or absolute path to the directory that should be created.
                 */
                createDirectory(relativeOrAbsoluteDirPath: string): Directory; // ------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
createSourceFile Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a source file, 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, structure, or writer function to create the source file text with.
                 * @param options - Options.
                 * @throws - InvalidOperationError if a source file already exists at the provided file name.
                 */
                createSourceFile(relativeFilePath: string, sourceFileText?: string | OptionalKind<SourceFileStructure> | WriterFunction, options?: SourceFileCreateOptions): SourceFile; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
addSourceFileAtPathIfExists Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds an existing source file, relative to this directory, or returns undefined.
                 *
                 * Will return the source file if it was already added.
                 * @param relativeFilePath - Relative file path to add.
                 */
                addSourceFileAtPathIfExists(relativeFilePath: string): SourceFile | undefined; // ------------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addSourceFileAtPath Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds an existing source file, 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.
                 */
                addSourceFileAtPath(relativeFilePath: string): SourceFile; // ---------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
emit Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Emits the files in the directory.
                 * @param options - Options for emitting.
                 */
                emit(options?: { // ------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        emitOnlyDtsFiles?: boolean; // ------------------------------ +0.1 Complexity index (+0.1 atomic)
                        outDir?: string; // ----------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        declarationDir?: string; // --------------------------------- +0.2 Complexity index (+0.2 atomic)
                    }): Promise<DirectoryEmitResult>; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
emitSync Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * 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?: { // ---------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        emitOnlyDtsFiles?: boolean; // ------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                        outDir?: string; // ------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                        declarationDir?: string; // ---------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    }): DirectoryEmitResult; // -------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
copyToDirectory Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Copies the directory to a subdirectory of the specified directory.
                 * @param dirPathOrDirectory Directory path or directory object to copy the directory to.
                 * @param options Options for copying.
                 * @returns The new copied directory.
                 */
                copyToDirectory(dirPathOrDirectory: string | Directory, options?: DirectoryCopyOptions): Directory; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
copy Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Copies the 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?: DirectoryCopyOptions): Directory; // -------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
copyImmediately Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Immediately copies the directory to the specified path asynchronously.
                 * @param relativeOrAbsolutePath - Directory path as an absolute or relative path.
                 * @param options - Options for moving the directory.
                 * @remarks If includeTrackedFiles is true, then it will execute the pending operations in the current directory.
                 */
                copyImmediately(relativeOrAbsolutePath: string, options?: DirectoryCopyOptions): Promise<Directory>; // -------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
copyImmediatelySync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Immediately copies the directory to the specified path synchronously.
                 * @param relativeOrAbsolutePath - Directory path as an absolute or relative path.
                 * @param options - Options for moving the directory.
                 * @remarks If includeTrackedFiles is true, then it will execute the pending operations in the current directory.
                 */
                copyImmediatelySync(relativeOrAbsolutePath: string, options?: DirectoryCopyOptions): Directory; // ------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
moveToDirectory Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Moves the directory to a subdirectory of the specified directory.
                 * @param dirPathOrDirectory Directory path or directory object to move the directory to.
                 * @param options Options for moving.
                 */
                moveToDirectory(dirPathOrDirectory: string | Directory, options?: DirectoryMoveOptions): this; // -------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
move Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Moves the directory to a new path.
                 * @param relativeOrAbsolutePath - Directory path as an absolute or relative path.
                 * @param options - Options for moving the directory.
                 */
                move(relativeOrAbsolutePath: string, options?: DirectoryMoveOptions): this; // -------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
moveImmediately Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Immediately moves the directory to a new path asynchronously.
                 * @param relativeOrAbsolutePath - Directory path as an absolute or relative path.
                 * @param options - Options for moving the directory.
                 */
                moveImmediately(relativeOrAbsolutePath: string, options?: DirectoryMoveOptions): Promise<this>; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
moveImmediatelySync Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Immediately moves the directory to a new path synchronously.
                 * @param relativeOrAbsolutePath - Directory path as an absolute or relative path.
                 * @param options - Options for moving the directory.
                 */
                moveImmediatelySync(relativeOrAbsolutePath: string, options?: DirectoryMoveOptions): this; // ------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
clear Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Recreates the directory.
                 * @remarks This will delete all the descendant source files and directories in memory and queue a delete & mkdir to the file system.
                 */
                clear(): void; // ------------------------------------------------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
clearImmediately Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Asynchronously recreates the directory.
                 * @remarks This will delete all the descendant source files and directories in memory and push a delete & mkdir to the file system.
                 */
                clearImmediately(): Promise<void>; // --------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
clearImmediatelySync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Synchronously recreates the directory.
                 * @remarks This will delete all the descendant source files and directories in memory and push a delete & mkdir to the file system.
                 */
                clearImmediatelySync(): void; // -------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
delete Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Queues a deletion of the directory to the file system.
                 *
                 * The directory will be deleted when calling ast.save(). If you wish to delete the file immediately, then use deleteImmediately().
                 */
                delete(): void; // --------------------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
deleteImmediately Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Asyncronously deletes the directory and all its descendants from the file system. */
                deleteImmediately(): Promise<void>; // ------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
deleteImmediatelySync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Synchronously deletes the directory and all its descendants from the file system. */
                deleteImmediatelySync(): void; // ----------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
forget Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Forgets the directory and all its descendants from the Project.
                 *
                 * Note: Does not delete the directory from the file system.
                 */
                forget(): void; // ---------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
save Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Asynchronously saves the directory and all the unsaved source files to the disk. */
                save(): Promise<void>; // ------------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
saveSync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Synchronously saves the directory and all the unsaved source files to the disk. */
                saveSync(): void; // ---------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getRelativePathTo Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path to another source file.
                 * @param sourceFile - Source file.
                 */
                getRelativePathTo(sourceFile: SourceFile): string; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getRelativePathTo Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path to another directory.
                 * @param directory - Directory.
                 */
                getRelativePathTo(directory: Directory): string; // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getRelativePathAsModuleSpecifierTo Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path to the specified source file as a module specifier.
                 * @param sourceFile - Source file.
                 */
                getRelativePathAsModuleSpecifierTo(sourceFile: SourceFile): string; // ----------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getRelativePathAsModuleSpecifierTo Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path to the specified directory as a module specifier.
                 * @param directory - Directory.
                 */
                getRelativePathAsModuleSpecifierTo(directory: Directory): string; // ----------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
wasForgotten Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the directory was forgotten. */
                wasForgotten(): boolean; // ------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                
                private constructor();
            
                            
                        
getSkippedFilePaths Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets a collections of skipped file paths. */
                getSkippedFilePaths(): StandardizedFilePath[]; // --------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getOutputFilePaths Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the output file paths. */
                getOutputFilePaths(): StandardizedFilePath[]; // -------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
            
                /**
                 * Initializes a new instance.
                 * @param options - Optional options.
                 */
                constructor(options?: ProjectOptions); // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
resolveSourceFileDependencies Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds the source files the project's source files depend on to the project.
                 * @returns The added source files.
                 * @remarks * This should be done after source files are added to the project, preferably once to
                 * avoid doing more work than necessary.
                 * * This is done by default when creating a Project and providing a tsconfig.json and
                 * not specifying to not add the source files.
                 */
                resolveSourceFileDependencies(): SourceFile[]; // ---------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
addDirectoryAtPathIfExists Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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.
                 * @param options - Options.
                 */
                addDirectoryAtPathIfExists(dirPath: string, options?: DirectoryAddOptions): Directory | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
addDirectoryAtPath Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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.
                 * @param options - Options.
                 * @throws DirectoryNotFoundError when the directory does not exist.
                 */
                addDirectoryAtPath(dirPath: string, options?: DirectoryAddOptions): Directory; // --------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
createDirectory Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a directory at the specified path.
                 * @param dirPath - Path to create the directory at.
                 */
                createDirectory(dirPath: string): Directory; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getDirectoryOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a directory by the specified path or throws if it doesn't exist.
                 * @param dirPath - Path to create the directory at.
                 */
                getDirectoryOrThrow(dirPath: string): Directory; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getDirectory Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a directory by the specified path or returns undefined if it doesn't exist.
                 * @param dirPath - Directory path.
                 */
                getDirectory(dirPath: string): Directory | undefined; // ------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDirectories Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets all the directories. */
                getDirectories(): Directory[]; // ------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getRootDirectories Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the directories without a parent. */
                getRootDirectories(): Directory[]; // ------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
addSourceFilesAtPaths Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds source files based on file globs.
                 * @param fileGlobs - File glob or globs to add files based on.
                 * @returns The matched source files.
                 */
                addSourceFilesAtPaths(fileGlobs: string | ReadonlyArray<string>): SourceFile[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addSourceFileAtPathIfExists Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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.
                 */
                addSourceFileAtPathIfExists(filePath: string): SourceFile | undefined; // ---------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addSourceFileAtPath Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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.
                 */
                addSourceFileAtPath(filePath: string): SourceFile; // ------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
addSourceFilesFromTsConfig Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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[]; // ---------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
createSourceFile Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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, structure, or writer function for the source file text.
                 * @param options - Options.
                 * @throws - InvalidOperationError if a source file already exists at the provided file path.
                 */
                createSourceFile(filePath: string, sourceFileText?: string | OptionalKind<SourceFileStructure> | WriterFunction, options?: SourceFileCreateOptions): SourceFile; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
removeSourceFile Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes a source file from the project.
                 * @param sourceFile - Source file to remove.
                 * @returns True if removed.
                 */
                removeSourceFile(sourceFile: SourceFile): boolean; // --------------------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSourceFileOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getSourceFileOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a source file by a search function. Throws an error if it doesn't exist.
                 * @param searchFunction - Search function.
                 */
                getSourceFileOrThrow(searchFunction: (file: SourceFile) => boolean): SourceFile; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getSourceFile Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ----------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getSourceFile Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a source file by a search function. Returns undefined if none exists.
                 * @param searchFunction - Search function.
                 */
                getSourceFile(searchFunction: (file: SourceFile) => boolean): SourceFile | undefined; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets all the source files added to the project. */
                getSourceFiles(): SourceFile[]; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSourceFiles Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets all the source files added to the project that match a pattern.
                 * @param globPattern - Glob pattern for filtering out the source files.
                 */
                getSourceFiles(globPattern: string): SourceFile[]; // ----------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getSourceFiles Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets all the source files added to the project that match the passed in patterns.
                 * @param globPatterns - Glob patterns for filtering out the source files.
                 */
                getSourceFiles(globPatterns: ReadonlyArray<string>): SourceFile[]; // ------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getAmbientModule Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the specified ambient module symbol or returns undefined if not found.
                 * @param moduleName - The ambient module name with or without quotes.
                 */
                getAmbientModule(moduleName: string): Symbol | undefined; // ---------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getAmbientModuleOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the specified ambient module symbol or throws if not found.
                 * @param moduleName - The ambient module name with or without quotes.
                 */
                getAmbientModuleOrThrow(moduleName: string): Symbol; // ------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getAmbientModules Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the ambient module symbols (ex. modules in the @types folder or node_modules). */
                getAmbientModules(): Symbol[]; // ------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
save Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Saves all the unsaved source files to the file system and deletes all deleted files. */
                save(): Promise<void>; // ---------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
saveSync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Synchronously saves all the unsaved source files to the file system and deletes all deleted files.
                 *
                 * Remarks: This might be very slow compared to the asynchronous version if there are a lot of files.
                 */
                saveSync(): void; // ------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
enableLogging Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Enables logging to the console.
                 * @param enabled - Enabled.
                 */
                enableLogging(enabled?: boolean): void; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getPreEmitDiagnostics Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the pre-emit diagnostics. */
                getPreEmitDiagnostics(): Diagnostic[]; // -------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getLanguageService Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the language service. */
                getLanguageService(): LanguageService; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getProgram Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the program. */
                getProgram(): Program; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getTypeChecker Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the type checker. */
                getTypeChecker(): TypeChecker; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFileSystem Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file system. */
                getFileSystem(): FileSystemHost; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
emit Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Asynchronously emits all the source files to the file system as JavaScript files.
                 * @param emitOptions - Optional emit options.
                 */
                emit(emitOptions?: EmitOptions): Promise<EmitResult>; // -------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
emitSync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Synchronously emits all the source files to the file system as JavaScript files.
                 * @param emitOptions - Optional emit options.
                 */
                emitSync(emitOptions?: EmitOptions): EmitResult; // ------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
emitToMemory Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Emits all the source files to memory.
                 * @param emitOptions - Optional emit options.
                 */
                emitToMemory(emitOptions?: EmitOptions): MemoryEmitResult; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getCompilerOptions Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the compiler options. */
                getCompilerOptions(): CompilerOptions; // --------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getConfigFileParsingDiagnostics Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the diagnostics found when parsing the tsconfig.json file provided in the project's constructor. */
                getConfigFileParsingDiagnostics(): Diagnostic[]; // ------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
createWriter Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates a writer with the current manipulation settings.
                 * @remarks Generally it's best to use a provided writer, but this may be useful in some scenarios.
                 */
                createWriter(): CodeBlockWriter; // -------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
forgetNodesCreatedInBlock Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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. Use the `remember` callback or return a node to remember it.
                 */
                forgetNodesCreatedInBlock<T = void>(block: (remember: (...node: Node[]) => void) => T): T; // ----------------------------------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
forgetNodesCreatedInBlock Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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. Use the `remember` callback or return a node to remember it.
                 */
                forgetNodesCreatedInBlock<T = void>(block: (remember: (...node: Node[]) => void) => Promise<T>): Promise<T>; // ----------------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
formatDiagnosticsWithColorAndContext Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Formats an array of diagnostics with their color and context into a string.
                 * @param diagnostics - Diagnostics to get a string of.
                 * @param options - Collection of options. For example, the new line character to use (defaults to the OS' new line character).
                 */
                formatDiagnosticsWithColorAndContext(diagnostics: ReadonlyArray<Diagnostic>, opts?: { // ------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
                        newLineChar?: "\n" | "\r\n"; // -------------------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
                    }): string; // ----------------------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getModuleResolutionHost Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                /** Gets a ts.ModuleResolutionHost for the project. */
                getModuleResolutionHost(): ts.ModuleResolutionHost; // ---------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
createWrappedNode Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
            
            /**
             * 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): CompilerNodeToWrappedType<T>; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
printNode Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Prints the provided node using the compiler's printer.
             * @param node - Compiler node.
             * @param options - Options.
             * @remarks If the node was not constructed with the compiler API factory methods and the node
             * does not have parents set, then use the other overload that accepts a source file.
             */
            export declare function printNode(node: ts.Node, options?: PrintNodeOptions): string; // ---------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
printNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
            
            /**
             * 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; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getCompilerOptionsFromTsConfig Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Gets the compiler options from a specified tsconfig.json
             * @param filePath - File path to the tsconfig.json.
             * @param options - Options.
             */
            export declare function getCompilerOptionsFromTsConfig(filePath: string, options?: CompilerOptionsFromTsConfigOptions): CompilerOptionsFromTsConfigResult; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
Complexity Index 0.8 Cyclomatic complexity 0
                            
                                
                
                constructor(filePath: string, oldText: string, newText: string, errorMessage: string); // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
object Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a writer function for writing the provided object as an object literal expression.
                 * @param obj - Object to write.
                 */
                static object(obj: { // ----------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        [key: string]: WriterFunctionOrValue | undefined; // ---------------------------------------- +0.4 Complexity index (+0.4 atomic)
                    }): WriterFunction; // -------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
objectType Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                    
                /** Gets a writer function for writing an object type. */
                static objectType(structure: TypeElementMemberedNodeStructure): WriterFunction; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
unionType Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets a writer function for writing a union type (ex. `FirstType | SecondType`). */
                static unionType(firstType: WriterFunctionOrValue, secondType: WriterFunctionOrValue, ...additionalTypes: WriterFunctionOrValue[]): (writer: CodeBlockWriter) => void; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
intersectionType Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets a writer function for writing an intersection type (ex. `FirstType & SecondType`). */
                static intersectionType(firstType: WriterFunctionOrValue, secondType: WriterFunctionOrValue, ...additionalTypes: WriterFunctionOrValue[]): (writer: CodeBlockWriter) => void; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
assertion Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /** Gets a writer function for writing a type assertion (ex. `type as assertionType`). */
                static assertion(type: WriterFunctionOrValue, assertionType: WriterFunctionOrValue): (writer: CodeBlockWriter) => void; // ------------------------------------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
returnStatement Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a writer function for writing a return statement returning the provided value (ex. `return value;`).
                 * @param value - Value to be returned.
                 */
                static returnStatement(value: WriterFunctionOrValue): WriterFunction; // --------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
AmbientableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function AmbientableNode<T extends Constructor<AmbientableNodeExtensionType>>(Base: T): Constructor<AmbientableNode> & T; // --------------------------------------------------------------------------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ArgumentedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ArgumentedNode<T extends Constructor<ArgumentedNodeExtensionType>>(Base: T): Constructor<ArgumentedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
AsyncableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function AsyncableNode<T extends Constructor<AsyncableNodeExtensionType>>(Base: T): Constructor<AsyncableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
AwaitableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function AwaitableNode<T extends Constructor<AwaitableNodeExtensionType>>(Base: T): Constructor<AwaitableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
BodiedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function BodiedNode<T extends Constructor<BodiedNodeExtensionType>>(Base: T): Constructor<BodiedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
BodyableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function BodyableNode<T extends Constructor<BodyableNodeExtensionType>>(Base: T): Constructor<BodyableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ChildOrderableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function ChildOrderableNode<T extends Constructor<ChildOrderableNodeExtensionType>>(Base: T): Constructor<ChildOrderableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
DecoratableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function DecoratableNode<T extends Constructor<DecoratableNodeExtensionType>>(Base: T): Constructor<DecoratableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
DotDotDotTokenableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function DotDotDotTokenableNode<T extends Constructor<DotDotDotTokenableNodeExtensionType>>(Base: T): Constructor<DotDotDotTokenableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ExclamationTokenableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function ExclamationTokenableNode<T extends Constructor<ExclamationTokenableNodeExtensionType>>(Base: T): Constructor<ExclamationTokenableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ExportableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function ExportableNode<T extends Constructor<ExportableNodeExtensionType>>(Base: T): Constructor<ExportableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ExportGetableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ExportGetableNode<T extends Constructor<ExportGetableNodeExtensionType>>(Base: T): Constructor<ExportGetableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ExtendsClauseableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ExtendsClauseableNode<T extends Constructor<ExtendsClauseableNodeExtensionType>>(Base: T): Constructor<ExtendsClauseableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
GeneratorableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function GeneratorableNode<T extends Constructor<GeneratorableNodeExtensionType>>(Base: T): Constructor<GeneratorableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
HeritageClauseableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function HeritageClauseableNode<T extends Constructor<HeritageClauseableNodeExtensionType>>(Base: T): Constructor<HeritageClauseableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ImplementsClauseableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function ImplementsClauseableNode<T extends Constructor<ImplementsClauseableNodeExtensionType>>(Base: T): Constructor<ImplementsClauseableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
InitializerExpressionableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function InitializerExpressionableNode<T extends Constructor<InitializerExpressionableNodeExtensionType>>(Base: T): Constructor<InitializerExpressionableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
InitializerExpressionGetableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function InitializerExpressionGetableNode<T extends Constructor<InitializerExpressionGetableNodeExtensionType>>(Base: T): Constructor<InitializerExpressionGetableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
JSDocableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function JSDocableNode<T extends Constructor<JSDocableNodeExtensionType>>(Base: T): Constructor<JSDocableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
LiteralLikeNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function LiteralLikeNode<T extends Constructor<LiteralLikeNodeExtensionType>>(Base: T): Constructor<LiteralLikeNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ModifierableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ModifierableNode<T extends Constructor<ModifierableNodeExtensionType>>(Base: T): Constructor<ModifierableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ModuledNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ModuledNode<T extends Constructor<ModuledNodeExtensionType>>(Base: T): Constructor<ModuledNode> & T; // ---------------------------------------------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
BindingNamedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function BindingNamedNode<T extends Constructor<BindingNamedNodeExtensionType>>(Base: T): Constructor<BindingNamedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
NameableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function NameableNode<T extends Constructor<NameableNodeExtensionType>>(Base: T): Constructor<NameableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
NamedNodeBase Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
            
            
            export declare function NamedNodeBase<TCompilerNode extends ts.Node, U extends Constructor<NamedNodeBaseExtensionType<TCompilerNode>>>(Base: U): Constructor<NamedNodeSpecificBase<CompilerNodeToWrappedType<TCompilerNode>>> & U; // ------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
NamedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function NamedNode<T extends Constructor<NamedNodeExtensionType>>(Base: T): Constructor<NamedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
PropertyNamedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function PropertyNamedNode<T extends Constructor<PropertyNamedNodeExtensionType>>(Base: T): Constructor<PropertyNamedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ReferenceFindableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ReferenceFindableNode<T extends Constructor<ReferenceFindableNodeExtensionType>>(Base: T): Constructor<ReferenceFindableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
RenameableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function RenameableNode<T extends Constructor<RenameableNodeExtensionType>>(Base: T): Constructor<RenameableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ParameteredNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ParameteredNode<T extends Constructor<ParameteredNodeExtensionType>>(Base: T): Constructor<ParameteredNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
QuestionDotTokenableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function QuestionDotTokenableNode<T extends Constructor<QuestionDotTokenableNodeExtensionType>>(Base: T): Constructor<QuestionDotTokenableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
QuestionTokenableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function QuestionTokenableNode<T extends Constructor<QuestionTokenableNodeExtensionType>>(Base: T): Constructor<QuestionTokenableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ReadonlyableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function ReadonlyableNode<T extends Constructor<ReadonlyableNodeExtensionType>>(Base: T): Constructor<ReadonlyableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ReturnTypedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ReturnTypedNode<T extends Constructor<ReturnTypedNodeExtensionType>>(Base: T): Constructor<ReturnTypedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ScopeableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ScopeableNode<T extends Constructor<ScopeableNodeExtensionType>>(Base: T): Constructor<ScopeableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ScopedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ScopedNode<T extends Constructor<ScopedNodeExtensionType>>(Base: T): Constructor<ScopedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
SignaturedDeclaration Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function SignaturedDeclaration<T extends Constructor<SignaturedDeclarationExtensionType>>(Base: T): Constructor<SignaturedDeclaration> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
StaticableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function StaticableNode<T extends Constructor<StaticableNodeExtensionType>>(Base: T): Constructor<StaticableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
TextInsertableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function TextInsertableNode<T extends Constructor<TextInsertableNodeExtensionType>>(Base: T): Constructor<TextInsertableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
TypeArgumentedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function TypeArgumentedNode<T extends Constructor<TypeArgumentedNodeExtensionType>>(Base: T): Constructor<TypeArgumentedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
TypedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function TypedNode<T extends Constructor<TypedNodeExtensionType>>(Base: T): Constructor<TypedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
TypeElementMemberedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function TypeElementMemberedNode<T extends Constructor<TypeElementMemberedNodeExtensionType>>(Base: T): Constructor<TypeElementMemberedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
TypeParameteredNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function TypeParameteredNode<T extends Constructor<TypeParameteredNodeExtensionType>>(Base: T): Constructor<TypeParameteredNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
UnwrappableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function UnwrappableNode<T extends Constructor<UnwrappableNodeExtensionType>>(Base: T): Constructor<UnwrappableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
getElements Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
                /** Gets the array binding pattern's elements. */
                getElements(): (BindingElement | OmittedExpression)[]; // ---------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ArrayBindingPattern>; // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ArrayBindingPattern>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getPropertyNameNodeOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets binding element's property name node or throws if not found.
                 *
                 * For example in `const { a: b } = { a: 5 }`, `a` would be the property name.
                 */
                getPropertyNameNodeOrThrow(): PropertyName; // ------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getPropertyNameNode Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets binding element's property name node or returns undefined if not found.
                 *
                 * For example in `const { a: b } = { a: 5 }`, `a` would be the property name.
                 */
                getPropertyNameNode(): Identifier | NumericLiteral | StringLiteral | PrivateIdentifier | ComputedPropertyName | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.BindingElement>; // ---------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.BindingElement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getElements Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the object binding pattern's elements. */
                getElements(): BindingElement[]; // ---------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ObjectBindingPattern>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ObjectBindingPattern>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
AbstractableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function AbstractableNode<T extends Constructor<AbstractableNodeExtensionType>>(Base: T): Constructor<AbstractableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ClassLikeDeclarationBase Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function ClassLikeDeclarationBase<T extends Constructor<ClassLikeDeclarationBaseExtensionType>>(Base: T): Constructor<ClassLikeDeclarationBase> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ClassLikeDeclarationBaseSpecific Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            declare function ClassLikeDeclarationBaseSpecific<T extends Constructor<ClassLikeDeclarationBaseSpecificExtensionType>>(Base: T): Constructor<ClassLikeDeclarationBaseSpecific> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ClassDeclarationStructure>): this; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ClassDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
extractInterface Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Extracts an interface declaration structure from the class.
                 * @param name - Name of the interface. Falls back to the same name as the class and then the filepath's base name.
                 */
                extractInterface(name?: string): InterfaceDeclarationStructure; // ----------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
extractStaticInterface Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Extracts an interface declaration structure from the static part of the class.
                 * @param name - Name of the interface.
                 */
                extractStaticInterface(name: string): InterfaceDeclarationStructure; // -------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ClassDeclaration>; // -------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ClassDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes the class member. */
                remove(): void; // ------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ClassExpression>; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ClassExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ConstructorDeclarationStructure>): this; // ----------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
addOverload Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Add a constructor overload.
                 * @param structure - Structure to add.
                 */
                addOverload(structure: OptionalKind<ConstructorDeclarationOverloadStructure>): ConstructorDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addOverloads Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Add constructor overloads.
                 * @param structures - Structures to add.
                 */
                addOverloads(structures: ReadonlyArray<OptionalKind<ConstructorDeclarationOverloadStructure>>): ConstructorDeclaration[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertOverload Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a constructor overload.
                 * @param index - Child index to insert at.
                 * @param structure - Structures to insert.
                 */
                insertOverload(index: number, structure: OptionalKind<ConstructorDeclarationOverloadStructure>): ConstructorDeclaration; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertOverloads Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts constructor overloads.
                 * @param index - Child index to insert at.
                 * @param structures - Structures to insert.
                 */
                insertOverloads(index: number, structures: ReadonlyArray<OptionalKind<ConstructorDeclarationOverloadStructure>>): ConstructorDeclaration[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getStructure Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ConstructorDeclarationStructure | ConstructorDeclarationOverloadStructure; // -------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ConstructorDeclaration>; // ------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ConstructorDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<GetAccessorDeclarationStructure>): this; // ----------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getSetAccessor Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the corresponding set accessor if one exists. */
                getSetAccessor(): SetAccessorDeclaration | undefined; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSetAccessorOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the corresponding set accessor or throws if not exists. */
                getSetAccessorOrThrow(): SetAccessorDeclaration; // -------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): GetAccessorDeclarationStructure; // --------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.GetAccessorDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.GetAccessorDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<MethodDeclarationStructure>): this; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
addOverload Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Add a method overload.
                 * @param structure - Structure to add.
                 */
                addOverload(structure: OptionalKind<MethodDeclarationOverloadStructure>): MethodDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addOverloads Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Add method overloads.
                 * @param structures - Structures to add.
                 */
                addOverloads(structures: ReadonlyArray<OptionalKind<MethodDeclarationOverloadStructure>>): MethodDeclaration[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertOverload Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a method overload.
                 * @param index - Child index to insert at.
                 * @param structure - Structures to insert.
                 */
                insertOverload(index: number, structure: OptionalKind<MethodDeclarationOverloadStructure>): MethodDeclaration; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertOverloads Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts method overloads.
                 * @param index - Child index to insert at.
                 * @param structures - Structures to insert.
                 */
                insertOverloads(index: number, structures: ReadonlyArray<OptionalKind<MethodDeclarationOverloadStructure>>): MethodDeclaration[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getStructure Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): MethodDeclarationStructure | MethodDeclarationOverloadStructure; // -------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.MethodDeclaration>; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.MethodDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<PropertyDeclarationStructure>): this; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes the property. */
                remove(): void; // ---------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): PropertyDeclarationStructure; // ------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.PropertyDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.PropertyDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<SetAccessorDeclarationStructure>): this; // ----------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getGetAccessor Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the corresponding get accessor if one exists. */
                getGetAccessor(): GetAccessorDeclaration | undefined; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getGetAccessorOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the corresponding get accessor or throws if not exists. */
                getGetAccessorOrThrow(): GetAccessorDeclaration; // -------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): SetAccessorDeclarationStructure; // --------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SetAccessorDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SetAccessorDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getKind Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the comment syntax kind. */
                getKind(): ts.CommentKind; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                
                protected constructor();
            
                            
                        
getSourceFile Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                getSourceFile(): ts.SourceFile; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getChildCount Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                getChildCount(sourceFile?: ts.SourceFile | undefined): number; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getChildAt Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                getChildAt(index: number, sourceFile?: ts.SourceFile | undefined): ts.Node; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getChildren Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                getChildren(sourceFile?: ts.SourceFile | undefined): ts.Node[]; // ------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getStart Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                getStart(sourceFile?: ts.SourceFile | undefined, includeJsDocComment?: boolean | undefined): number; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getFullStart Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                getFullStart(): number; // ------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getEnd Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                getEnd(): number; // ------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getWidth Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                getWidth(sourceFile?: ts.SourceFileLike | undefined): number; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getFullWidth Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                getFullWidth(): number; // --------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getLeadingTriviaWidth Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                getLeadingTriviaWidth(sourceFile?: ts.SourceFile | undefined): number; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getFullText Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                getFullText(sourceFile?: ts.SourceFile | undefined): string; // ----------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getText Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                getText(sourceFile?: ts.SourceFile | undefined): string; // ----------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getFirstToken Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                getFirstToken(sourceFile?: ts.SourceFile | undefined): ts.Node | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getLastToken Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                getLastToken(sourceFile?: ts.SourceFile | undefined): ts.Node | undefined; // -------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
forEachChild Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                forEachChild<T>(cbNode: (node: ts.Node) => T | undefined, cbNodeArray?: ((nodes: ts.NodeArray<ts.Node>) => T | undefined) | undefined): T | undefined; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                
                protected constructor();
            
                            
                        
forget Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // --------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
forgetDescendants Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Forgets the descendants of this node. */
                forgetDescendants(): this; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
wasForgotten Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the compiler node was forgotten.
                 *
                 * This will be true when the compiler node was forgotten or removed.
                 */
                wasForgotten(): boolean; // ---------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the syntax kind. */
                getKind(): SyntaxKind; // ------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getKindName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the syntax kind name. */
                getKindName(): string; // ------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
print Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Prints the node using the compiler's printer.
                 * @param options - Options.
                 */
                print(options?: PrintNodeOptions): string; // ------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getSymbolOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the symbol or throws an error if it doesn't exist. */
                getSymbolOrThrow(): Symbol; // ------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getSymbol Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the compiler symbol or undefined if it doesn't exist. */
                getSymbol(): Symbol | undefined; // ---------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSymbolsInScope Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the symbols in the scope of the node.
                 *
                 * Note: This will always return the local symbols. If you want the export symbol from a local symbol, then
                 * use the `#getExportSymbol()` method on the symbol.
                 * @param meaning - Meaning of symbol to filter by.
                 */
                getSymbolsInScope(meaning: SymbolFlags): Symbol[]; // ---------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLocalOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the specified local symbol by name or throws if it doesn't exist.
                 *
                 * WARNING: The symbol table of locals is not exposed publicly by the compiler. Use this at your own risk knowing it may break.
                 * @param name - Name of the local symbol.
                 */
                getLocalOrThrow(name: string): Symbol; // ------------------------------------------------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getLocal Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the specified local symbol by name or returns undefined if it doesn't exist.
                 *
                 * WARNING: The symbol table of locals is not exposed publicly by the compiler. Use this at your own risk knowing it may break.
                 * @param name - Name of the local symbol.
                 */
                getLocal(name: string): Symbol | undefined; // ------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLocals Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the symbols within the current scope.
                 *
                 * WARNING: The symbol table of locals is not exposed publicly by the compiler. Use this at your own risk knowing it may break.
                 */
                getLocals(): Symbol[]; // ---------------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getType Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the type of the node. */
                getType(): Type; // ------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
containsRange Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * If the node contains the provided range (inclusive).
                 * @param pos - Start position.
                 * @param end - End position.
                 */
                containsRange(pos: number, end: number): boolean; // ------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isInStringAtPos Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the specified position is within a string.
                 * @param pos - Position.
                 */
                isInStringAtPos(pos: number): boolean; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFirstChildOrThrow Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first child by a condition or throws.
                 * @param condition - Condition.
                 */
                getFirstChildOrThrow<T extends Node>(condition?: (node: Node) => node is T): T; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getFirstChildOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first child by a condition or throws.
                 * @param condition - Condition.
                 */
                getFirstChildOrThrow(condition?: (node: Node) => boolean): Node; // ---------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getFirstChild Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first child by a condition.
                 * @param condition - Condition.
                 */
                getFirstChild<T extends Node>(condition?: (node: Node) => node is T): T | undefined; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getFirstChild Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first child by a condition.
                 * @param condition - Condition.
                 */
                getFirstChild(condition?: (node: Node) => boolean): Node | undefined; // ---------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getLastChildOrThrow Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last child by a condition or throws.
                 * @param condition - Condition.
                 */
                getLastChildOrThrow<T extends Node>(condition?: (node: Node) => node is T): T; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getLastChildOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last child by a condition or throws.
                 * @param condition - Condition.
                 */
                getLastChildOrThrow(condition?: (node: Node) => boolean): Node; // ---------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLastChild Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last child by a condition.
                 * @param condition - Condition.
                 */
                getLastChild<T extends Node>(condition?: (node: Node) => node is T): T | undefined; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getLastChild Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last child by a condition.
                 * @param condition - Condition.
                 */
                getLastChild(condition?: (node: Node) => boolean): Node | undefined; // ---------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getFirstDescendantOrThrow Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first descendant by a condition or throws.
                 * @param condition - Condition.
                 */
                getFirstDescendantOrThrow<T extends Node>(condition?: (node: Node) => node is T): T; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getFirstDescendantOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first descendant by a condition or throws.
                 * @param condition - Condition.
                 */
                getFirstDescendantOrThrow(condition?: (node: Node) => boolean): Node; // ---------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getFirstDescendant Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first descendant by a condition.
                 * @param condition - Condition.
                 */
                getFirstDescendant<T extends Node>(condition?: (node: Node) => node is T): T | undefined; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getFirstDescendant Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first descendant by a condition.
                 * @param condition - Condition.
                 */
                getFirstDescendant(condition?: (node: Node) => boolean): Node | undefined; // ---------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getPreviousSiblingOrThrow Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the previous sibling or throws.
                 * @param condition - Optional condition for getting the previous sibling.
                 */
                getPreviousSiblingOrThrow<T extends Node>(condition?: (node: Node) => node is T): T; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getPreviousSiblingOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the previous sibling or throws.
                 * @param condition - Optional condition for getting the previous sibling.
                 */
                getPreviousSiblingOrThrow(condition?: (node: Node) => boolean): Node; // ---------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getPreviousSibling Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the previous sibling.
                 * @param condition - Optional condition for getting the previous sibling.
                 */
                getPreviousSibling<T extends Node>(condition?: (node: Node) => node is T): T | undefined; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getPreviousSibling Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the previous sibling.
                 * @param condition - Optional condition for getting the previous sibling.
                 */
                getPreviousSibling(condition?: (node: Node) => boolean): Node | undefined; // ---------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getNextSiblingOrThrow Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the next sibling or throws.
                 * @param condition - Optional condition for getting the next sibling.
                 */
                getNextSiblingOrThrow<T extends Node>(condition?: (node: Node) => node is T): T; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getNextSiblingOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the next sibling or throws.
                 * @param condition - Optional condition for getting the next sibling.
                 */
                getNextSiblingOrThrow(condition?: (node: Node) => boolean): Node; // ---------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getNextSibling Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the next sibling.
                 * @param condition - Optional condition for getting the next sibling.
                 */
                getNextSibling<T extends Node>(condition?: (node: Node) => node is T): T | undefined; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getNextSibling Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the next sibling.
                 * @param condition - Optional condition for getting the next sibling.
                 */
                getNextSibling(condition?: (node: Node) => boolean): Node | undefined; // ---------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getPreviousSiblings Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the previous siblings.
                 *
                 * Note: Closest sibling is the zero index.
                 */
                getPreviousSiblings(): Node[]; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getNextSiblings Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the next siblings.
                 *
                 * Note: Closest sibling is the zero index.
                 */
                getNextSiblings(): Node[]; // ------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getChildren Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets all the children of the node. */
                getChildren(): Node[]; // -------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getChildAtIndex Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the child at the specified index.
                 * @param index - Index of the child.
                 */
                getChildAtIndex(index: number): Node; // ----------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getChildSyntaxListOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the child syntax list or throws if it doesn't exist. */
                getChildSyntaxListOrThrow(): SyntaxList; // ------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getChildSyntaxList Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the child syntax list if it exists. */
                getChildSyntaxList(): SyntaxList | undefined; // --------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
forEachChild Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Invokes the `cbNode` callback for each child and the `cbNodeArray` for every array of nodes stored in properties of the node.
                 * If `cbNodeArray` is not defined, then it will pass every element of the array to `cbNode`.
                 * @returns The first truthy value returned by a callback.
                 * @param cbNode - Callback invoked for each child.
                 * @param cbNodeArray - Callback invoked for each array of nodes.
                 */
                forEachChild<T>(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: Node[]) => T | undefined): T | undefined; // ----------------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
forEachDescendant Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Invokes the `cbNode` callback for each descendant and the `cbNodeArray` for every array of nodes stored in properties of the node and descendant nodes.
                 * If `cbNodeArray` is not defined, then it will pass every element of the array to `cbNode`.
                 *
                 * @returns The first truthy value returned by a callback.
                 * @remarks There exists a `traversal` object on the second parameter that allows various control of iteration.
                 * @param cbNode - Callback invoked for each descendant.
                 * @param cbNodeArray - Callback invoked for each array of nodes.
                 */
                forEachDescendant<T>(cbNode: (node: Node, traversal: ForEachDescendantTraversalControl) => T | undefined, cbNodeArray?: (nodes: Node[], traversal: ForEachDescendantTraversalControl) => T | undefined): T | undefined; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
forEachChildAsArray Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the child nodes passed to the delegate of `node.forEachChild(child => {})` as an array. */
                forEachChildAsArray(): Node<ts.Node>[]; // --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
forEachDescendantAsArray Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the descendant nodes passed to the delegate of `node.forEachDescendant(descendant => {})` as an array. */
                forEachDescendantAsArray(): Node<ts.Node>[]; // ----------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDescendants Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the node's descendants. */
                getDescendants(): Node[]; // -------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDescendantStatements Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the node's descendant statements and any arrow function statement-like expressions (ex. returns the expression `5` in `() => 5`). */
                getDescendantStatements(): (Statement | Expression)[]; // ---------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getChildCount Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the number of children the node has. */
                getChildCount(): number; // ------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getChildAtPos Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the child at the provided text position, or undefined if not found.
                 * @param pos - Text position to search for.
                 */
                getChildAtPos(pos: number): Node | undefined; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getDescendantAtPos Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the most specific descendant at the provided text position, or undefined if not found.
                 * @param pos - Text position to search for.
                 */
                getDescendantAtPos(pos: number): Node | undefined; // --------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getDescendantAtStartWithWidth Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the most specific descendant at the provided start text position with the specified width, or undefined if not found.
                 * @param start - Start text position to search for.
                 * @param width - Text length of the node to search for.
                 */
                getDescendantAtStartWithWidth(start: number, width: number): Node | undefined; // ------------------------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getPos Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file text position where the node starts that includes the leading trivia (comments and whitespace). */
                getPos(): number; // ----------------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getEnd Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the source file text position where the node ends.
                 *
                 * @remarks This does not include the following trivia (comments and whitespace).
                 */
                getEnd(): number; // ----------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getStart Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the source file text position where the node starts that does not include the leading trivia (comments and whitespace).
                 * @param includeJsDocComments - Whether to include the JS doc comments.
                 */
                getStart(includeJsDocComments?: boolean): number; // ------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFullStart Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file text position of the end of the last significant token or the start of the source file. */
                getFullStart(): number; // --------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getNonWhitespaceStart Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the first source file text position that is not whitespace taking into account comment nodes and a previous node's trailing trivia. */
                getNonWhitespaceStart(): number; // ---------------------------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getWidth Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the text length of the node without trivia.
                 * @param includeJsDocComments - Whether to include the JS doc comments in the width or not.
                 */
                getWidth(includeJsDocComments?: boolean): number; // -------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFullWidth Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text length of the node with trivia. */
                getFullWidth(): number; // ------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getLeadingTriviaWidth Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the node's leading trivia's text length. */
                getLeadingTriviaWidth(): number; // --------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getTrailingTriviaWidth Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text length from the end of the current node to the next significant token or new line. */
                getTrailingTriviaWidth(): number; // ----------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getTrailingTriviaEnd Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text position of the next significant token or new line. */
                getTrailingTriviaEnd(): number; // ------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getText Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the text without leading trivia (comments and whitespace).
                 * @param includeJsDocComments - Whether to include the js doc comments when getting the text.
                 */
                getText(includeJsDocComments?: boolean): string; // ----------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getText Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the text without leading trivia (comments and whitespace).
                 * @param options - Options for getting the text.
                 */
                getText(options: { // ------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        trimLeadingIndentation?: boolean; // -------------------------------- +0.1 Complexity index (+0.1 atomic)
                        includeJsDocComments?: boolean; // ---------------------------------- +0.1 Complexity index (+0.1 atomic)
                    }): string; // ---------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getFullText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                    
                /** Gets the full text with leading trivia (comments and whitespace). */
                getFullText(): string; // --------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getCombinedModifierFlags Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the combined modifier flags. */
                getCombinedModifierFlags(): ts.ModifierFlags; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSourceFile Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file. */
                getSourceFile(): SourceFile; // ------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getProject Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the project. */
                getProject(): Project; // ------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNodeProperty Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a compiler node property wrapped in a Node.
                 * @param propertyName - Property name.
                 */
                getNodeProperty<KeyType extends keyof LocalNodeType, LocalNodeType extends ts.Node = NodeType>(propertyName: KeyType): NodePropertyToWrappedType<LocalNodeType, KeyType>; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
getAncestors Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Goes up the tree getting all the parents in ascending order. */
                getAncestors(): Node[]; // --------------------------------------------------------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Get the node's parent. */
                getParent(): Node<ts.Node> | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent or throws an error if it doesn't exist. */
                getParentOrThrow(): Node<ts.Node>; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentWhileOrThrow Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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<T extends Node>(condition: (parent: Node, node: Node) => parent is T): T; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
getParentWhileOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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: (parent: Node, node: Node) => boolean): Node; // ------------------------ +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getParentWhile Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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<T extends Node>(condition: (parent: Node, child: Node) => parent is T): T | undefined; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
getParentWhile Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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: (parent: Node, child: Node) => boolean): Node | undefined; // ------------------------ +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getParentWhileKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // -------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getParentWhileKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getLastToken Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the last token of this node. Usually this is a close brace. */
                getLastToken(): Node; // ----------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isInSyntaxList Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this node is in a syntax list. */
                isInSyntaxList(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getParentSyntaxListOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent if it's a syntax list or throws an error otherwise. */
                getParentSyntaxListOrThrow(): SyntaxList; // ---------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParentSyntaxList Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent if it's a syntax list. */
                getParentSyntaxList(): SyntaxList | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getChildIndex Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the child index of this node relative to the parent. */
                getChildIndex(): number; // ----------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getIndentationLevel Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the indentation level of the current node. */
                getIndentationLevel(): number; // ------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getChildIndentationLevel Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the child indentation level of the current node. */
                getChildIndentationLevel(): number; // -------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getIndentationText Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the indentation text.
                 * @param offset - Optional number of levels of indentation to add or remove.
                 */
                getIndentationText(offset?: number): string; // ---------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getChildIndentationText Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the next indentation level text.
                 * @param offset - Optional number of levels of indentation to add or remove.
                 */
                getChildIndentationText(offset?: number): string; // ----------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getStartLinePos Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the position of the start of the line that this node starts on.
                 * @param includeJsDocComments - Whether to include the JS doc comments or not.
                 */
                getStartLinePos(includeJsDocComments?: boolean): number; // ------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getStartLineNumber Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the line number at the start of the node.
                 * @param includeJsDocComments - Whether to include the JS doc comments or not.
                 */
                getStartLineNumber(includeJsDocComments?: boolean): number; // --------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getEndLineNumber Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the line number of the end of the node. */
                getEndLineNumber(): number; // --------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isFirstNodeOnLine Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is the first node on the current line. */
                isFirstNodeOnLine(): boolean; // ------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
replaceWithText Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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 textOrWriterFunction - Text or writer function to replace with.
                 * @returns The new node.
                 * @remarks This will replace the text from the `Node#getStart(true)` position (start position with js docs) to `Node#getEnd()`.
                 * Use `Node#getText(true)` to get all the text that will be replaced.
                 */
                replaceWithText(textOrWriterFunction: string | WriterFunction): Node; // ------------------------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
prependWhitespace Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Prepends the specified whitespace to current node.
                 * @param textOrWriterFunction - Text or writer function.
                 */
                prependWhitespace(textOrWriterFunction: string | WriterFunction): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
appendWhitespace Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Appends the specified whitespace to current node.
                 * @param textOrWriterFunction - Text or writer function.
                 */
                appendWhitespace(textOrWriterFunction: string | WriterFunction): void; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
formatText Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Formats the node's text using the internal TypeScript formatting API.
                 * @param settings - Format code settings.
                 */
                formatText(settings?: FormatCodeSettings): void; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
transform Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Transforms the node using the compiler api nodes and functions (experimental).
                 *
                 * WARNING: This will forget descendants of transformed nodes.
                 * @example Increments all the numeric literals in a source file.
                 * ```ts
                 * sourceFile.transform(traversal => {
                 *   const node = traversal.visitChildren(); // recommend always visiting the children first (post order)
                 *   if (ts.isNumericLiteral(node))
                 *     return ts.createNumericLiteral((parseInt(node.text, 10) + 1).toString());
                 *   return node;
                 * });
                 * ```
                 * @example Updates the class declaration node without visiting the children.
                 * ```ts
                 * const classDec = sourceFile.getClassOrThrow("MyClass");
                 * classDec.transform(traversal => {
                 *   const node = traversal.currentNode;
                 *   return ts.updateClassDeclaration(node, undefined, undefined, ts.createIdentifier("MyUpdatedClass"), undefined, undefined, []);
                 * });
                 * ```
                 */
                transform(visitNode: (traversal: TransformTraversalControl) => ts.Node): this; // ------------------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getLeadingCommentRanges Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the leading comment ranges of the current node. */
                getLeadingCommentRanges(): CommentRange[]; // ------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getTrailingCommentRanges Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the trailing comment ranges of the current node. */
                getTrailingCommentRanges(): CommentRange[]; // ------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getChildrenOfKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the children based on a kind.
                 * @param kind - Syntax kind.
                 */
                getChildrenOfKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind][]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getFirstChildByKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first child by syntax kind or throws an error if not found.
                 * @param kind - Syntax kind.
                 */
                getFirstChildByKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getFirstChildByKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first child by syntax kind.
                 * @param kind - Syntax kind.
                 */
                getFirstChildByKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getFirstChildIfKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first child if it matches the specified syntax kind or throws an error if not found.
                 * @param kind - Syntax kind.
                 */
                getFirstChildIfKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ------------ +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getFirstChildIfKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first child if it matches the specified syntax kind.
                 * @param kind - Syntax kind.
                 */
                getFirstChildIfKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getLastChildByKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last child by syntax kind or throws an error if not found.
                 * @param kind - Syntax kind.
                 */
                getLastChildByKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getLastChildByKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last child by syntax kind.
                 * @param kind - Syntax kind.
                 */
                getLastChildByKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getLastChildIfKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last child if it matches the specified syntax kind or throws an error if not found.
                 * @param kind - Syntax kind.
                 */
                getLastChildIfKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ------------ +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getLastChildIfKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last child if it matches the specified syntax kind.
                 * @param kind - Syntax kind.
                 */
                getLastChildIfKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getChildAtIndexIfKindOrThrow Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the child at the specified index if it's the specified kind or throws an exception.
                 * @param index - Child index to get.
                 * @param kind - Expected kind.
                 */
                getChildAtIndexIfKindOrThrow<TKind extends SyntaxKind>(index: number, kind: TKind): KindToNodeMappings[TKind]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getChildAtIndexIfKind Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the child at the specified index if it's the specified kind or returns undefined.
                 * @param index - Child index to get.
                 * @param kind - Expected kind.
                 */
                getChildAtIndexIfKind<TKind extends SyntaxKind>(index: number, kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getPreviousSiblingIfKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the previous sibiling if it matches the specified kind, or throws.
                 * @param kind - Kind to check.
                 */
                getPreviousSiblingIfKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ------------------------ +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getNextSiblingIfKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the next sibiling if it matches the specified kind, or throws.
                 * @param kind - Kind to check.
                 */
                getNextSiblingIfKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ----------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getPreviousSiblingIfKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the previous sibling if it matches the specified kind.
                 * @param kind - Kind to check.
                 */
                getPreviousSiblingIfKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getNextSiblingIfKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the next sibling if it matches the specified kind.
                 * @param kind - Kind to check.
                 */
                getNextSiblingIfKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ----------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getParentIfOrThrow Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent if it matches a certain condition or throws. */
                getParentIfOrThrow<T extends Node>(condition: (parent: Node | undefined, node: Node) => parent is T): T; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
getParentIfOrThrow Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent if it matches a certain condition or throws. */
                getParentIfOrThrow(condition: (parent: Node | undefined, node: Node) => boolean): Node; // ------------------------ +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getParentIf Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent if it matches a certain condition. */
                getParentIf<T extends Node>(condition: (parent: Node | undefined, node: Node) => parent is T): T | undefined; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
getParentIf Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent if it matches a certain condition. */
                getParentIf(condition: (parent: Node | undefined, node: Node) => boolean): Node | undefined; // ------------------------ +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getParentIfKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent if it's a certain syntax kind or throws. */
                getParentIfKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ---------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getParentIfKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parent if it's a certain syntax kind. */
                getParentIfKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getFirstAncestorByKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first ancestor by syntax kind or throws if not found.
                 * @param kind - Syntax kind.
                 */
                getFirstAncestorByKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getFirstAncestorByKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Get the first ancestor by syntax kind.
                 * @param kind - Syntax kind.
                 */
                getFirstAncestorByKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getFirstAncestorOrThrow Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first ancestor that matches the provided condition or throws if not found.
                 * @param condition - Condition to match.
                 */
                getFirstAncestorOrThrow<T extends Node>(condition?: (node: Node) => node is T): T; // -------------------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getFirstAncestorOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first ancestor that matches the provided condition or throws if not found.
                 * @param condition - Condition to match.
                 */
                getFirstAncestorOrThrow(condition?: (node: Node) => boolean): Node; // -------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getFirstAncestor Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first ancestor that matches the provided condition or returns undefined if not found.
                 * @param condition - Condition to match.
                 */
                getFirstAncestor<T extends Node>(condition?: (node: Node) => node is T): T | undefined; // ----------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getFirstAncestor Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first ancestor that matches the provided condition or returns undefined if not found.
                 * @param condition - Condition to match.
                 */
                getFirstAncestor(condition?: (node: Node) => boolean): Node | undefined; // -------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getDescendantsOfKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the descendants that match a specified syntax kind.
                 * @param kind - Kind to check.
                 */
                getDescendantsOfKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind][]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getFirstDescendantByKindOrThrow Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first descendant by syntax kind or throws.
                 * @param kind - Syntax kind.
                 */
                getFirstDescendantByKindOrThrow<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getFirstDescendantByKind Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first descendant by syntax kind.
                 * @param kind - Syntax kind.
                 */
                getFirstDescendantByKind<TKind extends SyntaxKind>(kind: TKind): KindToNodeMappings[TKind] | undefined; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
hasExpression Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node has an expression.
                 * @param node - Node to check.
                 */
                static hasExpression<T extends Node>(node: T): node is T & { // -------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
                        getExpression(): Expression; // -------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    };
            
                            
                        
hasName Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Gets if the node has a name.
                 * @param node - Node to check.
                 */
                static hasName<T extends Node>(node: T): node is T & { // ------- +0.7 Complexity index (+0.7 atomic)
                        getName(): string; // ----------------------------------- +0.2 Complexity index (+0.2 atomic)
                        getNameNode(): Node; // --------------------------------- +0.2 Complexity index (+0.2 atomic)
                    };
            
                            
                        
hasBody Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Gets if the node has a body.
                 * @param node - Node to check.
                 */
                static hasBody<T extends Node>(node: T): node is T & { // ------- +0.7 Complexity index (+0.7 atomic)
                        getBody(): Node; // ------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    };
            
                            
                        
is Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                    
                /** Creates a type guard for syntax kinds. */
                static is<TKind extends keyof KindToNodeMappings>(kind: TKind): (node: Node | undefined) => node is KindToNodeMappings[TKind]; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
isNode Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the provided value is a Node. */
                static isNode(value: unknown): value is Node; // ---------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isCommentNode Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the provided node is a comment node. */
                static isCommentNode(node: Node | undefined): node is CommentStatement | CommentClassElement | CommentTypeElement | CommentObjectLiteralElement | CommentEnumMember; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
isCommentStatement Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the provided node is a CommentStatement. */
                static isCommentStatement(node: Node | undefined): node is CommentStatement; // ----------------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isCommentClassElement Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the provided node is a CommentClassElement. */
                static isCommentClassElement(node: Node | undefined): node is CommentClassElement; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isCommentTypeElement Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the provided value is a CommentTypeElement. */
                static isCommentTypeElement(node: Node | undefined): node is CommentTypeElement; // --------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isCommentObjectLiteralElement Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the provided node is a CommentObjectLiteralElement. */
                static isCommentObjectLiteralElement(node: Node | undefined): node is CommentObjectLiteralElement; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isCommentEnumMember Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the provided node is a CommentEnumMember. */
                static isCommentEnumMember(node: Node | undefined): node is CommentEnumMember; // --------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isAbstractableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an AbstractableNode.
                 * @param node - Node to check.
                 */
                static isAbstractableNode<T extends Node>(node: T | undefined): node is AbstractableNode & AbstractableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isAmbientableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an AmbientableNode.
                 * @param node - Node to check.
                 */
                static isAmbientableNode<T extends Node>(node: T | undefined): node is AmbientableNode & AmbientableNodeExtensionType & T; // ---------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isArgumentedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an ArgumentedNode.
                 * @param node - Node to check.
                 */
                static isArgumentedNode<T extends Node>(node: T | undefined): node is ArgumentedNode & ArgumentedNodeExtensionType & T; // ---------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isArrayTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an ArrayTypeNode.
                 * @param node - Node to check.
                 */
                static isArrayTypeNode(node: Node | undefined): node is ArrayTypeNode; // -------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isAsyncableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an AsyncableNode.
                 * @param node - Node to check.
                 */
                static isAsyncableNode<T extends Node>(node: T | undefined): node is AsyncableNode & AsyncableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isAwaitableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an AwaitableNode.
                 * @param node - Node to check.
                 */
                static isAwaitableNode<T extends Node>(node: T | undefined): node is AwaitableNode & AwaitableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isBindingNamedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a BindingNamedNode.
                 * @param node - Node to check.
                 */
                static isBindingNamedNode<T extends Node>(node: T | undefined): node is BindingNamedNode & BindingNamedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isBodiedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a BodiedNode.
                 * @param node - Node to check.
                 */
                static isBodiedNode<T extends Node>(node: T | undefined): node is BodiedNode & BodiedNodeExtensionType & T; // ------------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isBodyableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a BodyableNode.
                 * @param node - Node to check.
                 */
                static isBodyableNode<T extends Node>(node: T | undefined): node is BodyableNode & BodyableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isBooleanLiteral Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a BooleanLiteral.
                 * @param node - Node to check.
                 */
                static isBooleanLiteral(node: Node | undefined): node is BooleanLiteral; // ------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isCallSignatureDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a CallSignatureDeclaration.
                 * @param node - Node to check.
                 */
                static isCallSignatureDeclaration(node: Node | undefined): node is CallSignatureDeclaration; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isChildOrderableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ChildOrderableNode.
                 * @param node - Node to check.
                 */
                static isChildOrderableNode<T extends Node>(node: T | undefined): node is ChildOrderableNode & ChildOrderableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isClassLikeDeclarationBase Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ClassLikeDeclarationBase.
                 * @param node - Node to check.
                 */
                static isClassLikeDeclarationBase<T extends Node>(node: T | undefined): node is ClassLikeDeclarationBase & ClassLikeDeclarationBaseExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isConditionalTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ConditionalTypeNode.
                 * @param node - Node to check.
                 */
                static isConditionalTypeNode(node: Node | undefined): node is ConditionalTypeNode; // -------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isConstructSignatureDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ConstructSignatureDeclaration.
                 * @param node - Node to check.
                 */
                static isConstructSignatureDeclaration(node: Node | undefined): node is ConstructSignatureDeclaration; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isConstructorDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ConstructorDeclaration.
                 * @param node - Node to check.
                 */
                static isConstructorDeclaration(node: Node | undefined): node is ConstructorDeclaration; // --------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isConstructorTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ConstructorTypeNode.
                 * @param node - Node to check.
                 */
                static isConstructorTypeNode(node: Node | undefined): node is ConstructorTypeNode; // ------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isDecoratableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a DecoratableNode.
                 * @param node - Node to check.
                 */
                static isDecoratableNode<T extends Node>(node: T | undefined): node is DecoratableNode & DecoratableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isDotDotDotTokenableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a DotDotDotTokenableNode.
                 * @param node - Node to check.
                 */
                static isDotDotDotTokenableNode<T extends Node>(node: T | undefined): node is DotDotDotTokenableNode & DotDotDotTokenableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isExclamationTokenableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an ExclamationTokenableNode.
                 * @param node - Node to check.
                 */
                static isExclamationTokenableNode<T extends Node>(node: T | undefined): node is ExclamationTokenableNode & ExclamationTokenableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isExportGetableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an ExportGetableNode.
                 * @param node - Node to check.
                 */
                static isExportGetableNode<T extends Node>(node: T | undefined): node is ExportGetableNode & ExportGetableNodeExtensionType & T; // ---------------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isExportableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an ExportableNode.
                 * @param node - Node to check.
                 */
                static isExportableNode<T extends Node>(node: T | undefined): node is ExportableNode & ExportableNodeExtensionType & T; // ---------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an Expression.
                 * @param node - Node to check.
                 */
                static isExpression(node: Node | undefined): node is Expression; // -------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isExpressionableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an ExpressionableNode.
                 * @param node - Node to check.
                 */
                static isExpressionableNode<T extends Node>(node: T | undefined): node is ExpressionableNode & ExpressionableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isExpressionedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an ExpressionedNode.
                 * @param node - Node to check.
                 */
                static isExpressionedNode<T extends Node>(node: T | undefined): node is ExpressionedNode & ExpressionedNodeExtensionType & T; // ------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isExtendsClauseableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is an ExtendsClauseableNode.
                 * @param node - Node to check.
                 */
                static isExtendsClauseableNode<T extends Node>(node: T | undefined): node is ExtendsClauseableNode & ExtendsClauseableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isFunctionLikeDeclaration Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a FunctionLikeDeclaration.
                 * @param node - Node to check.
                 */
                static isFunctionLikeDeclaration<T extends Node>(node: T | undefined): node is FunctionLikeDeclaration & FunctionLikeDeclarationExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isFunctionTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a FunctionTypeNode.
                 * @param node - Node to check.
                 */
                static isFunctionTypeNode(node: Node | undefined): node is FunctionTypeNode; // ----------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isGeneratorableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a GeneratorableNode.
                 * @param node - Node to check.
                 */
                static isGeneratorableNode<T extends Node>(node: T | undefined): node is GeneratorableNode & GeneratorableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isGetAccessorDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a GetAccessorDeclaration.
                 * @param node - Node to check.
                 */
                static isGetAccessorDeclaration(node: Node | undefined): node is GetAccessorDeclaration; // ----------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isHeritageClauseableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a HeritageClauseableNode.
                 * @param node - Node to check.
                 */
                static isHeritageClauseableNode<T extends Node>(node: T | undefined): node is HeritageClauseableNode & HeritageClauseableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isImplementsClauseableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ImplementsClauseableNode.
                 * @param node - Node to check.
                 */
                static isImplementsClauseableNode<T extends Node>(node: T | undefined): node is ImplementsClauseableNode & ImplementsClauseableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isImportExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ImportExpression.
                 * @param node - Node to check.
                 */
                static isImportExpression(node: Node | undefined): node is ImportExpression; // -------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isImportTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ImportTypeNode.
                 * @param node - Node to check.
                 */
                static isImportTypeNode(node: Node | undefined): node is ImportTypeNode; // ----------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isIndexSignatureDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a IndexSignatureDeclaration.
                 * @param node - Node to check.
                 */
                static isIndexSignatureDeclaration(node: Node | undefined): node is IndexSignatureDeclaration; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isIndexedAccessTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a IndexedAccessTypeNode.
                 * @param node - Node to check.
                 */
                static isIndexedAccessTypeNode(node: Node | undefined): node is IndexedAccessTypeNode; // --------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isInferTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a InferTypeNode.
                 * @param node - Node to check.
                 */
                static isInferTypeNode(node: Node | undefined): node is InferTypeNode; // ----------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isInitializerExpressionGetableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a InitializerExpressionGetableNode.
                 * @param node - Node to check.
                 */
                static isInitializerExpressionGetableNode<T extends Node>(node: T | undefined): node is InitializerExpressionGetableNode & InitializerExpressionGetableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isInitializerExpressionableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a InitializerExpressionableNode.
                 * @param node - Node to check.
                 */
                static isInitializerExpressionableNode<T extends Node>(node: T | undefined): node is InitializerExpressionableNode & InitializerExpressionableNodeExtensionType & T; // ---------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isIntersectionTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a IntersectionTypeNode.
                 * @param node - Node to check.
                 */
                static isIntersectionTypeNode(node: Node | undefined): node is IntersectionTypeNode; // --------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isIterationStatement Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a IterationStatement.
                 * @param node - Node to check.
                 */
                static isIterationStatement(node: Node | undefined): node is IterationStatement; // ----------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isJSDoc Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JSDoc.
                 * @param node - Node to check.
                 */
                static isJSDoc(node: Node | undefined): node is JSDoc; // --------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isJSDocPropertyLikeTag Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JSDocPropertyLikeTag.
                 * @param node - Node to check.
                 */
                static isJSDocPropertyLikeTag<T extends Node>(node: T | undefined): node is JSDocPropertyLikeTag & JSDocPropertyLikeTagExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isJSDocTag Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JSDocTag.
                 * @param node - Node to check.
                 */
                static isJSDocTag(node: Node | undefined): node is JSDocTag; // ------------------------------------------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isJSDocType Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JSDocType.
                 * @param node - Node to check.
                 */
                static isJSDocType(node: Node | undefined): node is JSDocType; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isJSDocTypeExpressionableTag Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JSDocTypeExpressionableTag.
                 * @param node - Node to check.
                 */
                static isJSDocTypeExpressionableTag<T extends Node>(node: T | undefined): node is JSDocTypeExpressionableTag & JSDocTypeExpressionableTagExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isJSDocTypeParameteredTag Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JSDocTypeParameteredTag.
                 * @param node - Node to check.
                 */
                static isJSDocTypeParameteredTag<T extends Node>(node: T | undefined): node is JSDocTypeParameteredTag & JSDocTypeParameteredTagExtensionType & T; // ---------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isJSDocUnknownTag Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JSDocUnknownTag.
                 * @param node - Node to check.
                 */
                static isJSDocUnknownTag(node: Node | undefined): node is JSDocUnknownTag; // ------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isJSDocableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JSDocableNode.
                 * @param node - Node to check.
                 */
                static isJSDocableNode<T extends Node>(node: T | undefined): node is JSDocableNode & JSDocableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isJsxAttributedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JsxAttributedNode.
                 * @param node - Node to check.
                 */
                static isJsxAttributedNode<T extends Node>(node: T | undefined): node is JsxAttributedNode & JsxAttributedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isJsxTagNamedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a JsxTagNamedNode.
                 * @param node - Node to check.
                 */
                static isJsxTagNamedNode<T extends Node>(node: T | undefined): node is JsxTagNamedNode & JsxTagNamedNodeExtensionType & T; // ------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isLeftHandSideExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a LeftHandSideExpression.
                 * @param node - Node to check.
                 */
                static isLeftHandSideExpression(node: Node | undefined): node is LeftHandSideExpression; // ----------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isLeftHandSideExpressionedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a LeftHandSideExpressionedNode.
                 * @param node - Node to check.
                 */
                static isLeftHandSideExpressionedNode<T extends Node>(node: T | undefined): node is LeftHandSideExpressionedNode & LeftHandSideExpressionedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isLiteralExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a LiteralExpression.
                 * @param node - Node to check.
                 */
                static isLiteralExpression(node: Node | undefined): node is LiteralExpression; // ------------------------------------------------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isLiteralLikeNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a LiteralLikeNode.
                 * @param node - Node to check.
                 */
                static isLiteralLikeNode<T extends Node>(node: T | undefined): node is LiteralLikeNode & LiteralLikeNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isLiteralTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a LiteralTypeNode.
                 * @param node - Node to check.
                 */
                static isLiteralTypeNode(node: Node | undefined): node is LiteralTypeNode; // ------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isMemberExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a MemberExpression.
                 * @param node - Node to check.
                 */
                static isMemberExpression(node: Node | undefined): node is MemberExpression; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isModifierableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ModifierableNode.
                 * @param node - Node to check.
                 */
                static isModifierableNode<T extends Node>(node: T | undefined): node is ModifierableNode & ModifierableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isModuledNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ModuledNode.
                 * @param node - Node to check.
                 */
                static isModuledNode<T extends Node>(node: T | undefined): node is ModuledNode & ModuledNodeExtensionType & T; // ---------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isNameableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a NameableNode.
                 * @param node - Node to check.
                 */
                static isNameableNode<T extends Node>(node: T | undefined): node is NameableNode & NameableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isNamedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a NamedNode.
                 * @param node - Node to check.
                 */
                static isNamedNode<T extends Node>(node: T | undefined): node is NamedNode & NamedNodeExtensionType & T; // ---------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isNamespaceChildableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a NamespaceChildableNode.
                 * @param node - Node to check.
                 */
                static isNamespaceChildableNode<T extends Node>(node: T | undefined): node is NamespaceChildableNode & NamespaceChildableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isNamespaceDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a NamespaceDeclaration.
                 * @param node - Node to check.
                 */
                static isNamespaceDeclaration(node: Node | undefined): node is NamespaceDeclaration; // ------------------------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isNullLiteral Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a NullLiteral.
                 * @param node - Node to check.
                 */
                static isNullLiteral(node: Node | undefined): node is NullLiteral; // ------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isOverloadableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a OverloadableNode.
                 * @param node - Node to check.
                 */
                static isOverloadableNode<T extends Node>(node: T | undefined): node is OverloadableNode & OverloadableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isParameterDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ParameterDeclaration.
                 * @param node - Node to check.
                 */
                static isParameterDeclaration(node: Node | undefined): node is ParameterDeclaration; // ------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isParameteredNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ParameteredNode.
                 * @param node - Node to check.
                 */
                static isParameteredNode<T extends Node>(node: T | undefined): node is ParameteredNode & ParameteredNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isParenthesizedTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ParenthesizedTypeNode.
                 * @param node - Node to check.
                 */
                static isParenthesizedTypeNode(node: Node | undefined): node is ParenthesizedTypeNode; // ------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isPrimaryExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a PrimaryExpression.
                 * @param node - Node to check.
                 */
                static isPrimaryExpression(node: Node | undefined): node is PrimaryExpression; // --------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isPropertyNamedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a PropertyNamedNode.
                 * @param node - Node to check.
                 */
                static isPropertyNamedNode<T extends Node>(node: T | undefined): node is PropertyNamedNode & PropertyNamedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isQuestionDotTokenableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a QuestionDotTokenableNode.
                 * @param node - Node to check.
                 */
                static isQuestionDotTokenableNode<T extends Node>(node: T | undefined): node is QuestionDotTokenableNode & QuestionDotTokenableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isQuestionTokenableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a QuestionTokenableNode.
                 * @param node - Node to check.
                 */
                static isQuestionTokenableNode<T extends Node>(node: T | undefined): node is QuestionTokenableNode & QuestionTokenableNodeExtensionType & T; // ---------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isReadonlyableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ReadonlyableNode.
                 * @param node - Node to check.
                 */
                static isReadonlyableNode<T extends Node>(node: T | undefined): node is ReadonlyableNode & ReadonlyableNodeExtensionType & T; // ---------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isReferenceFindableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ReferenceFindableNode.
                 * @param node - Node to check.
                 */
                static isReferenceFindableNode<T extends Node>(node: T | undefined): node is ReferenceFindableNode & ReferenceFindableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isRenameableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a RenameableNode.
                 * @param node - Node to check.
                 */
                static isRenameableNode<T extends Node>(node: T | undefined): node is RenameableNode & RenameableNodeExtensionType & T; // ---------------------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isReturnTypedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ReturnTypedNode.
                 * @param node - Node to check.
                 */
                static isReturnTypedNode<T extends Node>(node: T | undefined): node is ReturnTypedNode & ReturnTypedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isScopeableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ScopeableNode.
                 * @param node - Node to check.
                 */
                static isScopeableNode<T extends Node>(node: T | undefined): node is ScopeableNode & ScopeableNodeExtensionType & T; // ------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isScopedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ScopedNode.
                 * @param node - Node to check.
                 */
                static isScopedNode<T extends Node>(node: T | undefined): node is ScopedNode & ScopedNodeExtensionType & T; // ---------------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isSetAccessorDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a SetAccessorDeclaration.
                 * @param node - Node to check.
                 */
                static isSetAccessorDeclaration(node: Node | undefined): node is SetAccessorDeclaration; // -------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isSignaturedDeclaration Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a SignaturedDeclaration.
                 * @param node - Node to check.
                 */
                static isSignaturedDeclaration<T extends Node>(node: T | undefined): node is SignaturedDeclaration & SignaturedDeclarationExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isStatement Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a Statement.
                 * @param node - Node to check.
                 */
                static isStatement(node: Node | undefined): node is Statement; // ------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isStatementedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a StatementedNode.
                 * @param node - Node to check.
                 */
                static isStatementedNode<T extends Node>(node: T | undefined): node is StatementedNode & StatementedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isStaticableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a StaticableNode.
                 * @param node - Node to check.
                 */
                static isStaticableNode<T extends Node>(node: T | undefined): node is StaticableNode & StaticableNodeExtensionType & T; // ---------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isSuperExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a SuperExpression.
                 * @param node - Node to check.
                 */
                static isSuperExpression(node: Node | undefined): node is SuperExpression; // ---------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTextInsertableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TextInsertableNode.
                 * @param node - Node to check.
                 */
                static isTextInsertableNode<T extends Node>(node: T | undefined): node is TextInsertableNode & TextInsertableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isThisExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ThisExpression.
                 * @param node - Node to check.
                 */
                static isThisExpression(node: Node | undefined): node is ThisExpression; // ------------------------------------------------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isThisTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a ThisTypeNode.
                 * @param node - Node to check.
                 */
                static isThisTypeNode(node: Node | undefined): node is ThisTypeNode; // ----------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTupleTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TupleTypeNode.
                 * @param node - Node to check.
                 */
                static isTupleTypeNode(node: Node | undefined): node is TupleTypeNode; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTypeArgumentedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeArgumentedNode.
                 * @param node - Node to check.
                 */
                static isTypeArgumentedNode<T extends Node>(node: T | undefined): node is TypeArgumentedNode & TypeArgumentedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isTypeAssertion Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeAssertion.
                 * @param node - Node to check.
                 */
                static isTypeAssertion(node: Node | undefined): node is TypeAssertion; // -------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTypeElement Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeElement.
                 * @param node - Node to check.
                 */
                static isTypeElement(node: Node | undefined): node is TypeElement; // ----------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTypeElementMemberedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeElementMemberedNode.
                 * @param node - Node to check.
                 */
                static isTypeElementMemberedNode<T extends Node>(node: T | undefined): node is TypeElementMemberedNode & TypeElementMemberedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isTypeLiteralNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeLiteralNode.
                 * @param node - Node to check.
                 */
                static isTypeLiteralNode(node: Node | undefined): node is TypeLiteralNode; // ------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeNode.
                 * @param node - Node to check.
                 */
                static isTypeNode(node: Node | undefined): node is TypeNode; // --------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTypeParameterDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeParameterDeclaration.
                 * @param node - Node to check.
                 */
                static isTypeParameterDeclaration(node: Node | undefined): node is TypeParameterDeclaration; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTypeParameteredNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeParameteredNode.
                 * @param node - Node to check.
                 */
                static isTypeParameteredNode<T extends Node>(node: T | undefined): node is TypeParameteredNode & TypeParameteredNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isTypePredicateNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypePredicateNode.
                 * @param node - Node to check.
                 */
                static isTypePredicateNode(node: Node | undefined): node is TypePredicateNode; // --------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTypeReferenceNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypeReferenceNode.
                 * @param node - Node to check.
                 */
                static isTypeReferenceNode(node: Node | undefined): node is TypeReferenceNode; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isTypedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a TypedNode.
                 * @param node - Node to check.
                 */
                static isTypedNode<T extends Node>(node: T | undefined): node is TypedNode & TypedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isUnaryExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a UnaryExpression.
                 * @param node - Node to check.
                 */
                static isUnaryExpression(node: Node | undefined): node is UnaryExpression; // ------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isUnaryExpressionedNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a UnaryExpressionedNode.
                 * @param node - Node to check.
                 */
                static isUnaryExpressionedNode<T extends Node>(node: T | undefined): node is UnaryExpressionedNode & UnaryExpressionedNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isUnionTypeNode Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a UnionTypeNode.
                 * @param node - Node to check.
                 */
                static isUnionTypeNode(node: Node | undefined): node is UnionTypeNode; // ----------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isUnwrappableNode Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a UnwrappableNode.
                 * @param node - Node to check.
                 */
                static isUnwrappableNode<T extends Node>(node: T | undefined): node is UnwrappableNode & UnwrappableNodeExtensionType & T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
isUpdateExpression Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the node is a UpdateExpression.
                 * @param node - Node to check.
                 */
                static isUpdateExpression(node: Node | undefined): node is UpdateExpression; // ----------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
addChildText Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Adds text at the end of the current children.
                 * @param textOrWriterFunction - Text to add or function that provides a writer to write with.
                 * @returns The children that were added.
                 */
                addChildText(textOrWriterFunction: string | WriterFunction | ReadonlyArray<string | WriterFunction>): Node<ts.Node>[]; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
insertChildText Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts text at the specified child index.
                 * @param index - Child index to insert at.
                 * @param textOrWriterFunction - Text to insert or function that provides a writer to write with.
                 * @returns The children that were inserted.
                 */
                insertChildText(index: number, textOrWriterFunction: string | WriterFunction | ReadonlyArray<string | WriterFunction>): Node<ts.Node>[]; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SyntaxList>; // ---------------------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SyntaxList>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                protected constructor();
            
                            
                        
getSourceFile Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file of the text range. */
                getSourceFile(): SourceFile; // ------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getPos Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the position. */
                getPos(): number; // ------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getEnd Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the end. */
                getEnd(): number; // ---------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getWidth Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the width of the text range. */
                getWidth(): number; // ---------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text of the text range. */
                getText(): string; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
wasForgotten Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the text range was forgotten.
                 *
                 * This will be true after any manipulations have occured to the source file this text range was generated from.
                 */
                wasForgotten(): boolean; // ----------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the decorator name. */
                getName(): string; // ----------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNameNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name node of the decorator. */
                getNameNode(): Identifier; // ------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFullName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the full decorator name. */
                getFullName(): string; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isDecoratorFactory Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the decorator is a decorator factory. */
                isDecoratorFactory(): boolean; // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setIsDecoratorFactory Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Set if this decorator is a decorator factory.
                 * @param isDecoratorFactory - If it should be a decorator factory or not.
                 */
                setIsDecoratorFactory(isDecoratorFactory: boolean): this; // ------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getCallExpressionOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the call expression if a decorator factory, or throws. */
                getCallExpressionOrThrow(): CallExpression; // ------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getCallExpression Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the call expression if a decorator factory. */
                getCallExpression(): CallExpression | undefined; // -------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getArguments Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the decorator's arguments from its call expression. */
                getArguments(): Node[]; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getTypeArguments Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the decorator's type arguments from its call expression. */
                getTypeArguments(): TypeNode[]; // -------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
addTypeArgument Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a type argument.
                 * @param argumentTexts - Argument text.
                 */
                addTypeArgument(argumentText: string): TypeNode<ts.TypeNode>; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
addTypeArguments Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds type arguments.
                 * @param argumentTexts - Argument texts.
                 */
                addTypeArguments(argumentTexts: ReadonlyArray<string>): TypeNode<ts.TypeNode>[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
insertTypeArgument Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a type argument.
                 * @param index - Child index to insert at.
                 * @param argumentTexts - Argument text.
                 */
                insertTypeArgument(index: number, argumentText: string): TypeNode<ts.TypeNode>; // -------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertTypeArguments Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts type arguments.
                 * @param index - Child index to insert at.
                 * @param argumentTexts - Argument texts.
                 */
                insertTypeArguments(index: number, argumentTexts: ReadonlyArray<string>): TypeNode<ts.TypeNode>[]; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
removeTypeArgument Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes a type argument.
                 * @param typeArg - Type argument to remove.
                 */
                removeTypeArgument(typeArg: Node): this; // ----------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeTypeArgument Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes a type argument.
                 * @param index - Index to remove.
                 */
                removeTypeArgument(index: number): this; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
addArgument Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds an argument.
                 * @param argumentTexts - Argument text.
                 */
                addArgument(argumentText: string | WriterFunction): Node<ts.Node>; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addArguments Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds arguments.
                 * @param argumentTexts - Argument texts.
                 */
                addArguments(argumentTexts: ReadonlyArray<string | WriterFunction> | WriterFunction): Node<ts.Node>[]; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
insertArgument Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts an argument.
                 * @param index - Child index to insert at.
                 * @param argumentTexts - Argument text.
                 */
                insertArgument(index: number, argumentText: string | WriterFunction): Node<ts.Node>; // ------------------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
insertArguments Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts arguments.
                 * @param index - Child index to insert at.
                 * @param argumentTexts - Argument texts.
                 */
                insertArguments(index: number, argumentTexts: ReadonlyArray<string | WriterFunction> | WriterFunction): Node<ts.Node>[]; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
removeArgument Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes an argument based on the node.
                 * @param node - Argument's node to remove.
                 */
                removeArgument(node: Node): this; // ---------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeArgument Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes an argument based on the specified index.
                 * @param index - Index to remove.
                 */
                removeArgument(index: number): this; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes this decorator. */
                remove(): void; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<DecoratorStructure>): this; // ---------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): DecoratorStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.Decorator>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.Decorator>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
JSDocPropertyLikeTag Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function JSDocPropertyLikeTag<T extends Constructor<JSDocPropertyLikeTagExtensionType>>(Base: T): Constructor<JSDocPropertyLikeTag> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
JSDocTypeExpressionableTag Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function JSDocTypeExpressionableTag<T extends Constructor<JSDocTypeExpressionableTagExtensionType>>(Base: T): Constructor<JSDocTypeExpressionableTag> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
JSDocTypeParameteredTag Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function JSDocTypeParameteredTag<T extends Constructor<JSDocTypeParameteredTagExtensionType>>(Base: T): Constructor<JSDocTypeParameteredTag> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
isMultiLine Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets if this JS doc spans multiple lines. */
                isMultiLine(): boolean; // ------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getTags Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the tags of the JSDoc. */
                getTags(): JSDocTag[]; // ------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getInnerText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSDoc's text without the surrounding slashes and stars. */
                getInnerText(): string; // ------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDescription Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the description from the JS doc comment.
                 * @remarks This will contain a leading newline if the jsdoc is multi-line.
                 */
                getDescription(): string; // --------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setDescription Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the description.
                 * @param textOrWriterFunction - Text or writer function to set.
                 */
                setDescription(textOrWriterFunction: string | WriterFunction): this; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addTag Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a JS doc tag.
                 * @param structure - Tag structure to add.
                 */
                addTag(structure: OptionalKind<JSDocTagStructure>): JSDocTag<ts.JSDocTag>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
addTags Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds JS doc tags.
                 * @param structures - Tag structures to add.
                 */
                addTags(structures: ReadonlyArray<OptionalKind<JSDocTagStructure>>): JSDocTag<ts.JSDocTag>[]; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
insertTag Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a JS doc tag at the specified index.
                 * @param index - Index to insert at.
                 * @param structure - Tag structure to insert.
                 */
                insertTag(index: number, structure: OptionalKind<JSDocTagStructure>): JSDocTag<ts.JSDocTag>; // -------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
insertTags Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts JS doc tags at the specified index.
                 * @param index - Index to insert at.
                 * @param structures - Tag structures to insert.
                 */
                insertTags(index: number, structures: ReadonlyArray<OptionalKind<JSDocTagStructure>>): JSDocTag<ts.JSDocTag>[]; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes this JSDoc. */
                remove(): void; // ------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<JSDocStructure>): Node<ts.Node>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): JSDocStructure; // ------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDoc>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDoc>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocAugmentsTag>; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocAugmentsTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocClassTag>; // ---------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocClassTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocDeprecatedTag>; // --------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocDeprecatedTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocFunctionType>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocFunctionType>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocParameterTag>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocParameterTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocPrivateTag>; // ------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocPrivateTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocPropertyTag>; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocPropertyTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocProtectedTag>; // -------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocProtectedTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocPublicTag>; // ----------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocPublicTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocReadonlyTag>; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocReadonlyTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocReturnTag>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocReturnTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeNode Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the type node of the JS doc signature. */
                getTypeNode(): JSDocReturnTag | undefined; // ----------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocSignature>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocSignature>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTagName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the tag's name as a string (ex. returns `"param"` for `&#64;param`). */
                getTagName(): string; // ---------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getTagNameNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the tag name node (ex. Returns the `param` identifier for `&#64;param`). */
                getTagNameNode(): Identifier; // -------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setTagName Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the tag name.
                 * @param tagName - The new name to use.
                 * @returns The current node or new node if the node kind changed.
                 * @remarks This will forget the current node if the JSDocTag kind changes. Use the return value if you're changing the kind.
                 */
                setTagName(tagName: string): Node<ts.Node>; // ----------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getComment Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the tag's comment (ex. `"Some description."` for `&#64;param value Some description.`) */
                getComment(): string | undefined; // ------------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes the JS doc comment. */
                remove(): void; // -------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 * @returns The node or the node that replaced the existing node (ex. when changing from a JSDocParameterTag to something else).
                 */
                set(structure: Partial<JSDocTagStructure>): Node<ts.Node>; // ----------------------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
replaceWithText Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                replaceWithText(textOrWriterFunction: string | WriterFunction): Node; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets a structure that represents this JS doc tag node. */
                getStructure(): JSDocTagStructure; // ------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name. */
                getName(): string; // --------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getText Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text. */
                getText(): string | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getConstraint Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the template tag's constraint if it exists or returns undefined. */
                getConstraint(): JSDocTypeExpression | undefined; // ------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getConstraintOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the template tag's constraint if it exists or throws otherwise. */
                getConstraintOrThrow(): JSDocTypeExpression; // -------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocTemplateTag>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocTemplateTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocThisTag>; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocThisTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocTypedefTag>; // ------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocTypedefTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeExpression Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the type expression node of the JS doc property type tag. */
                getTypeExpression(): JSDocTypeExpression | undefined; // ----------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocTypeTag>; // --------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocTypeTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocUnknownTag>; // ------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocUnknownTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeNode Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets the type node of the JS doc type expression. */
                getTypeNode(): TypeNode<ts.TypeNode>; // ------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocTypeExpression>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocTypeExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocAuthorTag>; // ----------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocAuthorTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocCallbackTag>; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocCallbackTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocEnumTag>; // --------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocEnumTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JSDocImplementsTag>; // --------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JSDocImplementsTag>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes this enum member comment. */
                remove(): void; // -------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<EnumDeclarationStructure>): this; // --------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
addMember Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a member to the enum.
                 * @param structure - Structure of the enum.
                 */
                addMember(structure: OptionalKind<EnumMemberStructure>): EnumMember; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addMember Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a member to the enum.
                 * @param structure - Structure of the enum.
                 */
                addMember(structure: OptionalKind<EnumMemberStructure> | WriterFunction | string): EnumMember | CommentEnumMember; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
addMembers Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds members to the enum.
                 * @param structures - Structures of the enums.
                 */
                addMembers(structures: ReadonlyArray<OptionalKind<EnumMemberStructure>>): EnumMember[]; // ---------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
addMembers Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds members to the enum.
                 * @param structures - Structures of the enums.
                 */
                addMembers(structures: ReadonlyArray<OptionalKind<EnumMemberStructure> | WriterFunction | string> | string | WriterFunction): (EnumMember | CommentEnumMember)[]; // ------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
insertMember Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a member to the enum.
                 * @param index - Child index to insert at.
                 * @param structure - Structure of the enum.
                 */
                insertMember(index: number, structure: OptionalKind<EnumMemberStructure>): EnumMember; // ---------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertMember Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a member to the enum.
                 * @param index - Child index to insert at.
                 * @param structure - Structure of the enum.
                 */
                insertMember(index: number, structure: OptionalKind<EnumMemberStructure> | WriterFunction | string): EnumMember | CommentEnumMember; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
insertMembers Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts members to an enum.
                 * @param index - Child index to insert at.
                 * @param structures - Structures of the enums.
                 */
                insertMembers(index: number, structures: ReadonlyArray<OptionalKind<EnumMemberStructure>>): EnumMember[]; // ---------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
insertMembers Complexity Index 1.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts members to an enum.
                 * @param index - Child index to insert at.
                 * @param structures - Structures of the enums.
                 */
                insertMembers(index: number, structures: ReadonlyArray<OptionalKind<EnumMemberStructure> | WriterFunction | string> | WriterFunction | string): (EnumMember | CommentEnumMember)[]; // ------- +1.6 Complexity index (+1.6 atomic)
            
                            
                        
getMember Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets an enum member.
                 * @param name - Name of the member.
                 */
                getMember(name: string): EnumMember | undefined; // ------------------------------------------------------------------------------------------------------------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getMember Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets an enum member.
                 * @param findFunction - Function to use to find the member.
                 */
                getMember(findFunction: (declaration: EnumMember) => boolean): EnumMember | undefined; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getMemberOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets an enum member or throws if not found.
                 * @param name - Name of the member.
                 */
                getMemberOrThrow(name: string): EnumMember; // -------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getMemberOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets an enum member or throws if not found.
                 * @param findFunction - Function to use to find the member.
                 */
                getMemberOrThrow(findFunction: (declaration: EnumMember) => boolean): EnumMember; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getMembers Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the enum's members. */
                getMembers(): EnumMember[]; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getMembersWithComments Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the enum's members with comment enum members. */
                getMembersWithComments(): (EnumMember | CommentEnumMember)[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setIsConstEnum Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Toggle if it's a const enum. */
                setIsConstEnum(value: boolean): this; // ------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isConstEnum Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if it's a const enum. */
                isConstEnum(): boolean; // --------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getConstKeyword Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the const enum keyword or undefined if not exists. */
                getConstKeyword(): Node<ts.Node> | undefined; // ------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): EnumDeclarationStructure; // ---------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.EnumDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.EnumDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getValue Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the constant value of the enum. */
                getValue(): string | number | undefined; // ---------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setValue Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the enum value.
                 *
                 * This is a helper method. Use `#setInitializer` if you want to set the initializer
                 * to something other than a string or number.
                 * @param value - Enum value.
                 */
                setValue(value: string | number): this; // ---------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes this enum member. */
                remove(): void; // ------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<EnumMemberStructure>): this; // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): EnumMemberStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.EnumMember>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.EnumMember>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLeft Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the left array literal expression of the array destructuring assignment. */
                getLeft(): ArrayLiteralExpression; // ---------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ArrayDestructuringAssignment>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ArrayDestructuringAssignment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getElements Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the array's elements. */
                getElements(): Expression[]; // ------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
addElement Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds an element to the array.
                 * @param textOrWriterFunction - Text to add as an element.
                 * @param options - Options.
                 */
                addElement(textOrWriterFunction: string | WriterFunction, options?: { // ------- +0.6 Complexity index (+0.6 atomic)
                        useNewLines?: boolean; // ---------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    }): Expression<ts.Expression>; // ------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
addElements Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Adds elements to the array.
                 * @param textsOrWriterFunction - Texts to add as elements.
                 * @param options - Options.
                 */
                addElements(textsOrWriterFunction: ReadonlyArray<string | WriterFunction> | WriterFunction, options?: { // ------- +0.9 Complexity index (+0.9 atomic)
                        useNewLines?: boolean; // -------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    }): Expression<ts.Expression>[]; // -------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
insertElement Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Insert an element into the array.
                 * @param index - Child index to insert at.
                 * @param text - Text to insert as an element.
                 * @param options - Options.
                 */
                insertElement(index: number, textOrWriterFunction: string | WriterFunction, options?: { // ------- +0.7 Complexity index (+0.7 atomic)
                        useNewLines?: boolean; // ---------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    }): Expression<ts.Expression>; // ------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
insertElements Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Insert elements into the array.
                 * @param index - Child index to insert at.
                 * @param textsOrWriterFunction - Texts to insert as elements.
                 * @param options - Options.
                 */
                insertElements(index: number, textsOrWriterFunction: ReadonlyArray<string | WriterFunction> | WriterFunction, options?: { // ------- +1.0 Complexity index (+1.0 atomic)
                        useNewLines?: boolean; // -------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    }): Expression<ts.Expression>[]; // -------------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
removeElement Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Removes an element from the array.
                 * @param index - Index to remove from.
                 */
                removeElement(index: number): void; // ----------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeElement Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes an element from the array.
                 * @param element - Element to remove.
                 */
                removeElement(element: Expression): void; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ArrayLiteralExpression>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ArrayLiteralExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.AsExpression>; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.AsExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getOperatorToken Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets the operator token of the assignment expression. */
                getOperatorToken(): Node<ts.AssignmentOperatorToken>; // -------------------------------------------------------------------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.AwaitExpression>; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.AwaitExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLeft Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the left side of the binary expression. */
                getLeft(): Expression; // --------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getOperatorToken Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the operator token of the binary expression. */
                getOperatorToken(): Node<ts.BinaryOperatorToken>; // -------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getRight Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the right side of the binary expression. */
                getRight(): Expression; // ------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getReturnType Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the return type of the call expression. */
                getReturnType(): Type; // ------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getElements Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the elements. */
                getElements(): Expression[]; // ------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.CommaListExpression>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.CommaListExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getCondition Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the condition of the conditional expression. */
                getCondition(): Expression; // -------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getQuestionToken Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the question token of the conditional expression. */
                getQuestionToken(): Node<ts.QuestionToken>; // ------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getWhenTrue Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the when true expression of the conditional expression. */
                getWhenTrue(): Expression; // ------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getColonToken Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the colon token of the conditional expression. */
                getColonToken(): Node<ts.ColonToken>; // ---------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getWhenFalse Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the when false expression of the conditional expression. */
                getWhenFalse(): Expression; // ------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ConditionalExpression>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ConditionalExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.DeleteExpression>; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.DeleteExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getArgumentExpression Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets this element access expression's argument expression or undefined if none exists. */
                getArgumentExpression(): Expression | undefined; // ----------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getArgumentExpressionOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets this element access expression's argument expression or throws if none exists. */
                getArgumentExpressionOrThrow(): Expression<ts.Expression>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getContextualType Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the contextual type of the expression. */
                getContextualType(): Type | undefined; // ------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
ExpressionableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function ExpressionableNode<T extends Constructor<ExpressionableNodeExtensionType>>(Base: T): Constructor<ExpressionableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
BaseExpressionedNode Complexity Index 3.6 Cyclomatic complexity 1
                            
                                
                
            export declare function BaseExpressionedNode<T extends Constructor<ExpressionedNodeExtensionType>, TExpression extends Node = CompilerNodeToWrappedType<InstanceOf<T>["compilerNode"]>>(Base: T): Constructor<BaseExpressionedNode<TExpression>> & T; // ------- +3.6 Complexity index (+1.6 atomic, +2 recursivity)
            
                            
                        
ExpressionedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function ExpressionedNode<T extends Constructor<ExpressionedNodeExtensionType>>(Base: T): Constructor<ExpressionedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
ImportExpressionedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function ImportExpressionedNode<T extends Constructor<ImportExpressionedNodeExtensionType>>(Base: T): Constructor<ImportExpressionedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
LeftHandSideExpressionedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function LeftHandSideExpressionedNode<T extends Constructor<LeftHandSideExpressionedNodeExtensionType>>(Base: T): Constructor<LeftHandSideExpressionedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
SuperExpressionedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function SuperExpressionedNode<T extends Constructor<SuperExpressionedNodeExtensionType>>(Base: T): Constructor<SuperExpressionedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
UnaryExpressionedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function UnaryExpressionedNode<T extends Constructor<UnaryExpressionedNodeExtensionType>>(Base: T): Constructor<UnaryExpressionedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ImportExpression>; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ImportExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getKeywordToken Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
            
                /** Gets the keyword token. */
                getKeywordToken(): SyntaxKind.ImportKeyword | SyntaxKind.NewKeyword; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.MetaProperty>; // ------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.MetaProperty>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NewExpression>; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NewExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NonNullExpression>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NonNullExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLeft Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the left object literal expression of the object destructuring assignment. */
                getLeft(): ObjectLiteralExpression; // ------------------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ObjectDestructuringAssignment>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ObjectDestructuringAssignment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes the object literal element from the object literal expression. */
                remove(): void; // ------------------------------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getPropertyOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets the first property by the provided name or throws.
                 * @param name - Name of the property.
                 */
                getPropertyOrThrow(name: string): ObjectLiteralElementLike; // ------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getPropertyOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first property that matches the provided find function or throws.
                 * @param findFunction - Find function.
                 */
                getPropertyOrThrow(findFunction: (property: ObjectLiteralElementLike) => boolean): ObjectLiteralElementLike; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getProperty Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first property by the provided name or returns undefined.
                 * @param name - Name of the property.
                 */
                getProperty(name: string): ObjectLiteralElementLike | undefined; // --------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getProperty Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the first property that matches the provided find function or returns undefined.
                 * @param findFunction - Find function.
                 */
                getProperty(findFunction: (property: ObjectLiteralElementLike) => boolean): ObjectLiteralElementLike | undefined; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getProperties Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the properties. */
                getProperties(): ObjectLiteralElementLike[]; // ---------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getPropertiesWithComments Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the properties with comment object literal elements. */
                getPropertiesWithComments(): (ObjectLiteralElementLike | CommentObjectLiteralElement)[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addProperty Complexity Index 1.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds the specified property to the object literal expression.
                 *
                 * Note: If you only want to add a property assignment, then it might be more convenient to use #addPropertyAssignment.
                 * @structure - The structure to add.
                 */
                addProperty(structure: string | WriterFunction | ObjectLiteralExpressionPropertyStructures): CommentObjectLiteralElement | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment; // ------- +1.4 Complexity index (+1.4 atomic)
            
                            
                        
addProperties Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds the specified properties to the object literal expression.
                 *
                 * Note: If you only want to add property assignments, then it might be more convenient to use #addPropertyAssignments.
                 * @structures - The structures to add.
                 */
                addProperties(structures: string | WriterFunction | ReadonlyArray<string | WriterFunction | ObjectLiteralExpressionPropertyStructures>): (CommentObjectLiteralElement | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment)[]; // ------- +1.9 Complexity index (+1.9 atomic)
            
                            
                        
insertProperty Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts the specified property to the object literal expression.
                 *
                 * Note: If you only want to insert a property assignment, then it might be more convenient to use #insertPropertyAssignment.
                 * @index - The index to insert at.
                 * @structure - The structure to insert.
                 */
                insertProperty(index: number, structure: string | WriterFunction | ObjectLiteralExpressionPropertyStructures): CommentObjectLiteralElement | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment; // ------------------------------------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
insertProperties Complexity Index 2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts the specified properties to the object literal expression.
                 *
                 * Note: If you only want to insert property assignments, then it might be more convenient to use #insertPropertyAssignments.
                 * @index - The index to insert at.
                 * @structures - The structures to insert.
                 */
                insertProperties(index: number, structures: string | WriterFunction | ReadonlyArray<string | WriterFunction | ObjectLiteralExpressionPropertyStructures>): (CommentObjectLiteralElement | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment)[]; // ------- +2.0 Complexity index (+2.0 atomic)
            
                            
                        
addPropertyAssignment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a property assignment.
                 * @param structure - Structure that represents the property assignment to add.
                 */
                addPropertyAssignment(structure: OptionalKind<PropertyAssignmentStructure>): PropertyAssignment; // ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addPropertyAssignments Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds property assignments.
                 * @param structures - Structure that represents the property assignments to add.
                 */
                addPropertyAssignments(structures: ReadonlyArray<OptionalKind<PropertyAssignmentStructure>>): PropertyAssignment[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertPropertyAssignment Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a property assignment at the specified index.
                 * @param index - Child index to insert at.
                 * @param structure - Structure that represents the property assignment to insert.
                 */
                insertPropertyAssignment(index: number, structure: OptionalKind<PropertyAssignmentStructure>): PropertyAssignment; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertPropertyAssignments Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts property assignments at the specified index.
                 * @param index - Child index to insert at.
                 * @param structures - Structures that represent the property assignments to insert.
                 */
                insertPropertyAssignments(index: number, structures: ReadonlyArray<OptionalKind<PropertyAssignmentStructure>>): PropertyAssignment[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addShorthandPropertyAssignment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a shorthand property assignment.
                 * @param structure - Structure that represents the shorthand property assignment to add.
                 */
                addShorthandPropertyAssignment(structure: OptionalKind<ShorthandPropertyAssignmentStructure>): ShorthandPropertyAssignment; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addShorthandPropertyAssignments Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds shorthand property assignments.
                 * @param structures - Structure that represents the shorthand property assignments to add.
                 */
                addShorthandPropertyAssignments(structures: ReadonlyArray<OptionalKind<ShorthandPropertyAssignmentStructure>>): ShorthandPropertyAssignment[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertShorthandPropertyAssignment Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a shorthand property assignment at the specified index.
                 * @param index - Child index to insert at.
                 * @param structure - Structure that represents the shorthand property assignment to insert.
                 */
                insertShorthandPropertyAssignment(index: number, structure: OptionalKind<ShorthandPropertyAssignmentStructure>): ShorthandPropertyAssignment; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertShorthandPropertyAssignments Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts shorthand property assignments at the specified index.
                 * @param index - Child index to insert at.
                 * @param structures - Structures that represent the shorthand property assignments to insert.
                 */
                insertShorthandPropertyAssignments(index: number, structures: ReadonlyArray<OptionalKind<ShorthandPropertyAssignmentStructure>>): ShorthandPropertyAssignment[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addSpreadAssignment Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a spread assignment.
                 * @param structure - Structure that represents the spread assignment to add.
                 */
                addSpreadAssignment(structure: OptionalKind<SpreadAssignmentStructure>): SpreadAssignment; // ----------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addSpreadAssignments Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds spread assignments.
                 * @param structures - Structure that represents the spread assignments to add.
                 */
                addSpreadAssignments(structures: ReadonlyArray<OptionalKind<SpreadAssignmentStructure>>): SpreadAssignment[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertSpreadAssignment Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a spread assignment at the specified index.
                 * @param index - Child index to insert at.
                 * @param structure - Structure that represents the spread assignment to insert.
                 */
                insertSpreadAssignment(index: number, structure: OptionalKind<SpreadAssignmentStructure>): SpreadAssignment; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertSpreadAssignments Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts spread assignments at the specified index.
                 * @param index - Child index to insert at.
                 * @param structures - Structures that represent the spread assignments to insert.
                 */
                insertSpreadAssignments(index: number, structures: ReadonlyArray<OptionalKind<SpreadAssignmentStructure>>): SpreadAssignment[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addMethod Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a method.
                 * @param structure - Structure that represents the method to add.
                 */
                addMethod(structure: OptionalKind<MethodDeclarationStructure>): MethodDeclaration; // ---------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addMethods Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds methods.
                 * @param structures - Structure that represents the methods to add.
                 */
                addMethods(structures: ReadonlyArray<OptionalKind<MethodDeclarationStructure>>): MethodDeclaration[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertMethod Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a method at the specified index.
                 * @param index - Child index to insert at.
                 * @param structure - Structure that represents the method to insert.
                 */
                insertMethod(index: number, structure: OptionalKind<MethodDeclarationStructure>): MethodDeclaration; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertMethods Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts methods at the specified index.
                 * @param index - Child index to insert at.
                 * @param structures - Structures that represent the methods to insert.
                 */
                insertMethods(index: number, structures: ReadonlyArray<OptionalKind<MethodDeclarationStructure>>): MethodDeclaration[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addGetAccessor Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a get accessor.
                 * @param structure - Structure that represents the property assignment to add.
                 */
                addGetAccessor(structure: OptionalKind<GetAccessorDeclarationStructure>): GetAccessorDeclaration; // ----------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addGetAccessors Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds get accessors.
                 * @param structures - Structure that represents the get accessors to add.
                 */
                addGetAccessors(structures: ReadonlyArray<OptionalKind<GetAccessorDeclarationStructure>>): GetAccessorDeclaration[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertGetAccessor Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a get accessor at the specified index.
                 * @param index - Child index to insert at.
                 * @param structure - Structure that represents the get accessor to insert.
                 */
                insertGetAccessor(index: number, structure: OptionalKind<GetAccessorDeclarationStructure>): GetAccessorDeclaration; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertGetAccessors Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts get accessors at the specified index.
                 * @param index - Child index to insert at.
                 * @param structures - Structures that represent the get accessors to insert.
                 */
                insertGetAccessors(index: number, structures: ReadonlyArray<OptionalKind<GetAccessorDeclarationStructure>>): GetAccessorDeclaration[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addSetAccessor Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a set accessor.
                 * @param structure - Structure that represents the property assignment to add.
                 */
                addSetAccessor(structure: OptionalKind<SetAccessorDeclarationStructure>): SetAccessorDeclaration; // -------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addSetAccessors Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds set accessors.
                 * @param structures - Structure that represents the set accessors to add.
                 */
                addSetAccessors(structures: ReadonlyArray<OptionalKind<SetAccessorDeclarationStructure>>): SetAccessorDeclaration[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertSetAccessor Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a set accessor at the specified index.
                 * @param index - Child index to insert at.
                 * @param structure - Structure that represents the set accessor to insert.
                 */
                insertSetAccessor(index: number, structure: OptionalKind<SetAccessorDeclarationStructure>): SetAccessorDeclaration; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertSetAccessors Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts set accessors at the specified index.
                 * @param index - Child index to insert at.
                 * @param structures - Structures that represent the set accessors to insert.
                 */
                insertSetAccessors(index: number, structures: ReadonlyArray<OptionalKind<SetAccessorDeclarationStructure>>): SetAccessorDeclaration[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ObjectLiteralExpression>; // ------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ObjectLiteralExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
removeInitializer Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Removes the initializer 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; // ----------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setInitializer Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the initializer.
                 * @param textOrWriterFunction - New text ot set for the initializer.
                 */
                setInitializer(textOrWriterFunction: string | WriterFunction): this; // -------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<PropertyAssignmentStructure>): this | ShorthandPropertyAssignment; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): PropertyAssignmentStructure; // ---------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.PropertyAssignment>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.PropertyAssignment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
hasObjectAssignmentInitializer Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets if the shorthand property assignment has an object assignment initializer. */
                hasObjectAssignmentInitializer(): boolean; // ----------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getObjectAssignmentInitializerOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the object assignment initializer or throws if it doesn't exist. */
                getObjectAssignmentInitializerOrThrow(): Expression<ts.Expression>; // ---------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getObjectAssignmentInitializer Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the object assignment initializer if it exists. */
                getObjectAssignmentInitializer(): Expression | undefined; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getEqualsTokenOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the equals token or throws if it doesn't exist. */
                getEqualsTokenOrThrow(): Node<ts.EqualsToken>; // -------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getEqualsToken Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the equals token if it exists. */
                getEqualsToken(): Node<ts.EqualsToken> | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
removeObjectAssignmentInitializer Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Remove the object assignment initializer.
                 *
                 * This is only useful to remove bad code.
                 */
                removeObjectAssignmentInitializer(): this; // ---------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setInitializer Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // --------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ShorthandPropertyAssignmentStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ShorthandPropertyAssignmentStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ShorthandPropertyAssignment>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ShorthandPropertyAssignment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<SpreadAssignmentStructure>): this; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): SpreadAssignmentStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SpreadAssignment>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SpreadAssignment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.OmittedExpression>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.OmittedExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ParenthesizedExpression>; // --------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ParenthesizedExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.PartiallyEmittedExpression>; // --------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.PartiallyEmittedExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getOperatorToken Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the operator token of the postfix unary expression. */
                getOperatorToken(): ts.PostfixUnaryOperator; // ------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getOperand Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the operand of the postfix unary expression. */
                getOperand(): LeftHandSideExpression; // -------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.PostfixUnaryExpression>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.PostfixUnaryExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getOperatorToken Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the operator token of the prefix unary expression. */
                getOperatorToken(): ts.PrefixUnaryOperator; // ---------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getOperand Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the operand of the prefix unary expression. */
                getOperand(): UnaryExpression; // -------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.PrefixUnaryExpression>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.PrefixUnaryExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SpreadElement>; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SpreadElement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SuperElementAccessExpression>; // ------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SuperElementAccessExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SuperExpression>; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SuperExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SuperPropertyAccessExpression>; // --------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SuperPropertyAccessExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ThisExpression>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ThisExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TypeAssertion>; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TypeAssertion>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TypeOfExpression>; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TypeOfExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.VoidExpression>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.VoidExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.YieldExpression>; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.YieldExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getEqualsGreaterThan Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
            
                /** Gets the equals greater than token of the arrow function. */
                getEqualsGreaterThan(): Node<ts.Token<SyntaxKind.EqualsGreaterThanToken>>; // --------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ArrowFunction>; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ArrowFunction>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addOverload Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Adds a function overload.
                 * @param structure - Structure of the overload.
                 */
                addOverload(structure: OptionalKind<FunctionDeclarationOverloadStructure>): FunctionDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addOverloads Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds function overloads.
                 * @param structures - Structures of the overloads.
                 */
                addOverloads(structures: ReadonlyArray<OptionalKind<FunctionDeclarationOverloadStructure>>): FunctionDeclaration[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertOverload Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a function overload.
                 * @param index - Child index to insert at.
                 * @param structure - Structure of the overload.
                 */
                insertOverload(index: number, structure: OptionalKind<FunctionDeclarationOverloadStructure>): FunctionDeclaration; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertOverloads Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts function overloads.
                 * @param index - Child index to insert at.
                 * @param structure - Structures of the overloads.
                 */
                insertOverloads(index: number, structures: ReadonlyArray<OptionalKind<FunctionDeclarationOverloadStructure>>): FunctionDeclaration[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes this function declaration. */
                remove(): void; // ----------------------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<FunctionDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): FunctionDeclarationStructure | FunctionDeclarationOverloadStructure; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.FunctionDeclaration>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.FunctionDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.FunctionExpression>; // ----------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.FunctionExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
FunctionLikeDeclaration Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function FunctionLikeDeclaration<T extends Constructor<FunctionLikeDeclarationExtensionType>>(Base: T): Constructor<FunctionLikeDeclaration> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
OverloadableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            export declare function OverloadableNode<T extends Constructor<OverloadableNodeExtensionType>>(Base: T): Constructor<OverloadableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
isRestParameter Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets if it's a rest parameter. */
                isRestParameter(): boolean; // ----------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isParameterProperty Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a property with a scope or readonly keyword (found in class constructors). */
                isParameterProperty(): boolean; // ------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setIsRestParameter Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets if it's a rest parameter.
                 * @param value - Sets if it's a rest parameter or not.
                 */
                setIsRestParameter(value: boolean): this; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isOptional Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if it's optional. */
                isOptional(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Remove this parameter. */
                remove(): void; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ParameterDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ParameterDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setHasQuestionToken Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets if this node has a question token.
                 * @param value - If it should have a question token or not.
                 */
                setHasQuestionToken(value: boolean): this; // ------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setInitializer Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the initializer.
                 * @param text - Text or writer function to set for the initializer.
                 */
                setInitializer(textOrWriterFunction: string | WriterFunction): this; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the type.
                 * @param textOrWriterFunction - Text or writer function to set the type with.
                 */
                setType(textOrWriterFunction: string | WriterFunction): this; // ------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ParameterDeclaration>; // --------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ParameterDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeNodes Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets all the type nodes for the heritage clause. */
                getTypeNodes(): ExpressionWithTypeArguments[]; // -------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getToken Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets the heritage clause token. */
                getToken(): SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
removeExpression Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Remove the expression from the heritage clause.
                 * @param index - Index of the expression to remove.
                 */
                removeExpression(index: number): this; // -------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
removeExpression Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the expression from the heritage clause.
                 * @param expressionNode - Expression to remove.
                 */
                removeExpression(expressionNode: ExpressionWithTypeArguments): this; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.HeritageClause>; // ---------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.HeritageClause>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<CallSignatureDeclarationStructure>): this; // --------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): CallSignatureDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.CallSignatureDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.CallSignatureDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ConstructSignatureDeclarationStructure>): this; // ------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ConstructSignatureDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ConstructSignatureDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ConstructSignatureDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getKeyName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the key name. */
                getKeyName(): string; // -------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setKeyName Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the key name.
                 * @param name - New name.
                 */
                setKeyName(name: string): void; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getKeyNameNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the key name node. */
                getKeyNameNode(): BindingName; // -------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getKeyType Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the key type. */
                getKeyType(): Type; // ------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setKeyType Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the key type.
                 * @param type - Type.
                 */
                setKeyType(type: string): this; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getKeyTypeNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the key type node. */
                getKeyTypeNode(): TypeNode; // ----------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<IndexSignatureDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): IndexSignatureDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.IndexSignatureDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.IndexSignatureDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getBaseTypes Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the base types. */
                getBaseTypes(): Type[]; // --------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getBaseDeclarations Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets the base declarations. */
                getBaseDeclarations(): (TypeAliasDeclaration | InterfaceDeclaration | ClassDeclaration)[]; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getImplementations Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets all the implementations of the interface.
                 *
                 * This is similar to "go to implementation."
                 */
                getImplementations(): ImplementationLocation[]; // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<InterfaceDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): InterfaceDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.InterfaceDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.InterfaceDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<MethodSignatureStructure>): this; // --------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): MethodSignatureStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.MethodSignature>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.MethodSignature>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<PropertySignatureStructure>): this; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): PropertySignatureStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.PropertySignature>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.PropertySignature>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes the member. */
                remove(): void; // ----------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
JsxAttributedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function JsxAttributedNode<T extends Constructor<JsxAttributedNodeExtensionType>>(Base: T): Constructor<JsxAttributedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
JsxTagNamedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
                
            export declare function JsxTagNamedNode<T extends Constructor<JsxTagNamedNodeExtensionType>>(Base: T): Constructor<JsxTagNamedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
getInitializerOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets the JSX attribute's initializer or throws if it doesn't exist. */
                getInitializerOrThrow(): StringLiteral | JsxExpression; // -------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getInitializer Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JSX attribute's initializer or returns undefined if it doesn't exist. */
                getInitializer(): StringLiteral | JsxExpression | undefined; // -------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
setInitializer Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the initializer.
                 * @param textOrWriterFunction - Text or writer function to set the initializer with.
                 * @remarks You need to provide the quotes or braces.
                 */
                setInitializer(textOrWriterFunction: string | WriterFunction): this; // ------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
removeInitializer Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Removes the initializer. */
                removeInitializer(): this; // ------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes the JSX attribute. */
                remove(): void; // ------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<JsxAttributeStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): JsxAttributeStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxAttribute>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxAttribute>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxClosingElement>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxClosingElement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxClosingFragment>; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxClosingFragment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJsxChildren Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the children of the JSX element. */
                getJsxChildren(): JsxChild[]; // --------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getOpeningElement Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the opening element. */
                getOpeningElement(): JsxOpeningElement; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getClosingElement Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the closing element. */
                getClosingElement(): JsxClosingElement; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setBodyText Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the body text.
                 * @param textOrWriterFunction - Text or writer function to set as the body.
                 */
                setBodyText(textOrWriterFunction: string | WriterFunction): this; // ------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setBodyTextInline Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the body text without surrounding new lines.
                 * @param textOrWriterFunction - Text to set as the body.
                 */
                setBodyTextInline(textOrWriterFunction: string | WriterFunction): this; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<JsxElementStructure>): this; // --------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): JsxElementStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxElement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxElement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxExpression>; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getJsxChildren Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the children of the JSX fragment. */
                getJsxChildren(): JsxChild[]; // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getOpeningFragment Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the opening fragment. */
                getOpeningFragment(): JsxOpeningFragment; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getClosingFragment Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the closing fragment. */
                getClosingFragment(): JsxClosingFragment; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxFragment>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxFragment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxOpeningElement>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxOpeningElement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxOpeningFragment>; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxOpeningFragment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<JsxSelfClosingElementStructure>): this; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): JsxSelfClosingElementStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxSelfClosingElement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxSelfClosingElement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes the JSX spread attribute. */
                remove(): void; // ----------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<JsxSpreadAttributeStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): JsxSpreadAttributeStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxSpreadAttribute>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxSpreadAttribute>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
containsOnlyTriviaWhiteSpaces Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets if the JSX text contains only white spaces. */
                containsOnlyTriviaWhiteSpaces(): boolean; // ------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.JsxText>; // -------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.JsxText>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLiteralValue Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets the BigInt literal value.
                 *
                 * Assert this as a `bigint` in environments that support it.
                 */
                getLiteralValue(): unknown; // -------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setLiteralValue Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the bigint literal value.
                 * @param value - Value to set (must provide a bigint here at runtime).
                 */
                setLiteralValue(value: unknown): this; // ---------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.BigIntLiteral>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.BigIntLiteral>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLiteralValue Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets the literal value. */
                getLiteralValue(): boolean; // ----------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setLiteralValue Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the literal value.
                 *
                 * Note: For the time being, this forgets the current node and returns the new node.
                 * @param value - Value to set.
                 */
                setLiteralValue(value: boolean): BooleanLiteral; // ------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.BooleanLiteral>; // -------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.BooleanLiteral>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NullLiteral>; // --------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NullLiteral>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLiteralValue Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets the literal value. */
                getLiteralValue(): number; // ------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setLiteralValue Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the literal value.
                 * @param value - Value to set.
                 */
                setLiteralValue(value: number): this; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NumericLiteral>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NumericLiteral>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLiteralValue Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the literal value. */
                getLiteralValue(): RegExp; // ------------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setLiteralValue Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the literal value according to a pattern and some flags.
                 * @param pattern - Pattern.
                 * @param flags - Flags.
                 */
                setLiteralValue(pattern: string, flags?: string): this; // ---------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setLiteralValue Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the literal value according to a regular expression object.
                 * @param regExp - Regular expression.
                 */
                setLiteralValue(regExp: RegExp): this; // ------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.RegularExpressionLiteral>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.RegularExpressionLiteral>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLiteralValue Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets the literal value.
                 *
                 * This is equivalent to .getLiteralText() for string literals and only exists for consistency with other literals.
                 */
                getLiteralValue(): string; // ------------------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setLiteralValue Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the literal value.
                 * @param value - Value to set.
                 */
                setLiteralValue(value: string): this; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getQuoteKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the quote kind. */
                getQuoteKind(): QuoteKind; // ------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.StringLiteral>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.StringLiteral>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLiteralValue Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the literal value. */
                getLiteralValue(): string; // --------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setLiteralValue Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the literal value.
                 *
                 * Note: This could possibly replace the node if you add a tagged template.
                 * @param value - Value to set.
                 * @returns The new node if the kind changed; the current node otherwise.
                 */
                setLiteralValue(value: string): TemplateLiteral; // ---------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NoSubstitutionTemplateLiteral>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NoSubstitutionTemplateLiteral>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTag Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the tag. */
                getTag(): LeftHandSideExpression; // ----------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getTemplate Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the template literal. */
                getTemplate(): TemplateLiteral; // --------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
removeTag Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the tag from the tagged template.
                 * @returns The new template expression.
                 */
                removeTag(): TemplateLiteral; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TaggedTemplateExpression>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TaggedTemplateExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getHead Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the template head. */
                getHead(): TemplateHead; // -------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getTemplateSpans Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the template spans. */
                getTemplateSpans(): TemplateSpan[]; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setLiteralValue Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the literal value.
                 *
                 * Note: This could possibly replace the node if you remove all the tagged templates.
                 * @param value - Value to set.
                 * @returns The new node if the kind changed; the current node otherwise.
                 */
                setLiteralValue(value: string): TemplateLiteral; // -------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TemplateExpression>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TemplateExpression>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TemplateHead>; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TemplateHead>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TemplateMiddle>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TemplateMiddle>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLiteral Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets the template literal. */
                getLiteral(): TemplateMiddle | TemplateTail; // ------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TemplateSpan>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TemplateSpan>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TemplateTail>; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TemplateTail>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isExportEquals Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets if this is an export equals assignment.
                 *
                 * If this is false, then it's `export default`.
                 */
                isExportEquals(): boolean; // ------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setIsExportEquals Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets if this is an export equals assignment or export default.
                 * @param value - Whether it should be an export equals assignment.
                 */
                setIsExportEquals(value: boolean): this; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ExportAssignmentStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ExportAssignmentStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ExportAssignment>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ExportAssignment>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeOnly Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets if this export declaration is type only. */
                isTypeOnly(): boolean; // ------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setIsTypeOnly Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Sets if this export declaration is type only. */
                setIsTypeOnly(value: boolean): this; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNamespaceExport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace export or returns undefined if it doesn't exist. (ex. `* as ns`, but not `*`). */
                getNamespaceExport(): NamespaceExport | undefined; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getNamespaceExportOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace export or throws if it doesn't exist. (ex. `* as ns`, but not `*`) */
                getNamespaceExportOrThrow(): NamespaceExport; // ------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setNamespaceExport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Sets the namespace export name. */
                setNamespaceExport(name: string): this; // ------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setModuleSpecifier Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the import specifier.
                 * @param text - Text to set as the module specifier.
                 */
                setModuleSpecifier(text: string): this; // --------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setModuleSpecifier Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the import specifier.
                 * @param sourceFile - Source file to set the module specifier from.
                 */
                setModuleSpecifier(sourceFile: SourceFile): this; // -------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getModuleSpecifier Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the module specifier or undefined if it doesn't exist. */
                getModuleSpecifier(): StringLiteral | undefined; // ------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getModuleSpecifierValue Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the module specifier value or undefined if it doesn't exist. */
                getModuleSpecifierValue(): string | undefined; // --------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getModuleSpecifierSourceFileOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file referenced in the module specifier or throws if it can't find it or it doesn't exist. */
                getModuleSpecifierSourceFileOrThrow(): SourceFile; // ---------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getModuleSpecifierSourceFile Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file referenced in the module specifier. */
                getModuleSpecifierSourceFile(): SourceFile | undefined; // --------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isModuleSpecifierRelative Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the module specifier starts with `./` or `../`. */
                isModuleSpecifierRelative(): boolean; // -------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
removeModuleSpecifier Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Removes the module specifier. */
                removeModuleSpecifier(): this; // -------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
hasModuleSpecifier Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the module specifier exists */
                hasModuleSpecifier(): boolean; // ------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isNamespaceExport Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this export declaration is a namespace export. */
                isNamespaceExport(): boolean; // --------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
hasNamedExports Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the export declaration has named exports. */
                hasNamedExports(): boolean; // ------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
addNamedExport Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a named export.
                 * @param namedExport - Structure, name, or writer function to write the named export.
                 */
                addNamedExport(namedExport: OptionalKind<ExportSpecifierStructure> | string | WriterFunction): ExportSpecifier; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addNamedExports Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds named exports.
                 * @param namedExports - Structures, names, or writer function to write the named exports.
                 */
                addNamedExports(namedExports: ReadonlyArray<OptionalKind<ExportSpecifierStructure> | string | WriterFunction> | WriterFunction): ExportSpecifier[]; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
insertNamedExport Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a named export.
                 * @param index - Child index to insert at.
                 * @param namedExport - Structure, name, or writer function to write the named export.
                 */
                insertNamedExport(index: number, namedExport: OptionalKind<ExportSpecifierStructure> | string | WriterFunction): ExportSpecifier; // ------------------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
insertNamedExports Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts named exports into the export declaration.
                 * @param index - Child index to insert at.
                 * @param namedExports - Structures, names, or writer funciton to write the named exports.
                 */
                insertNamedExports(index: number, namedExports: ReadonlyArray<OptionalKind<ExportSpecifierStructure> | string | WriterFunction> | WriterFunction): ExportSpecifier[]; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
getNamedExports Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the named exports. */
                getNamedExports(): ExportSpecifier[]; // --------------------------------------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
toNamespaceExport Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Changes the export declaration to namespace export. Removes all the named exports. */
                toNamespaceExport(): this; // ---------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ExportDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ExportDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ExportDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ExportDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setName Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Sets the name of what's being exported. */
                setName(name: string): this; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name of the export specifier. */
                getName(): string; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNameNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name node of what's being exported. */
                getNameNode(): Identifier; // -------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
renameAlias Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the alias for the name being exported and renames all the usages.
                 * @param alias - Alias to set.
                 */
                renameAlias(alias: string): this; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setAlias Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the alias without renaming all the usages.
                 * @param alias - Alias to set.
                 */
                setAlias(alias: string): this; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeAlias Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the alias without renaming.
                 * @remarks Use removeAliasWithRename() if you want it to rename any usages to the name of the export specifier.
                 */
                removeAlias(): this; // --------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
removeAliasWithRename Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Removes the alias and renames any usages to the name of the export specifier. */
                removeAliasWithRename(): this; // ------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getAliasNode Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the alias identifier, if it exists. */
                getAliasNode(): Identifier | undefined; // --------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getExportDeclaration Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the export declaration associated with this export specifier. */
                getExportDeclaration(): ExportDeclaration; // -------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getLocalTargetSymbolOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the local target symbol of the export specifier or throws if it doesn't exist. */
                getLocalTargetSymbolOrThrow(): Symbol; // ----------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getLocalTargetSymbol Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the local target symbol of the export specifier or undefined if it doesn't exist. */
                getLocalTargetSymbol(): Symbol | undefined; // --------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getLocalTargetDeclarations Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets all the declarations referenced by the export specifier. */
                getLocalTargetDeclarations(): LocalTargetDeclarations[]; // ------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes the export specifier. */
                remove(): void; // ------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ExportSpecifierStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ExportSpecifierStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ExportSpecifier>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ExportSpecifier>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getReferencedSourceFileOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the source file referenced or throws if it can't find it. */
                getReferencedSourceFileOrThrow(): SourceFile; // -------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isRelative Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the external module reference is relative. */
                isRelative(): boolean; // ------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getReferencedSourceFile Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file referenced or returns undefined if it can't find it. */
                getReferencedSourceFile(): SourceFile | undefined; // ------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ExternalModuleReference>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ExternalModuleReference>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeOnly Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets if this import clause is type only. */
                isTypeOnly(): boolean; // ---------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setIsTypeOnly Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Sets if this import declaration is type only. */
                setIsTypeOnly(value: boolean): this; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDefaultImportOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default import or throws if it doesn't exit. */
                getDefaultImportOrThrow(): Identifier; // ----------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDefaultImport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default import or returns undefined if it doesn't exist. */
                getDefaultImport(): Identifier | undefined; // ------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getNamedBindingsOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the named bindings of the import clause or throws if it doesn't exist. */
                getNamedBindingsOrThrow(): NamespaceImport | NamedImports; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getNamedBindings Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the named bindings of the import clause or returns undefined if it doesn't exist. */
                getNamedBindings(): NamespaceImport | NamedImports | undefined; // ------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getNamespaceImportOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace import if it exists or throws. */
                getNamespaceImportOrThrow(): Identifier; // ------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNamespaceImport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace import identifier, if it exists. */
                getNamespaceImport(): Identifier | undefined; // -------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getNamedImports Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace import identifier, if it exists. */
                getNamedImports(): ImportSpecifier[]; // ---------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ImportClause>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ImportClause>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isTypeOnly Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
            
                /** Gets if this import declaration is type only. */
                isTypeOnly(): boolean; // ------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setIsTypeOnly Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Sets if this import declaration is type only. */
                setIsTypeOnly(value: boolean): this; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setModuleSpecifier Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the import specifier.
                 * @param text - Text to set as the module specifier.
                 */
                setModuleSpecifier(text: string): this; // --------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setModuleSpecifier Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the import specifier.
                 * @param sourceFile - Source file to set the module specifier from.
                 */
                setModuleSpecifier(sourceFile: SourceFile): this; // -------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getModuleSpecifier Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the module specifier. */
                getModuleSpecifier(): StringLiteral; // -------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getModuleSpecifierValue Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the module specifier string literal value. */
                getModuleSpecifierValue(): string; // --------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getModuleSpecifierSourceFileOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file referenced in the module specifier or throws if it can't find it. */
                getModuleSpecifierSourceFileOrThrow(): SourceFile; // -------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getModuleSpecifierSourceFile Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file referenced in the module specifier or returns undefined if it can't find it. */
                getModuleSpecifierSourceFile(): SourceFile | undefined; // -------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isModuleSpecifierRelative Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the module specifier starts with `./` or `../`. */
                isModuleSpecifierRelative(): boolean; // -------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setDefaultImport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the default import.
                 * @param text - Text to set as the default import.
                 * @remarks Use renameDefaultImport to rename.
                 */
                setDefaultImport(text: string): this; // --------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
renameDefaultImport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Renames or sets the provided default import.
                 * @param text - Text to set or rename the default import with.
                 */
                renameDefaultImport(text: string): this; // ------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDefaultImportOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default import or throws if it doesn't exit. */
                getDefaultImportOrThrow(): Identifier; // ----------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDefaultImport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default import or returns undefined if it doesn't exist. */
                getDefaultImport(): Identifier | undefined; // ------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setNamespaceImport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the namespace import.
                 * @param text - Text to set as the namespace import.
                 * @throws - InvalidOperationError if a named import exists.
                 */
                setNamespaceImport(text: string): this; // ---------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeNamespaceImport Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Removes the namespace import. */
                removeNamespaceImport(): this; // ---------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
removeDefaultImport Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Removes the default import. */
                removeDefaultImport(): this; // ------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getNamespaceImportOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace import if it exists or throws. */
                getNamespaceImportOrThrow(): Identifier; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNamespaceImport Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace import identifier, if it exists. */
                getNamespaceImport(): Identifier | undefined; // -------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
addNamedImport Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds a named import.
                 * @param namedImport - Name, structure, or writer to write the named import with.
                 */
                addNamedImport(namedImport: OptionalKind<ImportSpecifierStructure> | string | WriterFunction): ImportSpecifier; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
addNamedImports Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds named imports.
                 * @param namedImport - Structures, names, or writer function to write the named import with.
                 */
                addNamedImports(namedImports: ReadonlyArray<OptionalKind<ImportSpecifierStructure> | string | WriterFunction> | WriterFunction): ImportSpecifier[]; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
insertNamedImport Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a named import.
                 * @param index - Child index to insert at.
                 * @param namedImport - Structure, name, or writer function to write the named import with.
                 */
                insertNamedImport(index: number, namedImport: OptionalKind<ImportSpecifierStructure> | string | WriterFunction): ImportSpecifier; // ------------------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
insertNamedImports Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts named imports into the import declaration.
                 * @param index - Child index to insert at.
                 * @param namedImports - Structures, names, or writer function to write the named import with.
                 */
                insertNamedImports(index: number, namedImports: ReadonlyArray<OptionalKind<ImportSpecifierStructure> | string | WriterFunction> | WriterFunction): ImportSpecifier[]; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
getNamedImports Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the named imports. */
                getNamedImports(): ImportSpecifier[]; // --------------------------------------------------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeNamedImports Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes all the named imports.
                 * @remarks To remove a single named import, get the named import and call `#remove()` on it.
                 */
                removeNamedImports(): this; // ------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getImportClauseOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the import clause or throws if it doesn't exist. */
                getImportClauseOrThrow(): ImportClause; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getImportClause Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the import clause or returns undefined if it doesn't exist. */
                getImportClause(): ImportClause | undefined; // ---------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ImportDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ImportDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ImportDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ImportDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getModuleReference Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the module reference of the import equals declaration. */
                getModuleReference(): ModuleReference; // --------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isExternalModuleReferenceRelative Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the external module reference is relative. */
                isExternalModuleReferenceRelative(): boolean; // ------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setExternalModuleReference Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the external module reference.
                 * @param externalModuleReference - External module reference as a string.
                 */
                setExternalModuleReference(externalModuleReference: string): this; // --------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setExternalModuleReference Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the external module reference.
                 * @param sourceFile - Source file to set the external module reference to.
                 */
                setExternalModuleReference(sourceFile: SourceFile): this; // ------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getExternalModuleReferenceSourceFileOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file referenced in the external module reference or throws if it doesn't exist. */
                getExternalModuleReferenceSourceFileOrThrow(): SourceFile; // --------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getExternalModuleReferenceSourceFile Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file referenced in the external module reference or returns undefined if it doesn't exist. */
                getExternalModuleReferenceSourceFile(): SourceFile | undefined; // --------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ImportEqualsDeclaration>; // -------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ImportEqualsDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setName Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the identifier being imported.
                 * @param name - Name being imported.
                 */
                setName(name: string): this; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name of the import specifier. */
                getName(): string; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNameNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name node of what's being imported. */
                getNameNode(): Identifier; // -------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
renameAlias Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the alias for the name being imported and renames all the usages.
                 * @param alias - Alias to set.
                 */
                renameAlias(alias: string): this; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setAlias Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the alias without renaming all the usages.
                 * @param alias - Alias to set.
                 */
                setAlias(alias: string): this; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeAlias Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the alias without renaming.
                 * @remarks Use removeAliasWithRename() if you want it to rename any usages to the name of the import specifier.
                 */
                removeAlias(): this; // --------------------------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
removeAliasWithRename Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Removes the alias and renames any usages to the name of the import specifier. */
                removeAliasWithRename(): this; // ------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getAliasNode Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the alias identifier, if it exists. */
                getAliasNode(): Identifier | undefined; // --------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getImportDeclaration Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the import declaration associated with this import specifier. */
                getImportDeclaration(): ImportDeclaration; // -------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Remove the import specifier. */
                remove(): void; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<ImportSpecifierStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): ImportSpecifierStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ImportSpecifier>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ImportSpecifier>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ModuleBlock>; // --------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ModuleBlock>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getElements Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the export specifiers. */
                getElements(): ExportSpecifier[]; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NamedExports>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NamedExports>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getElements Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the import specifiers. */
                getElements(): ImportSpecifier[]; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NamedImports>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NamedImports>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
NamespaceChildableNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function NamespaceChildableNode<T extends Constructor<NamespaceChildableNodeExtensionType>>(Base: T): Constructor<NamespaceChildableNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the full name of the namespace. */
                getName(): string; // -------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setName Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the name without renaming references.
                 * @param newName - New full namespace name.
                 */
                setName(newName: string): this; // --------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
rename Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Renames the name.
                 * @param newName - New name.
                 */
                rename(newName: string): this; // -------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getNameNodes Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name nodes. */
                getNameNodes(): Identifier[]; // -------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
hasNamespaceKeyword Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this namespace has a namespace keyword. */
                hasNamespaceKeyword(): boolean; // ------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
hasModuleKeyword Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this namespace has a namespace keyword. */
                hasModuleKeyword(): boolean; // --------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
setDeclarationKind Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the namespace declaration kind.
                 * @param kind - Kind to set.
                 */
                setDeclarationKind(kind: NamespaceDeclarationKind): this; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDeclarationKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namesapce declaration kind. */
                getDeclarationKind(): NamespaceDeclarationKind; // ----------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDeclarationKindKeyword Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace or module keyword or returns undefined if it's global. */
                getDeclarationKindKeyword(): Node<ts.Node> | undefined; // -------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<NamespaceDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): NamespaceDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NamespaceDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NamespaceDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setName Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Sets the name of the namespace export. */
                setName(name: string): this; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name of the namespace export. */
                getName(): string; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNameNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace export's name node. */
                getNameNode(): Identifier; // -------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NamespaceExport>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NamespaceExport>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setName Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Sets the name of the namespace import. */
                setName(name: string): this; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name of the namespace import. */
                getName(): string; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNameNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the namespace import's name node. */
                getNameNode(): Identifier; // -------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NamespaceImport>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NamespaceImport>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
Complexity Index 0.5 Cyclomatic complexity 0
                            
                                
            
                constructor(compilerObject: ts.FileReference, sourceFile: SourceFile); // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getFileName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the referenced file name. */
                getFileName(): string; // ------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                
                private constructor();
            
                            
                        
getFilePath Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file path. */
                getFilePath(): StandardizedFilePath; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getBaseName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file path's base name. */
                getBaseName(): string; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getBaseNameWithoutExtension Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file path's base name without the extension. */
                getBaseNameWithoutExtension(): string; // ----------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getExtension Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file path's extension. */
                getExtension(): string; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDirectory Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the directory that the source file is contained in. */
                getDirectory(): Directory; // -------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDirectoryPath Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the directory path that the source file is contained in. */
                getDirectoryPath(): StandardizedFilePath; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFullText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the full text with leading trivia. */
                getFullText(): string; // ------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getLineAndColumnAtPos Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the line and column number at the provided position (1-indexed).
                 * @param pos - Position in the source file.
                 */
                getLineAndColumnAtPos(pos: number): { // ------------------------------------------ +0.2 Complexity index (+0.2 atomic)
                        line: number; // ---------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                        column: number; // -------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                    };
            
                            
                        
getLengthFromLineStartAtPos Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Gets the character count from the start of the line to the provided position.
                 * @param pos - Position.
                 */
                getLengthFromLineStartAtPos(pos: number): number; // -------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
copyToDirectory Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Copies this source file to the specified directory.
                 *
                 * This will modify the module specifiers in the new file, if necessary.
                 * @param dirPathOrDirectory Directory path or directory object to copy the file to.
                 * @param options Options for copying.
                 * @returns The source file the copy was made to.
                 */
                copyToDirectory(dirPathOrDirectory: string | Directory, options?: SourceFileCopyOptions): SourceFile; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
copy Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Copy this source file to a new file.
                 *
                 * This will modify the module specifiers in the new file, if necessary.
                 * @param filePath - New file path. Can be relative to the original file or an absolute path.
                 * @param options - Options for copying.
                 */
                copy(filePath: string, options?: SourceFileCopyOptions): SourceFile; // ---------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
copyImmediately Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Copy this source file to a new file and immediately saves it to the file system asynchronously.
                 *
                 * This will modify the module specifiers in the new file, if necessary.
                 * @param filePath - New file path. Can be relative to the original file or an absolute path.
                 * @param options - Options for copying.
                 */
                copyImmediately(filePath: string, options?: SourceFileCopyOptions): Promise<SourceFile>; // ----------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
copyImmediatelySync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Copy this source file to a new file and immediately saves it to the file system synchronously.
                 *
                 * This will modify the module specifiers in the new file, if necessary.
                 * @param filePath - New file path. Can be relative to the original file or an absolute path.
                 * @param options - Options for copying.
                 */
                copyImmediatelySync(filePath: string, options?: SourceFileCopyOptions): SourceFile; // --------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
moveToDirectory Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Moves this source file to the specified directory.
                 *
                 * This will modify the module specifiers in other files that specify this file and the module specifiers in the current file, if necessary.
                 * @param dirPathOrDirectory Directory path or directory object to move the file to.
                 * @param options Options for moving.
                 */
                moveToDirectory(dirPathOrDirectory: string | Directory, options?: SourceFileMoveOptions): SourceFile; // ---------------------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
move Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Moves this source file to a new file.
                 *
                 * This will modify the module specifiers in other files that specify this file and the module specifiers in the current file, if necessary.
                 * @param filePath - New file path. Can be relative to the original file or an absolute path.
                 * @param options - Options for moving.
                 */
                move(filePath: string, options?: SourceFileMoveOptions): SourceFile; // ------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
moveImmediately Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Moves this source file to a new file and asynchronously updates the file system immediately.
                 *
                 * This will modify the module specifiers in other files that specify this file and the module specifiers in the current file, if necessary.
                 * @param filePath - New file path. Can be relative to the original file or an absolute path.
                 * @param options - Options for moving.
                 */
                moveImmediately(filePath: string, options?: SourceFileMoveOptions): Promise<SourceFile>; // ----------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
moveImmediatelySync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Moves this source file to a new file and synchronously updates the file system immediately.
                 *
                 * This will modify the module specifiers in other files that specify this file and the module specifiers in the current file, if necessary.
                 * @param filePath - New file path. Can be relative to the original file or an absolute path.
                 * @param options - Options for moving.
                 */
                moveImmediatelySync(filePath: string, options?: SourceFileMoveOptions): SourceFile; // ---------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
delete Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Queues a deletion of the file to the file system.
                 *
                 * The file will be deleted when you call ast.save(). If you wish to immediately delete the file, then use deleteImmediately().
                 */
                delete(): void; // ----------------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
deleteImmediately Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Asynchronously deletes the file from the file system. */
                deleteImmediately(): Promise<void>; // -------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
deleteImmediatelySync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Synchronously deletes the file from the file system. */
                deleteImmediatelySync(): void; // ------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
save Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Asynchronously saves this file with any changes. */
                save(): Promise<void>; // ---------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
saveSync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Synchronously saves this file with any changes. */
                saveSync(): void; // -------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getPathReferenceDirectives Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets any `/// <reference path="..." />` comments. */
                getPathReferenceDirectives(): FileReference[]; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getTypeReferenceDirectives Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets any `/// <reference types="..." />` comments. */
                getTypeReferenceDirectives(): FileReference[]; // ------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getLibReferenceDirectives Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets any `/// <reference lib="..." />` comments. */
                getLibReferenceDirectives(): FileReference[]; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getReferencingSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets any source files that reference this source file. */
                getReferencingSourceFiles(): SourceFile[]; // -------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getReferencingNodesInOtherSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the import and exports in other source files that reference this source file. */
                getReferencingNodesInOtherSourceFiles(): SourceFileReferencingNodes[]; // -------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getReferencingLiteralsInOtherSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the string literals in other source files that reference this source file. */
                getReferencingLiteralsInOtherSourceFiles(): StringLiteral[]; // --------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getReferencedSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source files this source file references in string literals. */
                getReferencedSourceFiles(): SourceFile[]; // ------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getNodesReferencingOtherSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the nodes that reference other source files in string literals. */
                getNodesReferencingOtherSourceFiles(): SourceFileReferencingNodes[]; // -------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getLiteralsReferencingOtherSourceFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the string literals in this source file that references other source files.
                 * @remarks This is similar to `getImportStringLiterals()`, but `getImportStringLiterals()`
                 * will return import string literals that may not be referencing another source file
                 * or have not been able to be resolved.
                 */
                getLiteralsReferencingOtherSourceFiles(): StringLiteral[]; // ---------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getImportStringLiterals Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets all the descendant string literals that reference a module. */
                getImportStringLiterals(): StringLiteral[]; // ----------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getLanguageVersion Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the script target of the source file. */
                getLanguageVersion(): ScriptTarget; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getLanguageVariant Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the language variant of the source file. */
                getLanguageVariant(): LanguageVariant; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getScriptKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the script kind of the source file. */
                getScriptKind(): ScriptKind; // -------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isDeclarationFile Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a declaration file. */
                isDeclarationFile(): boolean; // -------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isFromExternalLibrary Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the source file was discovered while loading an external library. */
                isFromExternalLibrary(): boolean; // ------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isInNodeModules Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the source file is a descendant of a node_modules directory. */
                isInNodeModules(): boolean; // ------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isSaved Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this source file has been saved or if the latest changes have been saved. */
                isSaved(): boolean; // ---------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getPreEmitDiagnostics Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the pre-emit diagnostics of the specified source file. */
                getPreEmitDiagnostics(): Diagnostic[]; // ----------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
unindent Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ----------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
unindent Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // --------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
indent Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
indent Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
emit Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Asynchronously emits the source file as a JavaScript file. */
                emit(options?: SourceFileEmitOptions): Promise<EmitResult>; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
emitSync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Synchronously emits the source file as a JavaScript file. */
                emitSync(options?: SourceFileEmitOptions): EmitResult; // ----------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getEmitOutput Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the emit output of this source file.
                 * @param options - Emit options.
                 */
                getEmitOutput(options?: { // ------------------------------------ +0.2 Complexity index (+0.2 atomic)
                        emitOnlyDtsFiles?: boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
                    }): EmitOutput; // ------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
formatText Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Formats the source file text using the internal TypeScript formatting API.
                 * @param settings - Format code settings.
                 */
                formatText(settings?: FormatCodeSettings): void; // ------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
refreshFromFileSystem Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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>; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
refreshFromFileSystemSync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ---------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getRelativePathTo Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path to another source file.
                 * @param sourceFile - Source file.
                 */
                getRelativePathTo(sourceFile: SourceFile): string; // ---------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getRelativePathTo Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path to another directory.
                 * @param directory - Directory.
                 */
                getRelativePathTo(directory: Directory): string; // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getRelativePathAsModuleSpecifierTo Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path to the specified source file as a module specifier.
                 * @param sourceFile - Source file.
                 */
                getRelativePathAsModuleSpecifierTo(sourceFile: SourceFile): string; // ----------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getRelativePathAsModuleSpecifierTo Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path to the specified directory as a module specifier.
                 * @param directory - Directory.
                 */
                getRelativePathAsModuleSpecifierTo(directory: Directory): string; // ----------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
onModified Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Subscribe to when the source file is modified.
                 * @param subscription - Subscription.
                 * @param subscribe - Optional and defaults to true. Use an explicit false to unsubscribe.
                 */
                onModified(subscription: (sender: SourceFile) => void, subscribe?: boolean): this; // --------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
organizeImports Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Organizes the imports in the file.
                 *
                 * WARNING! This will forget all the nodes in the file! It's best to do this after you're all done with the file.
                 * @param formatSettings - Format code settings.
                 * @param userPreferences - User preferences for refactoring.
                 */
                organizeImports(formatSettings?: FormatCodeSettings, userPreferences?: UserPreferences): this; // -------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
fixUnusedIdentifiers Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes all unused declarations like interfaces, classes, enums, functions, variables, parameters,
                 * methods, properties, imports, etc. from this file.
                 *
                 * Tip: For optimal results, sometimes this method needs to be called more than once. There could be nodes
                 * that are only referenced in unused declarations and in this case, another call will also remove them.
                 *
                 * WARNING! This will forget all the nodes in the file! It's best to do this after you're all done with the file.
                 * @param formatSettings - Format code settings.
                 * @param userPreferences - User preferences for refactoring.
                 */
                fixUnusedIdentifiers(formatSettings?: FormatCodeSettings, userPreferences?: UserPreferences): this; // --------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
fixMissingImports Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Code fix to add import declarations for identifiers that are referenced, but not imported in the source file.
                 * @param formatSettings - Format code settings.
                 * @param userPreferences - User preferences for refactoring.
                 */
                fixMissingImports(formatSettings?: FormatCodeSettings, userPreferences?: UserPreferences): this; // ----------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
applyTextChanges Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Applies the text changes to the source file.
                 *
                 * WARNING! This will forget all the nodes in the file! It's best to do this after you're all done with the file.
                 * @param textChanges - Text changes.
                 */
                applyTextChanges(textChanges: ReadonlyArray<ts.TextChange | TextChange>): this; // ----------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<SourceFileStructure>): this; // ----------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): SourceFileStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SourceFile>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SourceFile>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
CommonIdentifierBase Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            declare function CommonIdentifierBase<T extends Constructor<CommonIdentifierBaseExtensionType>>(Base: T): Constructor<CommonIdentifierBase> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ComputedPropertyName>; // --------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ComputedPropertyName>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getImplementations Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets the implementations of the identifier.
                 *
                 * This is similar to "go to implementation."
                 */
                getImplementations(): ImplementationLocation[]; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.Identifier>; // ----------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.Identifier>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.PrivateIdentifier>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.PrivateIdentifier>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLeft Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the left side of the qualified name. */
                getLeft(): EntityName; // ------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getRight Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the right identifier of the qualified name. */
                getRight(): Identifier; // --------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.QualifiedName>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.QualifiedName>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.Block>; // --------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.Block>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLabel Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets this break statement's label or undefined if it does not exist. */
                getLabel(): Identifier | undefined; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getLabelOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets this break statement's label or throw if it does not exist. */
                getLabelOrThrow(): Identifier; // ------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.BreakStatement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.BreakStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getClauses Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the clauses. */
                getClauses(): CaseOrDefaultClause[]; // ----------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeClause Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the clause at the specified index.
                 * @param index - Index.
                 */
                removeClause(index: number): this; // ------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
removeClauses Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the clauses in the specified range.
                 * @param indexRange - Index range.
                 */
                removeClauses(indexRange: [number, number]): this; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.CaseBlock>; // --------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.CaseBlock>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes this case clause. */
                remove(): void; // ----------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.CaseClause>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.CaseClause>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getBlock Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets this catch clause's block. */
                getBlock(): Block; // ----------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getVariableDeclaration Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets this catch clause's variable declaration or undefined if none exists. */
                getVariableDeclaration(): VariableDeclaration | undefined; // ------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getVariableDeclarationOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets this catch clause's variable declaration or throws if none exists. */
                getVariableDeclarationOrThrow(): VariableDeclaration; // -------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.CatchClause>; // ---------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.CatchClause>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLabel Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets this continue statement's label or undefined if it does not exist. */
                getLabel(): Identifier | undefined; // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getLabelOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets this continue statement's label or throw if it does not exist. */
                getLabelOrThrow(): Identifier; // --------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ContinueStatement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ContinueStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.DebuggerStatement>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.DebuggerStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes the default clause. */
                remove(): void; // -------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.DefaultClause>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.DefaultClause>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.DoStatement>; // --------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.DoStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.EmptyStatement>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.EmptyStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ExpressionStatement>; // ------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ExpressionStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getInitializer Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets this for in statement's initializer. */
                getInitializer(): VariableDeclarationList | Expression; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ForInStatement>; // --------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ForInStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getInitializer Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets this for of statement's initializer. */
                getInitializer(): VariableDeclarationList | Expression; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ForOfStatement>; // --------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ForOfStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getInitializer Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets this for statement's initializer or undefined if none exists. */
                getInitializer(): VariableDeclarationList | Expression | undefined; // ------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getInitializerOrThrow Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets this for statement's initializer or throws if none exists. */
                getInitializerOrThrow(): Expression<ts.Expression> | VariableDeclarationList; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getCondition Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets this for statement's condition or undefined if none exists. */
                getCondition(): Expression | undefined; // --------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getConditionOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets this for statement's condition or throws if none exists. */
                getConditionOrThrow(): Expression<ts.Expression>; // -------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getIncrementor Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets this for statement's incrementor. */
                getIncrementor(): Expression | undefined; // --------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getIncrementorOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets this for statement's incrementor or throws if none exists. */
                getIncrementorOrThrow(): Expression<ts.Expression>; // -------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ForStatement>; // ------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ForStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getThenStatement Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets this if statement's then statement. */
                getThenStatement(): Statement; // ----------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getElseStatement Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets this if statement's else statement. */
                getElseStatement(): Statement | undefined; // ------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                remove(): void; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.IfStatement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.IfStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getStatement Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets this iteration statement's statement. */
                getStatement(): Statement; // ------------------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getLabel Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets this labeled statement's label */
                getLabel(): Identifier; // --------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getStatement Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets this labeled statement's statement */
                getStatement(): Statement; // --------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.LabeledStatement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.LabeledStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NotEmittedStatement>; // ------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NotEmittedStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ReturnStatement>; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ReturnStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes the statement. */
                remove(): void; // ------------------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
StatementedNode Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function StatementedNode<T extends Constructor<StatementedNodeExtensionType>>(Base: T): Constructor<StatementedNode> & T; // ------- +2.9 Complexity index (+0.9 atomic, +2 recursivity)
            
                            
                        
getCaseBlock Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets this switch statement's case block. */
                getCaseBlock(): CaseBlock; // --------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getClauses Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the switch statement's case block's clauses. */
                getClauses(): CaseOrDefaultClause[]; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeClause Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the specified clause based on the provided index.
                 * @param index - Index.
                 */
                removeClause(index: number): CaseBlock; // ---------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
removeClauses Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the specified clauses based on the provided index range.
                 * @param indexRange - Index range.
                 */
                removeClauses(indexRange: [number, number]): CaseBlock; // ------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.SwitchStatement>; // -------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.SwitchStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ThrowStatement>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ThrowStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTryBlock Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets this try statement's try block. */
                getTryBlock(): Block; // ----------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getCatchClause Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets this try statement's catch clause or undefined if none exists. */
                getCatchClause(): CatchClause | undefined; // --------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getCatchClauseOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets this try statement's catch clause or throws if none exists. */
                getCatchClauseOrThrow(): CatchClause; // ----------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFinallyBlock Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets this try statement's finally block or undefined if none exists. */
                getFinallyBlock(): Block | undefined; // --------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getFinallyBlockOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets this try statement's finally block or throws if none exists. */
                getFinallyBlockOrThrow(): Block; // ----------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TryStatement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TryStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDeclarationList Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Get variable declaration list. */
                getDeclarationList(): VariableDeclarationList; // ------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDeclarations Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Get the variable declarations. */
                getDeclarations(): VariableDeclaration[]; // ------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDeclarationKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the variable declaration kind. */
                getDeclarationKind(): VariableDeclarationKind; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDeclarationKindKeyword Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the variable declaration kind keyword. */
                getDeclarationKindKeyword(): Node<ts.Node>; // -------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
setDeclarationKind Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the variable declaration kind.
                 * @param type - Type to set.
                 */
                setDeclarationKind(type: VariableDeclarationKind): VariableDeclarationList; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
addDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Add a variable declaration to the statement.
                 * @param structure - Structure representing the variable declaration to add.
                 */
                addDeclaration(structure: OptionalKind<VariableDeclarationStructure>): VariableDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addDeclarations Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds variable declarations to the statement.
                 * @param structures - Structures representing the variable declarations to add.
                 */
                addDeclarations(structures: ReadonlyArray<OptionalKind<VariableDeclarationStructure>>): VariableDeclaration[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a variable declaration at the specified index within the statement.
                 * @param index - Child index to insert at.
                 * @param structure - Structure representing the variable declaration to insert.
                 */
                insertDeclaration(index: number, structure: OptionalKind<VariableDeclarationStructure>): VariableDeclaration; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertDeclarations Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts variable declarations at the specified index within the statement.
                 * @param index - Child index to insert at.
                 * @param structures - Structures representing the variable declarations to insert.
                 */
                insertDeclarations(index: number, structures: ReadonlyArray<OptionalKind<VariableDeclarationStructure>>): VariableDeclaration[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<VariableStatementStructure>): this; // ----------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): VariableStatementStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.VariableStatement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.VariableStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.WhileStatement>; // --------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.WhileStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getStatement Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets this with statement's statement. */
                getStatement(): Statement; // --------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.WithStatement>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.WithStatement>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getElementTypeNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the array type node's element type node. */
                getElementTypeNode(): TypeNode; // ------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ArrayTypeNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ArrayTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getCheckType Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets the conditional type node's check type.
                 *
                 * Ex. In `CheckType extends ExtendsType ? TrueType : FalseType` returns `CheckType`.
                 */
                getCheckType(): TypeNode<ts.TypeNode>; // ------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getExtendsType Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the conditional type node's extends type.
                 *
                 * Ex. In `CheckType extends ExtendsType ? TrueType : FalseType` returns `ExtendsType`.
                 */
                getExtendsType(): TypeNode<ts.TypeNode>; // ------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getTrueType Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the conditional type node's true type.
                 *
                 * Ex. In `CheckType extends ExtendsType ? TrueType : FalseType` returns `TrueType`.
                 */
                getTrueType(): TypeNode<ts.TypeNode>; // ------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getFalseType Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the conditional type node's false type.
                 *
                 * Ex. In `CheckType extends ExtendsType ? TrueType : FalseType` returns `FalseType`.
                 */
                getFalseType(): TypeNode<ts.TypeNode>; // ------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ConditionalTypeNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ConditionalTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ConstructorTypeNode>; // ----------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ConstructorTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeArguments Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the type arguments. */
                getTypeArguments(): TypeNode[]; // ---------------------------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ExpressionWithTypeArguments>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ExpressionWithTypeArguments>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.FunctionTypeNode>; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.FunctionTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
setArgument Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the argument text.
                 * @param text - Text of the argument.
                 */
                setArgument(text: string): this; // ------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getArgument Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the argument passed into the import type. */
                getArgument(): TypeNode; // ------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setQualifier Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the qualifier text.
                 * @param text - Text.
                 */
                setQualifier(text: string): this; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getQualifierOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the qualifier of the import type if it exists or throws */
                getQualifierOrThrow(): EntityName; // ---------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getQualifier Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the qualifier of the import type if it exists or returns undefined. */
                getQualifier(): EntityName | undefined; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ImportTypeNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ImportTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getObjectTypeNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets the indexed access type node's object type node.
                 *
                 * This is `MyObjectType` in `MyObjectType["myIndex"]`.
                 */
                getObjectTypeNode(): TypeNode; // ------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getIndexTypeNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the indexed access type node's index type node.
                 *
                 * This is `"myIndex"` in `MyObjectType["myIndex"]`.
                 */
                getIndexTypeNode(): TypeNode; // --------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.IndexedAccessTypeNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.IndexedAccessTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeParameter Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Gets the infer type node's type parameter.
                 *
                 * Ex. In `infer R` returns `R`.
                 */
                getTypeParameter(): TypeParameterDeclaration; // ----------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.InferTypeNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.InferTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeNodes Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the intersection type nodes. */
                getTypeNodes(): TypeNode[]; // ------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.IntersectionTypeNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.IntersectionTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getLiteral Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
            
                /** Gets the literal type node's literal. */
                getLiteral(): NullLiteral | BooleanLiteral | LiteralExpression | PrefixUnaryExpression; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.LiteralTypeNode>; // ---------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.LiteralTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeNode Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets the named tuple type's type. */
                getTypeNode(): TypeNode<ts.TypeNode>; // ------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
removeType Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Throws. This is not supported for NamedTupleMember. */
                removeType(): never; // --------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.NamedTupleMember>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.NamedTupleMember>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeNode Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the node within the parentheses. */
                getTypeNode(): TypeNode; // ------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the type within the parentheses.
                 * @param textOrWriterFunction - Text or writer function to set the type with.
                 */
                setType(textOrWriterFunction: string | WriterFunction): this; // ------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ParenthesizedTypeNode>; // -------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ParenthesizedTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.ThisTypeNode>; // --------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.ThisTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getElements Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
            
                /** Gets the tuple element type nodes. */
                getElements(): (TypeNode<ts.TypeNode> | NamedTupleMember)[]; // -------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TupleTypeNode>; // --------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TupleTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<TypeAliasDeclarationStructure>): this; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): TypeAliasDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TypeAliasDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TypeAliasDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TypeLiteralNode>; // ----------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TypeLiteralNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getConstraint Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the constraint of the type parameter. */
                getConstraint(): TypeNode | undefined; // ------------------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getConstraintOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the constraint of the type parameter or throws if it doesn't exist. */
                getConstraintOrThrow(): TypeNode<ts.TypeNode>; // ---------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
setConstraint Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the type parameter constraint.
                 * @param text - Text to set as the constraint.
                 */
                setConstraint(text: string | WriterFunction): this; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
removeConstraint Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Removes the constraint type node. */
                removeConstraint(): this; // --------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getDefault Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default node of the type parameter. */
                getDefault(): TypeNode | undefined; // ----------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDefaultOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default node of the type parameter or throws if it doesn't exist. */
                getDefaultOrThrow(): TypeNode<ts.TypeNode>; // --------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
setDefault Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the type parameter default type node.
                 * @param text - Text to set as the default type node.
                 */
                setDefault(text: string | WriterFunction): this; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
removeDefault Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Removes the default type node. */
                removeDefault(): this; // --------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Removes this type parameter. */
                remove(): void; // --------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<TypeParameterDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): TypeParameterDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TypeParameterDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TypeParameterDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getParameterNameNode Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
            
                /** Gets the parameter name node */
                getParameterNameNode(): Identifier | ThisTypeNode; // -------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
hasAssertsModifier Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the type predicate has an `asserts` modifier (ex. `asserts condition`). */
                hasAssertsModifier(): boolean; // --------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getAssertsModifier Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the asserts modifier if it exists. */
                getAssertsModifier(): Node<ts.AssertsKeyword> | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getAssertsModifierOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the asserts modifier if it exists or throws otherwise. */
                getAssertsModifierOrThrow(): Node<ts.AssertsKeyword>; // -------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getTypeNode Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the type name if it exists or returns undefined when it asserts a condition. */
                getTypeNode(): TypeNode | undefined; // ----------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getTypeNodeOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the type name if it exists or throws when it asserts a condition. */
                getTypeNodeOrThrow(): TypeNode; // ----------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TypePredicateNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TypePredicateNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the type name. */
                getTypeName(): EntityName; // -------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getTypeArguments Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the type arguments. */
                getTypeArguments(): TypeNode[]; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.TypeReferenceNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.TypeReferenceNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeNodes Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the union type nodes. */
                getTypeNodes(): TypeNode[]; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.UnionTypeNode>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.UnionTypeNode>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
remove Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Removes this variable declaration. */
                remove(): void; // -------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getVariableStatementOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the corresponding variable statement if it exists. Throws for variable declarations in for statements. */
                getVariableStatementOrThrow(): VariableStatement; // ------------------------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getVariableStatement Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the corresponding variable statement if it exists. Returns undefined for variable declarations in for statements. */
                getVariableStatement(): VariableStatement | undefined; // ------------------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the node from a structure.
                 * @param structure - Structure to set the node with.
                 */
                set(structure: Partial<VariableDeclarationStructure>): this; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStructure Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the structure equivalent to this node. */
                getStructure(): VariableDeclarationStructure; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.VariableDeclaration>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.VariableDeclaration>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDeclarations Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Get the variable declarations. */
                getDeclarations(): VariableDeclaration[]; // ------------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDeclarationKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the variable declaration kind. */
                getDeclarationKind(): VariableDeclarationKind; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDeclarationKindKeyword Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the variable declaration kind keyword. */
                getDeclarationKindKeyword(): Node; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setDeclarationKind Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the variable declaration kind.
                 * @param type - Type to set.
                 */
                setDeclarationKind(type: VariableDeclarationKind): this; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
addDeclaration Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Add a variable declaration to the statement.
                 * @param structure - Structure representing the variable declaration to add.
                 */
                addDeclaration(structure: OptionalKind<VariableDeclarationStructure>): VariableDeclaration; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
addDeclarations Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Adds variable declarations to the statement.
                 * @param structures - Structures representing the variable declarations to add.
                 */
                addDeclarations(structures: ReadonlyArray<OptionalKind<VariableDeclarationStructure>>): VariableDeclaration[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
insertDeclaration Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts a variable declaration at the specified index within the statement.
                 * @param index - Child index to insert at.
                 * @param structure - Structure representing the variable declaration to insert.
                 */
                insertDeclaration(index: number, structure: OptionalKind<VariableDeclarationStructure>): VariableDeclaration; // -------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
insertDeclarations Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts variable declarations at the specified index within the statement.
                 * @param index - Child index to insert at.
                 * @param structures - Structures representing the variable declarations to insert.
                 */
                insertDeclarations(index: number, structures: ReadonlyArray<OptionalKind<VariableDeclarationStructure>>): VariableDeclaration[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getParent Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParent(): NodeParentType<ts.VariableDeclarationList>; // ------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getParentOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc **/
                getParentOrThrow(): NonNullable<NodeParentType<ts.VariableDeclarationList>>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getTypeParameters Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the type parameters. */
                getTypeParameters(): TypeParameter[]; // -------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getParameters Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the parameters. */
                getParameters(): Symbol[]; // ------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getReturnType Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the signature return type. */
                getReturnType(): Type; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDocumentationComments Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Get the documentation comments. */
                getDocumentationComments(): SymbolDisplayPart[]; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getJsDocTags Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the JS doc tags. */
                getJsDocTags(): JSDocTagInfo[]; // ------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDeclaration Complexity Index 1.6 Cyclomatic complexity 1
                            
                                
                
                /** Gets the signature's declaration. */
                getDeclaration(): MethodSignature | MethodDeclaration | ConstructorDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | CallSignatureDeclaration | ConstructSignatureDeclaration | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | FunctionExpression | ArrowFunction | FunctionDeclaration | JSDocFunctionType; // ------- +1.6 Complexity index (+1.6 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the symbol name. */
                getName(): string; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getEscapedName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the escaped name. */
                getEscapedName(): string; // ----------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getAliasedSymbolOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the aliased symbol or throws if it doesn't exist. */
                getAliasedSymbolOrThrow(): Symbol; // ---------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getAliasedSymbol Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the aliased symbol or returns undefined if it doesn't exist. */
                getAliasedSymbol(): Symbol | undefined; // ---------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getExportSymbol Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the export symbol of the symbol if its a local symbol with a corresponding export symbol. Otherwise returns the current symbol.
                 *
                 * The following is from the compiler API documentation:
                 *
                 * For example, at `export type T = number;`:
                 *     - `getSymbolAtLocation` at the location `T` will return the exported symbol for `T`.
                 *     - But the result of `getSymbolsInScope` will contain the *local* symbol for `T`, not the exported symbol.
                 *     - Calling `getExportSymbol` on that local symbol will return the exported symbol.
                 */
                getExportSymbol(): Symbol; // -------------------------------------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isAlias Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the symbol is an alias. */
                isAlias(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getFlags Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the symbol flags. */
                getFlags(): SymbolFlags; // ------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
hasFlags Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the symbol has the specified flags.
                 * @param flags - Flags to check if the symbol has.
                 */
                hasFlags(flags: SymbolFlags): boolean; // -------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getValueDeclarationOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the value declaration of a symbol or throws if it doesn't exist. */
                getValueDeclarationOrThrow(): Node; // ------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getValueDeclaration Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the value declaration of the symbol or returns undefined if it doesn't exist. */
                getValueDeclaration(): Node | undefined; // -------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDeclarations Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the symbol declarations. */
                getDeclarations(): Node[]; // --------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getExportOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the export of the symbol by the specified name or throws if not exists.
                 * @param name - Name of the export.
                 */
                getExportOrThrow(name: string): Symbol; // ----------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getExport Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the export of the symbol by the specified name or returns undefined if not exists.
                 * @param name - Name of the export.
                 */
                getExport(name: string): Symbol | undefined; // ----------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getExports Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the exports from the symbol. */
                getExports(): Symbol[]; // ---------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getGlobalExportOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the global export of the symbol by the specified name or throws if not exists.
                 * @param name - Name of the global export.
                 */
                getGlobalExportOrThrow(name: string): Symbol; // ------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getGlobalExport Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the global export of the symbol by the specified name or returns undefined if not exists.
                 * @param name - Name of the global export.
                 */
                getGlobalExport(name: string): Symbol | undefined; // ------------------------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getGlobalExports Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the global exports from the symbol. */
                getGlobalExports(): Symbol[]; // ---------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getMemberOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the member of the symbol by the specified name or throws if not exists.
                 * @param name - Name of the export.
                 */
                getMemberOrThrow(name: string): Symbol; // ----------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getMember Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the member of the symbol by the specified name or returns undefined if not exists.
                 * @param name - Name of the member.
                 */
                getMember(name: string): Symbol | undefined; // ----------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getMembers Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the members of the symbol */
                getMembers(): Symbol[]; // ---------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDeclaredType Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the declared type of the symbol. */
                getDeclaredType(): Type; // --------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getTypeAtLocation Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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>; // ----------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getFullyQualifiedName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the fully qualified name. */
                getFullyQualifiedName(): string; // -------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getProgram Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the language service's program. */
                getProgram(): Program; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDefinitions Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the definitions for the specified node.
                 * @param node - Node.
                 */
                getDefinitions(node: Node): DefinitionInfo[]; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDefinitionsAtPosition Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the definitions at the specified position.
                 * @param sourceFile - Source file.
                 * @param pos - Position.
                 */
                getDefinitionsAtPosition(sourceFile: SourceFile, pos: number): DefinitionInfo[]; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getImplementations Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the implementations for the specified node.
                 * @param node - Node.
                 */
                getImplementations(node: Node): ImplementationLocation[]; // ------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getImplementationsAtPosition Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the implementations at the specified position.
                 * @param sourceFile - Source file.
                 * @param pos - Position.
                 */
                getImplementationsAtPosition(sourceFile: SourceFile, pos: number): ImplementationLocation[]; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
findReferences Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Finds references based on the specified node.
                 * @param node - Node to find references for.
                 */
                findReferences(node: Node): ReferencedSymbol[]; // ---------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
findReferencesAsNodes Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Finds the nodes that reference the definition(s) of the specified node.
                 * @param node - Node.
                 */
                findReferencesAsNodes(node: Node): Node<ts.Node>[]; // ------------------------------ +0.7 Complexity index (+0.7 atomic)
            
                            
                        
findReferencesAtPosition Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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[]; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
findRenameLocations Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Find the rename locations for the specified node.
                 * @param node - Node to get the rename locations for.
                 * @param options - Options for renaming.
                 */
                findRenameLocations(node: Node, options?: RenameOptions): RenameLocation[]; // -------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getSuggestionDiagnostics Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the suggestion diagnostics.
                 * @param filePathOrSourceFile - The source file or file path to get suggestions for.
                 */
                getSuggestionDiagnostics(filePathOrSourceFile: SourceFile | string): DiagnosticWithLocation[]; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getFormattingEditsForRange Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the formatting edits for a range.
                 * @param filePath - File path.
                 * @param range - Position range.
                 * @param formatSettings - Format code settings.
                 */
                getFormattingEditsForRange(filePath: string, range: [number, number], formatSettings: FormatCodeSettings): TextChange[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getFormattingEditsForDocument Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the formatting edits for a document.
                 * @param filePath - File path of the source file.
                 * @param formatSettings - Format code settings.
                 */
                getFormattingEditsForDocument(filePath: string, formatSettings: FormatCodeSettings): TextChange[]; // ----------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getFormattedDocumentText Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the formatted text for a document.
                 * @param filePath - File path of the source file.
                 * @param formatSettings - Format code settings.
                 */
                getFormattedDocumentText(filePath: string, formatSettings: FormatCodeSettings): string; // ------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getEmitOutput Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ---------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getEmitOutput Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getIdentationAtPosition Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the indentation at the specified position.
                 * @param sourceFile - Source file.
                 * @param position - Position.
                 * @param settings - Editor settings.
                 */
                getIdentationAtPosition(sourceFile: SourceFile, position: number, settings?: EditorSettings): number; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getIdentationAtPosition Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the indentation at the specified position.
                 * @param filePath - File path.
                 * @param position - Position.
                 * @param settings - Editor settings.
                 */
                getIdentationAtPosition(filePath: string, position: number, settings?: EditorSettings): number; // ------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
organizeImports Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the file text changes for organizing the imports in a source file.
                 *
                 * @param sourceFile - Source file.
                 * @param formatSettings - Format code settings.
                 * @param userPreferences - User preferences for refactoring.
                 */
                organizeImports(sourceFile: SourceFile, formatSettings?: FormatCodeSettings, userPreferences?: UserPreferences): FileTextChanges[]; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
organizeImports Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the file text changes for organizing the imports in a source file.
                 *
                 * @param filePath - File path of the source file.
                 * @param formatSettings - Format code settings.
                 * @param userPreferences - User preferences for refactoring.
                 */
                organizeImports(filePath: string, formatSettings?: FormatCodeSettings, userPreferences?: UserPreferences): FileTextChanges[]; // ------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
getEditsForRefactor Complexity Index 1.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the edit information for applying a refactor at a the provided position in a source file.
                 * @param filePathOrSourceFile - File path or source file to get the edits for.
                 * @param formatSettings - Fomat code settings.
                 * @param positionOrRange - Position in the source file where to apply given refactor.
                 * @param refactorName - Refactor name.
                 * @param actionName - Refactor action name.
                 * @param preferences - User preferences for refactoring.
                 */
                getEditsForRefactor(filePathOrSourceFile: string | SourceFile, formatSettings: FormatCodeSettings, positionOrRange: number | { // ------- +0.9 Complexity index (+0.9 atomic)
                        getPos(): number; // ------------------------------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                        getEnd(): number; // ------------------------------------------------------------------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
                    }, refactorName: string, actionName: string, preferences?: UserPreferences): RefactorEditInfo | undefined; // ----------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getCombinedCodeFix Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                    
                /**
                 * Gets file changes and actions to perform for the provided fixId.
                 * @param filePathOrSourceFile - File path or source file to get the combined code fixes for.
                 * @param fixId - Identifier for the code fix (ex. "fixMissingImport"). These ids are found in the `ts.codefix` namespace in the compiler api source.
                 * @param formatSettings - Format code settings.
                 * @param preferences - User preferences for refactoring.
                 */
                getCombinedCodeFix(filePathOrSourceFile: string | SourceFile, fixId: {}, formatSettings?: FormatCodeSettings, preferences?: UserPreferences): CombinedCodeActions; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
getCodeFixesAtPosition Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the edit information for applying a code fix at the provided text range in a source file.
                 * @param filePathOrSourceFile - File path or source file to get the code fixes for.
                 * @param start - Start position of the text range to be fixed.
                 * @param end - End position of the text range to be fixed.
                 * @param errorCodes - One or more error codes associated with the code fixes to retrieve.
                 * @param formatOptions - Format code settings.
                 * @param preferences - User preferences for refactoring.
                 */
                getCodeFixesAtPosition(filePathOrSourceFile: string | SourceFile, start: number, end: number, errorCodes: ReadonlyArray<number>, formatOptions?: FormatCodeSettings, preferences?: UserPreferences): CodeFixAction[]; // ------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getTypeChecker Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Get the program's type checker. */
                getTypeChecker(): TypeChecker; // --------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
emit Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Asynchronously emits the TypeScript files as JavaScript files.
                 * @param options - Options for emitting.
                 */
                emit(options?: ProgramEmitOptions): Promise<EmitResult>; // ---------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
emitSync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Synchronously emits the TypeScript files as JavaScript files.
                 * @param options - Options for emitting.
                 * @remarks Use `emit()` as the asynchronous version will be much faster.
                 */
                emitSync(options?: ProgramEmitOptions): EmitResult; // ----------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
emitToMemory Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Emits the TypeScript files to JavaScript files to memory.
                 * @param options - Options for emitting.
                 */
                emitToMemory(options?: EmitOptions): MemoryEmitResult; // ------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getSyntacticDiagnostics Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the syntactic diagnostics.
                 * @param sourceFile - Optional source file to filter by.
                 */
                getSyntacticDiagnostics(sourceFile?: SourceFile): DiagnosticWithLocation[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getSemanticDiagnostics Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the semantic diagnostics.
                 * @param sourceFile - Optional source file to filter by.
                 */
                getSemanticDiagnostics(sourceFile?: SourceFile): Diagnostic[]; // -------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDeclarationDiagnostics Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the declaration diagnostics.
                 * @param sourceFile - Optional source file to filter by.
                 */
                getDeclarationDiagnostics(sourceFile?: SourceFile): DiagnosticWithLocation[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getGlobalDiagnostics Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the global diagnostics. */
                getGlobalDiagnostics(): Diagnostic[]; // ----------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getConfigFileParsingDiagnostics Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the diagnostics found when parsing the tsconfig.json file. */
                getConfigFileParsingDiagnostics(): Diagnostic[]; // ----------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getEmitModuleResolutionKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the emit module resolution kind. */
                getEmitModuleResolutionKind(): ModuleResolutionKind; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isSourceFileFromExternalLibrary Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the provided source file was discovered while loading an external library.
                 * @param sourceFile - Source file.
                 */
                isSourceFileFromExternalLibrary(sourceFile: SourceFile): boolean; // --------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                protected constructor();
            
                            
                        
getDescription Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Description of the code action. */
                getDescription(): string; // -------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getChanges Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Text changes to apply to each file as part of the code action. */
                getChanges(): FileTextChanges[]; // -------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getChanges Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Text changes to apply to each file. */
                getChanges(): FileTextChanges[]; // -------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
applyChanges Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Executes the combined code actions.
                 *
                 * WARNING: This will cause all nodes to be forgotten in the changed files.
                 * @options - Options used when applying the changes.
                 */
                applyChanges(options?: ApplyFileTextChangesOptions): this; // ------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getFixName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Short name to identify the fix, for use by telemetry. */
                getFixName(): string; // ------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFixId Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * If present, one may call 'getCombinedCodeFix' with this fixId.
                 * This may be omitted to indicate that the code fix can't be applied in a group.
                 */
                getFixId(): {} | undefined; // ------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getFixAllDescription Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the description of the code fix when fixing everything. */
                getFixAllDescription(): string | undefined; // ------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                protected constructor();
            
                            
                        
getKind Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the kind. */
                getKind(): ts.ScriptElementKind; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the name. */
                getName(): string; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getContainerKind Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the container kind. */
                getContainerKind(): ts.ScriptElementKind; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getContainerName Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the container name. */
                getContainerName(): string; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDeclarationNode Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the declaration node. */
                getDeclarationNode(): Node | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                protected constructor();
            
                            
                        
getSourceFile Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file. */
                getSourceFile(): SourceFile | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getMessageText Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the message text. */
                getMessageText(): string | DiagnosticMessageChain; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getLineNumber Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the line number. */
                getLineNumber(): number | undefined; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getStart Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the start. */
                getStart(): number | undefined; // ------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getLength Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the length. */
                getLength(): number | undefined; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getCategory Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the diagnostic category. */
                getCategory(): DiagnosticCategory; // --------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getCode Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the code of the diagnostic. */
                getCode(): number; // ---------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getSource Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source. */
                getSource(): string | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getMessageText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the message text. */
                getMessageText(): string; // ------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNext Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the next diagnostic message chains in the chain. */
                getNext(): DiagnosticMessageChain[] | undefined; // ------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getCode Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the code of the diagnostic message chain. */
                getCode(): number; // ------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getCategory Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the category of the diagnostic message chain. */
                getCategory(): DiagnosticCategory; // ------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getLineNumber Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the line number. */
                getLineNumber(): number; // ----------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getStart Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the start. */
                getStart(): number; // ------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getLength Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the length */
                getLength(): number; // --------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getSourceFile Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file. */
                getSourceFile(): SourceFile; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                protected constructor();
            
                            
                        
getSourceFile Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file this reference is in. */
                getSourceFile(): SourceFile; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getTextSpan Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text span. */
                getTextSpan(): TextSpan; // ----------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNode Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the node at the start of the text span. */
                getNode(): Node<ts.Node>; // --------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getOriginalTextSpan Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the original text span if the span represents a location that was remapped. */
                getOriginalTextSpan(): TextSpan | undefined; // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getOriginalFileName Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the original file name if the span represents a location that was remapped. */
                getOriginalFileName(): string | undefined; // ---------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getEmitSkipped Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the emit was skipped. */
                getEmitSkipped(): boolean; // ----------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getOutputFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the output files. */
                getOutputFiles(): OutputFile[]; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                protected constructor();
            
                            
                        
getEmitSkipped Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** If the emit was skipped. */
                getEmitSkipped(): boolean; // ----------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getDiagnostics Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Contains declaration emit diagnostics.
                 *
                 * If the `noEmitOnError` compiler option is true, this will also include the program's semantic, syntactic, global, options, and if enabled declaration diagnostics.
                 * @remarks If you are looking for non-declaration emit diagnostics, then call `Project#getPreEmitDiagnostics()` or get specific diagnostics available from the program.
                 */
                getDiagnostics(): Diagnostic<ts.Diagnostic>[]; // --------------------------------------------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getFilePath Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file path. */
                getFilePath(): string; // ----------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getSourceFile Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the source file if it was in the cache at the time of this class' creation. */
                getSourceFile(): SourceFile | undefined; // ------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getTextChanges Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text changes */
                getTextChanges(): TextChange[]; // ---------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
applyChanges Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Applies the text changes to the file. This modifies and possibly creates a new source file.
                 *
                 * WARNING: This will forget any previously navigated descendant nodes in the source file.
                 * @param options - Options for applying the text changes to the file.
                 */
                applyChanges(options?: ApplyFileTextChangesOptions): this | undefined; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isNewFile Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this change is for creating a new file. */
                isNewFile(): boolean; // -------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getKind Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the kind. */
                getKind(): ts.ScriptElementKind; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDisplayParts Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the display parts. */
                getDisplayParts(): SymbolDisplayPart[]; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                
                private constructor();
            
                            
                        
getFiles Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the files that were emitted to memory. */
                getFiles(): MemoryEmitResultFile[]; // ---------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
saveFiles Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Asynchronously writes the files to the file system. */
                saveFiles(): Promise<void[]>; // ------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
saveFilesSync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Synchronously writes the files to the file system.
                 * @remarks Use `saveFiles()` as the asynchronous version will be much faster.
                 */
                saveFilesSync(): void; // --------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getFilePath Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file path. */
                getFilePath(): StandardizedFilePath; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getWriteByteOrderMark Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets whether the byte order mark should be written. */
                getWriteByteOrderMark(): boolean; // -------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file text. */
                getText(): string; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getEdits Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets refactor file text changes */
                getEdits(): FileTextChanges[]; // ------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getRenameFilePath Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the file path for a rename refactor. */
                getRenameFilePath(): string | undefined; // --------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getRenameLocation Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Location where renaming should be invoked from. */
                getRenameLocation(): number | undefined; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
applyChanges Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Executes the combined code actions.
                 *
                 * WARNING: This will cause all nodes to be forgotten in the changed files.
                 * @options - Options used when applying the changes.
                 */
                applyChanges(options?: ApplyFileTextChangesOptions): this; // ------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getDefinition Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the definition. */
                getDefinition(): ReferencedSymbolDefinitionInfo; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getReferences Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the references. */
                getReferences(): ReferenceEntry[]; // --------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getDisplayParts Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the display parts. */
                getDisplayParts(): SymbolDisplayPart[]; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
isWriteAccess Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                isWriteAccess(): boolean; // ------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isDefinition Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** If this is the definition reference. */
                isDefinition(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isInString Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                isInString(): true | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getPrefixText Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
            
                /** Gets the text to insert before the rename. */
                getPrefixText(): string | undefined; // -------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSuffixText Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text to insert after the rename. */
                getSuffixText(): string | undefined; // ------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text. */
                getText(): string; // -------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the kind.
                 *
                 * Examples: "text", "lineBreak"
                 */
                getKind(): string; // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getSpan Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the text span. */
                getSpan(): TextSpan; // ----------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNewText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the new text. */
                getNewText(): string; // ----------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getStart Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the start. */
                getStart(): number; // ---------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getEnd Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the start + length. */
                getEnd(): number; // --------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getLength Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the length. */
                getLength(): number; // ---------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
getAmbientModules Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the ambient module symbols (ex. modules in the @types folder or node_modules). */
                getAmbientModules(): Symbol[]; // ------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getApparentType Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the apparent type of a type.
                 * @param type - Type to get the apparent type of.
                 */
                getApparentType(type: Type): Type<ts.Type>; // -------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getConstantValue Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the constant value of a declaration.
                 * @param node - Node to get the constant value from.
                 */
                getConstantValue(node: EnumMember): string | number | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getFullyQualifiedName Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the fully qualified name of a symbol.
                 * @param symbol - Symbol to get the fully qualified name of.
                 */
                getFullyQualifiedName(symbol: Symbol): string; // ------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getTypeAtLocation Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the type at the specified location.
                 * @param node - Node to get the type for.
                 */
                getTypeAtLocation(node: Node): Type; // ----------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getContextualType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the contextual type of an expression.
                 * @param expression - Expression.
                 */
                getContextualType(expression: Expression): Type | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeOfSymbolAtLocation Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getDeclaredTypeOfSymbol Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the declared type of a symbol.
                 * @param symbol - Symbol to get the type for.
                 */
                getDeclaredTypeOfSymbol(symbol: Symbol): Type; // --------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getSymbolAtLocation Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ---------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getAliasedSymbol Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the aliased symbol of a symbol.
                 * @param symbol - Symbol to get the alias symbol of.
                 */
                getAliasedSymbol(symbol: Symbol): Symbol | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getExportSymbolOfSymbol Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the export symbol of a local symbol with a corresponding export symbol. Otherwise returns the input symbol.
                 *
                 * The following is from the compiler API documentation:
                 *
                 * For example, at `export type T = number;`:
                 *     - `getSymbolAtLocation` at the location `T` will return the exported symbol for `T`.
                 *     - But the result of `getSymbolsInScope` will contain the *local* symbol for `T`, not the exported symbol.
                 *     - Calling `getExportSymbolOfSymbol` on that local symbol will return the exported symbol.
                 */
                getExportSymbolOfSymbol(symbol: Symbol): Symbol; // -------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getPropertiesOfType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the properties of a type.
                 * @param type - Type.
                 */
                getPropertiesOfType(type: Type): Symbol[]; // ------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTypeText Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * 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; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getReturnTypeOfSignature Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the return type of a signature.
                 * @param signature - Signature to get the return type of.
                 */
                getReturnTypeOfSignature(signature: Signature): Type; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getSignatureFromNode Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a signature from a node.
                 * @param node - Node to get the signature from.
                 */
                getSignatureFromNode(node: Node<ts.SignatureDeclaration>): Signature | undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getExportsOfModule Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the exports of a module.
                 * @param moduleSymbol - Module symbol.
                 */
                getExportsOfModule(moduleSymbol: Symbol): Symbol[]; // ------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getExportSpecifierLocalTargetSymbol Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the local target symbol of the provided export specifier.
                 * @param exportSpecifier - Export specifier.
                 */
                getExportSpecifierLocalTargetSymbol(exportSpecifier: ExportSpecifier): Symbol | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getResolvedSignature Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the resolved signature from a node or returns undefined if the signature can't be resolved.
                 * @param node - Node to get the signature from.
                 */
                getResolvedSignature(node: CallLikeExpression): Signature | undefined; // ------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getResolvedSignatureOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the resolved signature from a node or throws if the signature cannot be resolved.
                 * @param node - Node to get the signature from.
                 */
                getResolvedSignatureOrThrow(node: CallLikeExpression): Signature; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getBaseTypeOfLiteralType Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the base type of a literal type.
                 *
                 * For example, for a number literal type it will return the number type.
                 * @param type - Literal type to get the base type of.
                 */
                getBaseTypeOfLiteralType(type: Type): Type<ts.Type>; // ---------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getSymbolsInScope Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the symbols in the scope of the provided node.
                 *
                 * Note: This will always return the local symbols. If you want the export symbol from a local symbol, then
                 * use the `#getExportSymbolOfSymbol(symbol)` method.
                 * @param node - Node to check the scope for.
                 * @param meaning - Meaning of symbol to filter by.
                 */
                getSymbolsInScope(node: Node, meaning: SymbolFlags): Symbol[]; // ---------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getTypeArguments Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the type arguments from a type reference.
                 * @param typeReference - Type reference.
                 */
                getTypeArguments(typeReference: Type): Type<ts.Type>[]; // -------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                protected constructor();
            
                            
                        
getText Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the type text.
                 * @param enclosingNode - The enclosing node.
                 * @param typeFormatFlags - Format flags for the type text.
                 */
                getText(enclosingNode?: Node, typeFormatFlags?: TypeFormatFlags): string; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getAliasSymbol Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the alias symbol if it exists. */
                getAliasSymbol(): Symbol | undefined; // ------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getAliasSymbolOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the alias symbol if it exists, or throws. */
                getAliasSymbolOrThrow(): Symbol; // ---------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getAliasTypeArguments Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the alias type arguments. */
                getAliasTypeArguments(): Type[]; // ------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getApparentType Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the apparent type. */
                getApparentType(): Type; // --------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getArrayElementTypeOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the array element type or throws if it doesn't exist (ex. for `T[]` it would be `T`). */
                getArrayElementTypeOrThrow(): Type<ts.Type>; // ------------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getArrayElementType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the array element type or returns undefined if it doesn't exist (ex. for `T[]` it would be `T`). */
                getArrayElementType(): Type<ts.Type> | undefined; // ------------------------------------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getBaseTypes Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the base types. */
                getBaseTypes(): Type<ts.BaseType>[]; // -------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getBaseTypeOfLiteralType Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the base type of a literal type.
                 *
                 * For example, for a number literal type it will return the number type.
                 */
                getBaseTypeOfLiteralType(): Type<ts.Type>; // -------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getCallSignatures Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the call signatures. */
                getCallSignatures(): Signature[]; // ---------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getConstructSignatures Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the construct signatures. */
                getConstructSignatures(): Signature[]; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getConstraintOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the constraint or throws if it doesn't exist. */
                getConstraintOrThrow(): Type<ts.Type>; // -------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getConstraint Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the constraint or returns undefined if it doesn't exist. */
                getConstraint(): Type<ts.Type> | undefined; // -------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getDefaultOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default type or throws if it doesn't exist. */
                getDefaultOrThrow(): Type<ts.Type>; // ------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getDefault Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default type or returns undefined if it doesn't exist. */
                getDefault(): Type<ts.Type> | undefined; // ------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getProperties Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the properties of the type. */
                getProperties(): Symbol[]; // --------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getPropertyOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a property or throws if it doesn't exist.
                 * @param name - By a name.
                 */
                getPropertyOrThrow(name: string): Symbol; // --------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getPropertyOrThrow Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a property or throws if it doesn't exist.
                 * @param findFunction - Function for searching for a property.
                 */
                getPropertyOrThrow(findFunction: (declaration: Symbol) => boolean): Symbol; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getProperty Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a property or returns undefined if it does not exist.
                 * @param name - By a name.
                 */
                getProperty(name: string): Symbol | undefined; // ------------------------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getProperty Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets a property or returns undefined if it does not exist.
                 * @param findFunction - Function for searching for a property.
                 */
                getProperty(findFunction: (declaration: Symbol) => boolean): Symbol | undefined; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getApparentProperties Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the apparent properties of the type. */
                getApparentProperties(): Symbol[]; // ----------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getApparentProperty Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets an apparent property.
                 * @param name - By a name.
                 * @param findFunction - Function for searching for an apparent property.
                 */
                getApparentProperty(name: string): Symbol | undefined; // -------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getApparentProperty Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                getApparentProperty(findFunction: (declaration: Symbol) => boolean): Symbol | undefined; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isNullable Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the type is possibly null or undefined. */
                isNullable(): boolean; // ------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getNonNullableType Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the non-nullable type. */
                getNonNullableType(): Type; // -------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNumberIndexType Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the number index type. */
                getNumberIndexType(): Type | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getStringIndexType Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the string index type. */
                getStringIndexType(): Type | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getTargetType Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Gets the target type of a type reference if it exists. */
                getTargetType(): Type<ts.GenericType> | undefined; // ------------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getTargetTypeOrThrow Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the target type of a type reference or throws if it doesn't exist. */
                getTargetTypeOrThrow(): Type<ts.GenericType>; // ---------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getTypeArguments Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets type arguments. */
                getTypeArguments(): Type[]; // ------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getTupleElements Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the individual element types of the tuple. */
                getTupleElements(): Type[]; // ---------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getUnionTypes Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the union types (ex. for `T | U` it returns the array `[T, U]`). */
                getUnionTypes(): Type[]; // ----------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getIntersectionTypes Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the intersection types (ex. for `T & U` it returns the array `[T, U]`). */
                getIntersectionTypes(): Type[]; // ----------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSymbol Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the symbol of the type. */
                getSymbol(): Symbol | undefined; // ---------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getSymbolOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the symbol of the type or throws. */
                getSymbolOrThrow(): Symbol; // ------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isAnonymous Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is an anonymous type. */
                isAnonymous(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isAny Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is an any type. */
                isAny(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isArray Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is an array type. */
                isArray(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isBoolean Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a boolean type. */
                isBoolean(): boolean; // ------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isString Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a string type. */
                isString(): boolean; // ------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isNumber Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a number type. */
                isNumber(): boolean; // ------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isLiteral Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a literal type. */
                isLiteral(): boolean; // ------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isBooleanLiteral Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a boolean literal type. */
                isBooleanLiteral(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isEnumLiteral Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is an enum literal type. */
                isEnumLiteral(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isNumberLiteral Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a number literal type. */
                isNumberLiteral(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isStringLiteral Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a string literal type. */
                isStringLiteral(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isClass Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a class type. */
                isClass(): boolean; // ------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isClassOrInterface Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a class or interface type. */
                isClassOrInterface(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isEnum Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is an enum type. */
                isEnum(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isInterface Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is an interface type. */
                isInterface(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isObject Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is an object type. */
                isObject(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isTypeParameter Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a type parameter. */
                isTypeParameter(): this is TypeParameter; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
isTuple Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a tuple type. */
                isTuple(): boolean; // ----------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isUnion Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a union type. */
                isUnion(): boolean; // ------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isIntersection Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is an intersection type. */
                isIntersection(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isUnionOrIntersection Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is a union or intersection type. */
                isUnionOrIntersection(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isUnknown Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is the unknown type. */
                isUnknown(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isNull Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is the null type. */
                isNull(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isUndefined Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if this is the undefined type. */
                isUndefined(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getFlags Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the type flags. */
                getFlags(): TypeFlags; // ------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getObjectFlags Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the object flags.
                 * @remarks Returns 0 for a non-object type.
                 */
                getObjectFlags(): ObjectFlags | 0; // ----------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getConstraintOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
            
                /** Gets the constraint or throws if it doesn't exist. */
                getConstraintOrThrow(): Type; // ----------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getConstraint Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the constraint type. */
                getConstraint(): Type | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDefaultOrThrow Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default type or throws if it doesn't exist. */
                getDefaultOrThrow(): Type; // ---------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDefault Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the default type or undefined if it doesn't exist. */
                getDefault(): Type | undefined; // -------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                
                constructor();
            
                            
                        
getEditorSettings Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the editor settings based on the current manipulation settings. */
                getEditorSettings(): Readonly<EditorSettings>; // ------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getFormatCodeSettings Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the format code settings. */
                getFormatCodeSettings(): Readonly<SupportedFormatCodeSettings>; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getUserPreferences Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the user preferences. */
                getUserPreferences(): Readonly<UserPreferences>; // ---------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getQuoteKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the quote kind used for string literals. */
                getQuoteKind(): QuoteKind; // --------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNewLineKind Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the new line kind. */
                getNewLineKind(): NewLineKind; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getNewLineKindAsString Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Gets the new line kind as a string. */
                getNewLineKindAsString(): "\n" | "\r\n"; // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getIndentationText Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the indentation text. */
                getIndentationText(): IndentationText; // --------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getUsePrefixAndSuffixTextForRename Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets whether to use prefix and suffix text when renaming. */
                getUsePrefixAndSuffixTextForRename(): boolean; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getUseTrailingCommas Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets whether trailing commas should be used. */
                getUseTrailingCommas(): boolean; // -------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
set Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets one or all of the settings.
                 * @param settings - Settings to set.
                 */
                set(settings: Partial<ManipulationSettings>): void; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
forEachStructureChild Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Iterates over the elements in the provided array.
             * @param structures - Array of structures to iterate over.
             * @param callback - Callback to do on each element in the array. Returning a truthy value will return that value in the main function call.
             */
            export declare function forEachStructureChild<TStructure>(structures: ReadonlyArray<Structures>, callback: (child: Structures) => TStructure | void): TStructure | undefined; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
forEachStructureChild Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
            
            /**
             * Iterates over the children of the provided array.
             * @remarks If the children do not have a `kind` property, it will be automatically added.
             * @param structure - Structure to iterate over.
             * @param callback - Callback to do on each child of the provided structure. Returning a truthy value will return that value in the main function call.
             */
            export declare function forEachStructureChild<TStructure>(structure: Structures, callback: (child: Structures) => TStructure | void): TStructure | undefined; // ----------------------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
Complexity Index 0.3 Cyclomatic complexity 0
                            
                                
            
                /**
                 * Constructor.
                 * @param opts - Options for the writer.
                 */
                constructor(opts?: Partial<CodeBlockWriterOptions>); // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getOptions Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the options. */
                getOptions(): CodeBlockWriterOptions; // ---------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
queueIndentationLevel Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Queues the indentation level for the next lines written.
                 * @param indentationLevel - Indentation level to queue.
                 */
                queueIndentationLevel(indentationLevel: number): this; // ------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
queueIndentationLevel Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Queues the indentation level for the next lines written using the provided indentation text.
                 * @param whitespaceText - Gets the indentation level from the indentation text.
                 */
                queueIndentationLevel(whitespaceText: string): this; // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
hangingIndent Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes the text within the provided action with hanging indentation.
                 * @param action - Action to perform with hanging indentation.
                 */
                hangingIndent(action: () => void): this; // -------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
hangingIndentUnlessBlock Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes the text within the provided action with hanging indentation unless writing a block.
                 * @param action - Action to perform with hanging indentation unless a block is written.
                 */
                hangingIndentUnlessBlock(action: () => void): this; // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
setIndentationLevel Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the current indentation level.
                 * @param indentationLevel - Indentation level to be at.
                 */
                setIndentationLevel(indentationLevel: number): this; // ----------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
setIndentationLevel Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the current indentation using the provided indentation text.
                 * @param whitespaceText - Gets the indentation level from the indentation text.
                 */
                setIndentationLevel(whitespaceText: string): this; // ------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
withIndentationLevel Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the indentation level within the provided action and restores the writer's indentation
                 * state afterwards.
                 * @remarks Restores the writer's state after the action.
                 * @param indentationLevel - Indentation level to set.
                 * @param action - Action to perform with the indentation.
                 */
                withIndentationLevel(indentationLevel: number, action: () => void): this; // ---------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
withIndentationLevel Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Sets the indentation level with the provided indentation text within the provided action
                 * and restores the writer's indentation state afterwards.
                 * @param whitespaceText - Gets the indentation level from the indentation text.
                 * @param action - Action to perform with the indentation.
                 */
                withIndentationLevel(whitespaceText: string, action: () => void): this; // --------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
getIndentationLevel Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the current indentation level. */
                getIndentationLevel(): number; // ------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
block Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes a block using braces.
                 * @param block - Write using the writer within this block.
                 */
                block(block?: () => void): this; // ---------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
inlineBlock Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes an inline block with braces.
                 * @param block - Write using the writer within this block.
                 */
                inlineBlock(block?: () => void): this; // ---------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
indent Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Indents the code one level for the current line. */
                indent(times?: number): this; // --------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
indent Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Indents a block of code.
                 * @param block - Block to indent.
                 */
                indent(block: () => void): this; // --------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
conditionalWriteLine Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Conditionally writes a line of text.
                 * @param condition - Condition to evaluate.
                 * @param textFunc - A function that returns a string to write if the condition is true.
                 */
                conditionalWriteLine(condition: boolean | undefined, textFunc: () => string): this; // ------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
conditionalWriteLine Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Conditionally writes a line of text.
                 * @param condition - Condition to evaluate.
                 * @param text - Text to write if the condition is true.
                 */
                conditionalWriteLine(condition: boolean | undefined, text: string): this; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
writeLine Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes a line of text.
                 * @param text - String to write.
                 */
                writeLine(text: string): this; // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
newLineIfLastNot Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Writes a newline if the last line was not a newline. */
                newLineIfLastNot(): this; // ----------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
blankLineIfLastNot Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Writes a blank line if the last written text was not a blank line. */
                blankLineIfLastNot(): this; // ----------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
conditionalBlankLine Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes a blank line if the condition is true.
                 * @param condition - Condition to evaluate.
                 */
                conditionalBlankLine(condition: boolean | undefined): this; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
blankLine Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Writes a blank line. */
                blankLine(): this; // ------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
conditionalNewLine Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes a newline if the condition is true.
                 * @param condition - Condition to evaluate.
                 */
                conditionalNewLine(condition: boolean | undefined): this; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
newLine Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Writes a newline. */
                newLine(): this; // ------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
quote Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Writes a quote character. */
                quote(): this; // ------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
quote Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes text surrounded in quotes.
                 * @param text - Text to write.
                 */
                quote(text: string): this; // ----------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
spaceIfLastNot Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Writes a space if the last character was not a space. */
                spaceIfLastNot(): this; // -------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
space Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes a space.
                 * @param times - Number of times to write a space.
                 */
                space(times?: number): this; // ------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
tabIfLastNot Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Writes a tab if the last character was not a tab. */
                tabIfLastNot(): this; // ------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
tab Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes a tab.
                 * @param times - Number of times to write a tab.
                 */
                tab(times?: number): this; // ------------------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
conditionalWrite Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Conditionally writes text.
                 * @param condition - Condition to evaluate.
                 * @param textFunc - A function that returns a string to write if the condition is true.
                 */
                conditionalWrite(condition: boolean | undefined, textFunc: () => string): this; // ---------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
conditionalWrite Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Conditionally writes text.
                 * @param condition - Condition to evaluate.
                 * @param text - Text to write if the condition is true.
                 */
                conditionalWrite(condition: boolean | undefined, text: string): this; // ----------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
write Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Writes the provided text.
                 * @param text - Text to write.
                 */
                write(text: string): this; // -------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
closeComment Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Writes text to exit a comment if in a comment. */
                closeComment(): this; // --------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
unsafeInsert Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Inserts text at the provided position.
                 *
                 * This method is "unsafe" because it won't update the state of the writer unless
                 * inserting at the end position. It is biased towards being fast at inserting closer
                 * to the start or end, but slower to insert in the middle. Only use this if
                 * absolutely necessary.
                 * @param pos - Position to insert at.
                 * @param text - Text to insert.
                 */
                unsafeInsert(pos: number, text: string): this; // ---------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getLength Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets the length of the string in the writer. */
                getLength(): number; // -------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isInComment Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the writer is currently in a comment. */
                isInComment(): boolean; // ------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isAtStartOfFirstLineOfBlock Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the writer is currently at the start of the first line of the text, block, or indentation block. */
                isAtStartOfFirstLineOfBlock(): boolean; // ------------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isOnFirstLineOfBlock Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the writer is currently on the first line of the text, block, or indentation block. */
                isOnFirstLineOfBlock(): boolean; // ------------------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isInString Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the writer is currently in a string. */
                isInString(): boolean; // ------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isLastNewLine Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the last chars written were for a newline. */
                isLastNewLine(): boolean; // --------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isLastBlankLine Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the last chars written were for a blank line. */
                isLastBlankLine(): boolean; // ---------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isLastSpace Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the last char written was a space. */
                isLastSpace(): boolean; // --------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
isLastTab Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** Gets if the last char written was a tab. */
                isLastTab(): boolean; // --------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getLastChar Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** Gets the last char written. */
                getLastChar(): string | undefined; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
endsWith Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the writer ends with the provided text.
                 * @param text - Text to check if the writer ends with the provided text.
                 */
                endsWith(text: string): boolean; // ------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
iterateLastChars Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Iterates over the writer characters in reverse order. The iteration stops when a non-null or
                 * undefined value is returned from the action. The returned value is then returned by the method.
                 *
                 * @remarks It is much more efficient to use this method rather than `#toString()` since `#toString()`
                 * will combine the internal array into a string.
                 */
                iterateLastChars<T>(action: (char: string, index: number) => T | undefined): T | undefined; // ------------------ +1.0 Complexity index (+1.0 atomic)
            
                            
                        
iterateLastCharCodes Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Iterates over the writer character char codes in reverse order. The iteration stops when a non-null or
                 * undefined value is returned from the action. The returned value is then returned by the method.
                 *
                 * @remarks It is much more efficient to use this method rather than `#toString()` since `#toString()`
                 * will combine the internal array into a string. Additionally, this is slightly more efficient that
                 * `iterateLastChars` as this won't allocate a string per character.
                 */
                iterateLastCharCodes<T>(action: (charCode: number, index: number) => T | undefined): T | undefined; // ------------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
toString Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** Gets the writer's text. */
                toString(): string; // --------------------------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)