Genese complexity report

<- ts-morph-common.d.ts
Methods : 234
Complexity index : 130.9
Cyclomatic complexity : 209
Cognitive complexity
100 % Correct 234/234
0 % Warning 0/234 (threshold : 10)
0 % Error 0/234 (threshold : 20)
Cyclomatic complexity
100 % Correct 234/234
0 % Warning 0/234 (threshold : 5)
0 % Error 0/234 (threshold : 10)
Methods of ts-morph-common.d.ts
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.6 Cyclomatic complexity 0
                            
                                
                
                constructor(fileSystem: TransactionalFileSystem, tsConfigFilePath: StandardizedFilePath, encoding: string); // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getCompilerOptions Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                getCompilerOptions(): ts.CompilerOptions; // ------------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getErrors Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                getErrors(): ts.Diagnostic[]; // ------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getPaths Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                getPaths(compilerOptions?: CompilerOptions): { // ------- +0.3 Complexity index (+0.3 atomic)
                    filePaths: StandardizedFilePath[]; // --------------- +0.3 Complexity index (+0.3 atomic)
                    directoryPaths: StandardizedFilePath[]; // ---------- +0.3 Complexity index (+0.3 atomic)
                };
            
                            
                        
getSize Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                getSize(): number; // ----------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getValues Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                getValues(): IterableIterator<U>; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getValuesAsArray Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                getValuesAsArray(): U[]; // ---------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getKeys Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                getKeys(): IterableIterator<T>; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getEntries Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                getEntries(): IterableIterator<[T, U]>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getOrCreate Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                getOrCreate<TCreate extends U = U>(key: T, createFunc: () => TCreate): TCreate; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
has Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                has(key: T): boolean; // ----------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
get Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                get(key: T): U | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                set(key: T, value: U): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
replaceKey Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                replaceKey(key: T, newKey: T): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
removeByKey Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                removeByKey(key: T): void; // ----------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
clear Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                clear(): void; // ------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.7 Cyclomatic complexity 0
                            
                                
                
                constructor(getKey: (value: TValue) => TKey, comparer: Comparer<TKey>); // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
set Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                set(value: TValue): void; // ----------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
removeByValue Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                removeByValue(value: TValue): void; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
removeByKey Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                removeByKey(key: TKey): void; // ------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getArrayCopy Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                getArrayCopy(): TValue[]; // ----------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
hasItems Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                hasItems(): boolean; // ------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
entries Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                entries(): Generator<TValue, void, undefined>; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getOrCreate Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                getOrCreate<TCreate extends U = U>(key: T, createFunc: () => TCreate): TCreate; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
has Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                has(key: T): boolean; // ----------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
get Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                get(key: T): U | undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
set Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                set(key: T, value: U): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
removeByKey Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                removeByKey(key: T): void; // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
createHosts Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Creates a language service host and compiler host.
             * @param options - Options for creating the hosts.
             */
            export declare function createHosts(options: CreateHostsOptions): { // ------- +0.3 Complexity index (+0.3 atomic)
                languageServiceHost: ts.LanguageServiceHost; // -------------------------- +0.3 Complexity index (+0.3 atomic)
                compilerHost: ts.CompilerHost; // ---------------------------------------- +0.3 Complexity index (+0.3 atomic)
            };
            
                            
                        
createModuleResolutionHost Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Creates a module resolution host based on the provided options.
             * @param options - Options for creating the module resolution host.
             */
            export declare function createModuleResolutionHost(options: CreateModuleResolutionHostOptions): ts.ModuleResolutionHost; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Constructor.
                 * @param transactionalFileSystem - The transaction file system to use.
                 */
                constructor(transactionalFileSystem: TransactionalFileSystem); // ---------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
createOrUpdateSourceFile Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Creates or updates a source file in the document registry.
                 * @param fileName - File name to create or update.
                 * @param compilationSettings - Compiler options to use.
                 * @param scriptSnapshot - Script snapshot (text) of the file.
                 * @param scriptKind - Script kind of the file.
                 */
                createOrUpdateSourceFile(fileName: StandardizedFilePath, compilationSettings: CompilerOptions, scriptSnapshot: ts.IScriptSnapshot, scriptKind: ScriptKind | undefined): ts.SourceFile; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
removeSourceFile Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Removes the source file from the document registry.
                 * @param fileName - File name to remove.
                 */
                removeSourceFile(fileName: StandardizedFilePath): void; // -------------------------------------------------------------------------------------------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
acquireDocument Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                acquireDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: ts.IScriptSnapshot, version: string, scriptKind: ScriptKind | undefined): ts.SourceFile; // ------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
acquireDocumentWithKey Complexity Index 2.1 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                acquireDocumentWithKey(fileName: string, path: ts.Path, compilationSettings: CompilerOptions, key: ts.DocumentRegistryBucketKey, scriptSnapshot: ts.IScriptSnapshot, version: string, scriptKind: ScriptKind | undefined): ts.SourceFile; // ------- +2.1 Complexity index (+2.1 atomic)
            
                            
                        
updateDocument Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                updateDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: ts.IScriptSnapshot, version: string, scriptKind: ScriptKind | undefined): ts.SourceFile; // ----------------------------------------------------------------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
updateDocumentWithKey Complexity Index 2.1 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                updateDocumentWithKey(fileName: string, path: ts.Path, compilationSettings: CompilerOptions, key: ts.DocumentRegistryBucketKey, scriptSnapshot: ts.IScriptSnapshot, version: string, scriptKind: ScriptKind | undefined): ts.SourceFile; // ------- +2.1 Complexity index (+2.1 atomic)
            
                            
                        
getKeyForCompilationSettings Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                getKeyForCompilationSettings(settings: CompilerOptions): ts.DocumentRegistryBucketKey; // --------------------------------------------------------------------------------------------------------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
releaseDocument Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                releaseDocument(fileName: string, compilationSettings: CompilerOptions): void; // --------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
releaseDocumentWithKey Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                releaseDocumentWithKey(path: ts.Path, key: ts.DocumentRegistryBucketKey): void; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
reportStats Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                reportStats(): string; // ---------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getSourceFileVersion Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                getSourceFileVersion(sourceFile: ts.SourceFile): any; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
Complexity Index 0.5 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Constructor.
                 * @param comparer - Comparer to use.
                 * @param storedValue - Stored value to use as the value to always compare the input of `compareTo` to.
                 */
                constructor(comparer: Comparer<T>, storedValue: T); // ----------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
compareTo Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                compareTo(value: T): number; // ------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
compareTo Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                compareTo(a: string, b: string): 1 | -1 | 0; // ---------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
Complexity Index 0.7 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Constructor.
                 * @param getProperty - Gets the property from the value to use for comparisons.
                 * @param comparer - Comparer to compare the properties with.
                 */
                constructor(getProperty: (value: TValue) => TProperty, comparer: Comparer<TProperty>); // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
compareTo Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                compareTo(a: TValue, b: TValue): number; // ----------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
Complexity Index 0.7 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Constructor.
                 * @param getProperty - Gets the property from the value.
                 * @param comparer - Comparer to compare the property with.
                 */
                constructor(getProperty: (value: TValue) => TProperty, comparer: StoredComparer<TProperty>); // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
compareTo Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                compareTo(value: TValue): number; // ------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
Memoize Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
            
            
            /** Decorator for memoizing the result of a method or get accessor. */
            export declare function Memoize(target: any, propertyName: string, descriptor: TypedPropertyDescriptor<any>): void; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                    
                    protected constructor();
            
                            
                        
Complexity Index 0.4 Cyclomatic complexity 0
                            
                                
                
                    constructor(argName: string, message: string); // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                    constructor(argName: string); // --------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.4 Cyclomatic complexity 0
                            
                                
                
                    constructor(argName: string, value: number, range: [number, number]); // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.6 Cyclomatic complexity 0
                            
                                
                
                    constructor(argName: string, expectedType: string, actualType: string); // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
Complexity Index 0.4 Cyclomatic complexity 0
                            
                                
                    
                    constructor(path: StandardizedFilePath, prefix?: string); // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                    constructor(dirPath: StandardizedFilePath); // ---------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                    constructor(filePath: StandardizedFilePath); // ---------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                    constructor(message: string); // --------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                    constructor(message?: string); // ------------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                    constructor(message: string); // ----------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
throwIfNotType Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Thows if not a type.
                 * @param value - Value to check the type of.
                 * @param expectedType - Expected type.
                 * @param argName - Argument name.
                 */
                function throwIfNotType(value: any, expectedType: string, argName: string): void; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
throwIfNotString Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throws if the value is not a string.
                 * @param value - Value to check.
                 * @param argName - Arg name.
                 */
                function throwIfNotString(value: string, argName: string): void; // ------------------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
throwIfWhitespaceOrNotString Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throws if the value is not a string or is whitespace.
                 * @param value - Value to check.
                 * @param argName - Arg name.
                 */
                function throwIfWhitespaceOrNotString(value: string, argName: string): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
throwIfOutOfRange Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throws an ArgumentOutOfRangeError if an argument's value is out of an inclusive range.
                 * @param value - Value.
                 * @param range - Range.
                 * @param argName - Argument name.
                 */
                function throwIfOutOfRange(value: number, range: [number, number], argName: string): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
throwIfRangeOutOfRange Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throws an ArgumentOutOfRangeError if an argument's range value is out of an inclusive range.
                 *
                 * Also throws when the start of the range is greater than the end.
                 * @param actualRange - Range to check.
                 * @param range - Range to check against.
                 * @param argName - Argument name.
                 */
                function throwIfRangeOutOfRange(actualRange: [number, number], range: [number, number], argName: string): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
throwNotImplementedForSyntaxKindError Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets an error saying that a feature is not implemented for a certain syntax kind.
                 * @param kind - Syntax kind that isn't implemented.
                 */
                function throwNotImplementedForSyntaxKindError(kind: ts.SyntaxKind): never; // ------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
throwIfNegative Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throws an Argument
                 * @param value
                 * @param argName
                 */
                function throwIfNegative(value: number, argName: string): void; // ------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
throwIfNullOrUndefined Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throws when the value is null or undefined.
                 * @param value - Value to check.
                 * @param errorMessage - Error message to throw when not defined.
                 */
                function throwIfNullOrUndefined<T>(value: T | undefined, errorMessage: string | (() => string)): T; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
throwNotImplementedForNeverValueError Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throw if the value should have been the never type.
                 * @param value - Value to check.
                 */
                function throwNotImplementedForNeverValueError(value: never): never; // -------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
throwIfNotEqual Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throws an error if the actual value does not equal the expected value.
                 * @param actual - Actual value.
                 * @param expected - Expected value.
                 * @param description - Message to show in the error. Should be a full sentence that doesn't include the actual and expected values.
                 */
                function throwIfNotEqual<T>(actual: T, expected: T, description: string): void; // ------------------------------------------------------------ +0.9 Complexity index (+0.9 atomic)
            
                            
                        
throwIfTrue Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Throws if true.
                 * @param value - Value to check.
                 * @param errorMessage - Error message to throw when true.
                 */
                function throwIfTrue(value: boolean | undefined, errorMessage: string): void; // --------- +0.6 Complexity index (+0.6 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)
            
                            
                        
isCaseSensitive Complexity Index 0.1 Cyclomatic complexity 1
                            
                                
                
                /** @inheritdoc */
                isCaseSensitive(): boolean; // -------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
Complexity Index 0.2 Cyclomatic complexity 0
                            
                                
                
                /**
                 * Constructor.
                 * @param fileSystem - File system host to commit the operations to.
                 */
                constructor(fileSystem: FileSystemHost); // ----------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
queueFileDelete Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                queueFileDelete(filePath: StandardizedFilePath): void; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
removeFileDelete Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                removeFileDelete(filePath: StandardizedFilePath): void; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
queueMkdir Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                queueMkdir(dirPath: StandardizedFilePath): void; // -------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
queueDirectoryDelete Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                queueDirectoryDelete(dirPath: StandardizedFilePath): void; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
queueMoveDirectory Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                queueMoveDirectory(srcPath: StandardizedFilePath, destPath: StandardizedFilePath): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
queueCopyDirectory Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                queueCopyDirectory(srcPath: StandardizedFilePath, destPath: StandardizedFilePath): void; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
flush Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                flush(): Promise<void>; // ------------------------------------------------------------------------ +0.3 Complexity index (+0.3 atomic)
            
                            
                        
flushSync Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                flushSync(): void; // ------------ +0.2 Complexity index (+0.2 atomic)
            
                            
                        
saveForDirectory Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                saveForDirectory(dirPath: StandardizedFilePath): Promise<void>; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
saveForDirectorySync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                saveForDirectorySync(dirPath: StandardizedFilePath): void; // ------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
moveFileImmediately Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                moveFileImmediately(oldFilePath: StandardizedFilePath, newFilePath: StandardizedFilePath, fileText: string): Promise<void>; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
moveFileImmediatelySync Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                moveFileImmediatelySync(oldFilePath: StandardizedFilePath, newFilePath: StandardizedFilePath, fileText: string): void; // ------------ +0.8 Complexity index (+0.8 atomic)
            
                            
                        
deleteFileImmediately Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                deleteFileImmediately(filePath: StandardizedFilePath): Promise<void>; // -------------------------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
deleteFileImmediatelySync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                deleteFileImmediatelySync(filePath: StandardizedFilePath): void; // ------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
copyDirectoryImmediately Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                copyDirectoryImmediately(srcDirPath: StandardizedFilePath, destDirPath: StandardizedFilePath): Promise<void>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
copyDirectoryImmediatelySync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                copyDirectoryImmediatelySync(srcDirPath: StandardizedFilePath, destDirPath: StandardizedFilePath): void; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
moveDirectoryImmediately Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                moveDirectoryImmediately(srcDirPath: StandardizedFilePath, destDirPath: StandardizedFilePath): Promise<void>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
moveDirectoryImmediatelySync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                moveDirectoryImmediatelySync(srcDirPath: StandardizedFilePath, destDirPath: StandardizedFilePath): void; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
deleteDirectoryImmediately Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                deleteDirectoryImmediately(dirPath: StandardizedFilePath): Promise<void>; // -------------------------------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
clearDirectoryImmediately Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /** Recreates a directory on the underlying file system asynchronously. */
                clearDirectoryImmediately(dirPath: StandardizedFilePath): Promise<void>; // --------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
clearDirectoryImmediatelySync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /** Recreates a directory on the underlying file system synchronously. */
                clearDirectoryImmediatelySync(dirPath: StandardizedFilePath): void; // ------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
deleteDirectoryImmediatelySync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                deleteDirectoryImmediatelySync(dirPath: StandardizedFilePath): void; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
fileExists Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                fileExists(filePath: StandardizedFilePath): false | Promise<boolean>; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
fileExistsSync Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                fileExistsSync(filePath: StandardizedFilePath): boolean; // -------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
directoryExistsSync Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                directoryExistsSync(dirPath: StandardizedFilePath): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
readFileSync Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                readFileSync(filePath: StandardizedFilePath, encoding: string | undefined): string; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
readFile Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                readFile(filePath: StandardizedFilePath, encoding: string | undefined): Promise<string>; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
readDirSync Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                readDirSync(dirPath: StandardizedFilePath): StandardizedFilePath[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
glob Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                glob(patterns: ReadonlyArray<string>): AsyncGenerator<StandardizedFilePath, void, unknown>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
globSync Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                globSync(patterns: ReadonlyArray<string>): Generator<StandardizedFilePath, void, unknown>; // -------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getFileSystem Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                getFileSystem(): FileSystemHost; // ----------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getCurrentDirectory Complexity Index 0.2 Cyclomatic complexity 1
                            
                                
                
                getCurrentDirectory(): StandardizedFilePath; // ------- +0.2 Complexity index (+0.2 atomic)
            
                            
                        
getDirectories Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                getDirectories(dirPath: StandardizedFilePath): StandardizedFilePath[]; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
realpathSync Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                realpathSync(path: StandardizedFilePath): StandardizedFilePath; // -------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getStandardizedAbsolutePath Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                getStandardizedAbsolutePath(fileOrDirPath: string, relativeBase?: string): StandardizedFilePath; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
readFileOrNotExists Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                readFileOrNotExists(filePath: StandardizedFilePath, encoding: string): false | Promise<string | false>; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
readFileOrNotExistsSync Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                readFileOrNotExistsSync(filePath: StandardizedFilePath, encoding: string): string | false; // -------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
writeFile Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                writeFile(filePath: StandardizedFilePath, fileText: string): Promise<void>; // ---------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
writeFileSync Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                writeFileSync(filePath: StandardizedFilePath, fileText: string): void; // ------------ +0.6 Complexity index (+0.6 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
                
                private constructor();
            
                            
                        
isNotExistsError Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the error is a file not found or directory not found error.
                 * @param err - Error to check.
                 */
                static isNotExistsError(err: any): boolean; // ---------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
pathJoin Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Joins the paths.
                 * @param paths - Paths to join.
                 */
                static pathJoin<T extends string>(basePath: T, ...paths: string[]): T; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
pathIsAbsolute Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the path is absolute.
                 * @param fileOrDirPath - File or directory path.
                 */
                static pathIsAbsolute(fileOrDirPath: string): boolean; // ----------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getStandardizedAbsolutePath Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the standardized absolute path.
                 * @param fileSystem - File system.
                 * @param fileOrDirPath - Path to standardize.
                 * @param relativeBase - Base path to be relative from.
                 */
                static getStandardizedAbsolutePath(fileSystem: FileSystemHost, fileOrDirPath: string, relativeBase?: string): StandardizedFilePath; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
getDirPath Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the directory path.
                 * @param fileOrDirPath - Path to get the directory name from.
                 */
                static getDirPath<T extends string>(fileOrDirPath: T): T; // --------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getBaseName Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the last portion of the path.
                 * @param fileOrDirPath - Path to get the base name from.
                 */
                static getBaseName(fileOrDirPath: StandardizedFilePath): string; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getExtension Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the extension of the file name.
                 * @param fileOrDirPath - Path to get the extension from.
                 */
                static getExtension(fileOrDirPath: StandardizedFilePath): string; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
standardizeSlashes Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Changes all back slashes to forward slashes.
                 * @param fileOrDirPath - Path.
                 */
                static standardizeSlashes<T extends string>(fileOrDirPath: T): T; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
pathEndsWith Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Checks if a path ends with a specified search path.
                 * @param fileOrDirPath - Path.
                 * @param endsWithPath - Ends with path.
                 */
                static pathEndsWith(fileOrDirPath: string | undefined, endsWithPath: string | undefined): boolean; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
pathStartsWith Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Checks if a path starts with a specified search path.
                 * @param fileOrDirPath - Path.
                 * @param startsWithPath - Starts with path.
                 */
                static pathStartsWith(fileOrDirPath: string | undefined, startsWithPath: string | undefined): boolean; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getParentMostPaths Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the parent most paths out of the list of paths.
                 * @param paths - File or directory paths.
                 */
                static getParentMostPaths(paths: StandardizedFilePath[]): StandardizedFilePath[]; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
readFileOrNotExists Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Reads a file or returns false if the file doesn't exist.
                 * @param fileSystem - File System.
                 * @param filePath - Path to file.
                 * @param encoding - File encoding.
                 */
                static readFileOrNotExists(fileSystem: FileSystemHost, filePath: StandardizedFilePath, encoding: string): Promise<string | false>; // ------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
readFileOrNotExistsSync Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Reads a file synchronously or returns false if the file doesn't exist.
                 * @param fileSystem - File System.
                 * @param filePath - Path to file.
                 * @param encoding - File encoding.
                 */
                static readFileOrNotExistsSync(fileSystem: FileSystemHost, filePath: StandardizedFilePath, encoding: string): string | false; // ------------ +1.0 Complexity index (+1.0 atomic)
            
                            
                        
getTextWithByteOrderMark Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the text with a byte order mark.
                 * @param text - Text.
                 */
                static getTextWithByteOrderMark(text: string): string; // ------------------------------------------------------------------------------ +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getRelativePathTo Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the relative path from one absolute path to another.
                 * @param absoluteDirPathFrom - Absolute directory path from.
                 * @param absolutePathTo - Absolute path to.
                 */
                static getRelativePathTo(absoluteDirPathFrom: StandardizedFilePath, absolutePathTo: StandardizedFilePath): StandardizedFilePath; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isRootDirPath Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the path is for the root directory.
                 * @param path - Path.
                 */
                static isRootDirPath(dirOrFilePath: StandardizedFilePath): boolean; // -------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
getDescendantDirectories Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the descendant directories of the specified directory.
                 * @param dirPath - Directory path.
                 */
                static getDescendantDirectories(fileSystemWrapper: TransactionalFileSystem, dirPath: StandardizedFilePath): IterableIterator<StandardizedFilePath>; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
toAbsoluteGlob Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets the glob as absolute.
                 * @param glob - Glob.
                 * @param cwd - Current working directory.
                 */
                static toAbsoluteGlob(glob: string, cwd: string): string; // ------------------------------------------------------------------------------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isNegatedGlob Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Gets if the glob is a negated glob.
                 * @param glob - Glob.
                 */
                static isNegatedGlob(glob: string): boolean; // -------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
matchGlobs Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
            
            
            /** Checks the specified file paths to see if the match any of the specified patterns. */
            export declare function matchGlobs(paths: ReadonlyArray<string>, patterns: ReadonlyArray<string> | string, cwd: string): string[]; // ------- +1.3 Complexity index (+1.3 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)
            
                            
                        
getSyntaxKindName Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Gets the enum name for the specified syntax kind.
             * @param kind - Syntax kind.
             */
            export declare function getSyntaxKindName(kind: ts.SyntaxKind): string; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
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)
            
                            
                        
matchFiles Complexity Index 2.9 Cyclomatic complexity 1
                            
                                
            
            
            export declare function matchFiles(this: any, path: string, extensions: ReadonlyArray<string>, excludes: ReadonlyArray<string>, includes: ReadonlyArray<string>, useCaseSensitiveFileNames: boolean, currentDirectory: string, depth: number | undefined, getEntries: (path: string) => FileSystemEntries, realpath: (path: string) => string): string[]; // ------- +2.9 Complexity index (+2.9 atomic)
            
                            
                        
getFileMatcherPatterns Complexity Index 1.5 Cyclomatic complexity 1
                            
                                
            
            
            export declare function getFileMatcherPatterns(this: any, path: string, excludes: ReadonlyArray<string>, includes: ReadonlyArray<string>, useCaseSensitiveFileNames: boolean, currentDirectory: string): FileMatcherPatterns; // ----------------------------------------------------------------------------------------------------------------------------------- +1.5 Complexity index (+1.5 atomic)
            
                            
                        
getEmitModuleResolutionKind Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
            
            
            export declare function getEmitModuleResolutionKind(this: any, compilerOptions: ts.CompilerOptions): any; // --------------------------------------------------------------------------------------------------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
isReadonlyArray Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                static isReadonlyArray<T>(a: unknown): a is ReadonlyArray<T>; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
isNullOrEmpty Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                static isNullOrEmpty<T>(a: (ReadonlyArray<T> | undefined)): a is undefined; // ------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
getUniqueItems Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                static getUniqueItems<T>(a: ReadonlyArray<T>): T[]; // ------------------------------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
removeFirst Complexity Index 0.7 Cyclomatic complexity 1
                            
                                
                
                static removeFirst<T>(a: T[], item: T): boolean; // ---------- +0.7 Complexity index (+0.7 atomic)
            
                            
                        
removeAll Complexity Index 1 Cyclomatic complexity 1
                            
                                
                
                static removeAll<T>(a: T[], isMatch: (item: T) => boolean): T[]; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
flatten Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                static flatten<T>(items: T[][]): T[]; // ---------------------------------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
from Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                static from<T>(items: ts.Iterator<T>): T[]; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
toIterator Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                static toIterator<T>(items: ReadonlyArray<T>): Generator<T, void, unknown>; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
sortByProperty Complexity Index 1.2 Cyclomatic complexity 1
                            
                                
                
                static sortByProperty<T>(items: T[], getProp: (item: T) => string | number): T[]; // ------- +1.2 Complexity index (+1.2 atomic)
            
                            
                        
groupBy Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                static groupBy<T>(items: ReadonlyArray<T>, getGroup: (item: T) => string | number): T[][]; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
binaryInsertWithOverwrite Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                static binaryInsertWithOverwrite<T>(items: T[], newItem: T, comparer: Comparer<T>): void; // -------- +1.1 Complexity index (+1.1 atomic)
            
                            
                        
binarySearch Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                static binarySearch<T>(items: ReadonlyArray<T>, storedComparer: StoredComparer<T>): number; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
containsSubArray Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                static containsSubArray<T>(items: ReadonlyArray<T>, subArray: ReadonlyArray<T>): boolean; // --------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
deepClone Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
            
            
            /**
             * Deep clones an object not maintaining references.
             * @remarks If this has a circular reference it will go forever so be careful.
             */
            export declare function deepClone<T extends object>(objToClone: T): T; // --------------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
subscribe Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Subscribe to an event being fired.
                 * @param subscription - Subscription.
                 */
                subscribe(subscription: EventContainerSubscription<EventArgType>): void; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
unsubscribe Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Unsubscribe to an event being fired.
                 * @param subscription - Subscription.
                 */
                unsubscribe(subscription: EventContainerSubscription<EventArgType>): void; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
fire Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Fire an event.
                 */
                fire(arg: EventArgType): void; // --------------------------------------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
find Complexity Index 1 Cyclomatic complexity 1
                            
                                
            
                static find<T>(items: IterableIterator<T>, condition: (item: T) => boolean): T | undefined; // ------- +1.0 Complexity index (+1.0 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
clone Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                static clone<T>(obj: T): T; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
assign Complexity Index 0.9 Cyclomatic complexity 1
                            
                                
                
                static assign<T, U>(a: T, b: U): T & U; // ------- +0.9 Complexity index (+0.9 atomic)
            
                            
                        
assign Complexity Index 1.3 Cyclomatic complexity 1
                            
                                
                
                static assign<T, U, V>(a: T, b: U, c: V): T & U & V; // ------- +1.3 Complexity index (+1.3 atomic)
            
                            
                        
Complexity Index 0 Cyclomatic complexity 0
                            
                                
            
                private constructor();
            
                            
                        
isWhitespaceCharCode Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                static isWhitespaceCharCode(charCode: number | undefined): boolean; // ------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
isSpaces Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                static isSpaces(text: string): boolean; // ----------------------------------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
hasBom Complexity Index 0.3 Cyclomatic complexity 1
                            
                                
                
                static hasBom(text: string): boolean; // --------- +0.3 Complexity index (+0.3 atomic)
            
                            
                        
stripBom Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static stripBom(text: string): string; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
isNullOrWhitespace Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                static isNullOrWhitespace(str: string | undefined): str is undefined; // ------- +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isNullOrEmpty Complexity Index 0.5 Cyclomatic complexity 1
                            
                                
                
                static isNullOrEmpty(str: string | undefined): str is undefined; // ------------ +0.5 Complexity index (+0.5 atomic)
            
                            
                        
isWhitespace Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static isWhitespace(text: string | undefined): boolean; // ---------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
startsWithNewLine Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static startsWithNewLine(str: string | undefined): boolean; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
endsWithNewLine Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static endsWithNewLine(str: string | undefined): boolean; // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
insertAtLastNonWhitespace Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                static insertAtLastNonWhitespace(str: string, insertText: string): string; // ------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
getLineNumberAtPos Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static getLineNumberAtPos(str: string, pos: number): number; // --------------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getLengthFromLineStartAtPos Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static getLengthFromLineStartAtPos(str: string, pos: number): number; // ------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getLineStartFromPos Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static getLineStartFromPos(str: string, pos: number): number; // --------------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
getLineEndFromPos Complexity Index 0.4 Cyclomatic complexity 1
                            
                                
                
                static getLineEndFromPos(str: string, pos: number): number; // --------- +0.4 Complexity index (+0.4 atomic)
            
                            
                        
escapeForWithinString Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                static escapeForWithinString(str: string, quoteKind: "\"" | "'"): string; // ------- +0.8 Complexity index (+0.8 atomic)
            
                            
                        
escapeChar Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
                
                /**
                 * Escapes all the occurrences of the char in the string.
                 */
                static escapeChar(str: string, char: string): string; // --------------------------- +0.6 Complexity index (+0.6 atomic)
            
                            
                        
removeIndentation Complexity Index 0.8 Cyclomatic complexity 1
                            
                                
                
                static removeIndentation(str: string, opts: { // --------------- +0.4 Complexity index (+0.4 atomic)
                    isInStringAtPos: (pos: number) => boolean; // -------------- +0.2 Complexity index (+0.2 atomic)
                    indentSizeInSpaces: number; // ----------------------------- +0.1 Complexity index (+0.1 atomic)
                }): string; // ------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
            
                            
                        
indent Complexity Index 1.1 Cyclomatic complexity 1
                            
                                
                
                static indent(str: string, times: number, options: { // ------- +0.5 Complexity index (+0.5 atomic)
                    indentText: string; // ------------------------------------ +0.2 Complexity index (+0.2 atomic)
                    indentSizeInSpaces: number; // ---------------------------- +0.1 Complexity index (+0.1 atomic)
                    isInStringAtPos: (pos: number) => boolean; // ------------- +0.2 Complexity index (+0.2 atomic)
                }): string; // ------------------------------------------------ +0.1 Complexity index (+0.1 atomic)
            
                            
                        
getLibFiles Complexity Index 0.6 Cyclomatic complexity 1
                            
                                
            
            
            /** Loads the lib files that are stored in a separate module. */
            export declare function getLibFiles(): { // ------------------------------- +0.2 Complexity index (+0.2 atomic)
                fileName: string; // -------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                text: string; // ------------------------------------------------------ +0.2 Complexity index (+0.2 atomic)
            }[];