tnp-helpers 21.0.2 → 21.0.5

package/browser/types/tnp-helpers.d.ts

@@ -0,0 +1,3202 @@
+// @ts-nocheck
+import * as child_process from 'child_process';
+import { ChildProcess as ChildProcess$1 } from 'child_process';
+import { Level } from 'ng2-logger/browser';
+import { CopyOptionsSync } from 'fs-extra';
+import * as tnp_core_browser from 'tnp-core/browser';
+import { CoreHelpers, CoreModels } from 'tnp-core/browser';
+import { Subject, BehaviorSubject } from 'rxjs';
+import { StdioOptions, ChildProcess } from 'node:child_process';
+import * as ts from 'typescript';
+import * as tnp_helpers from 'tnp-helpers';
+import { PackageJson as PackageJson$1 } from 'type-fest';
+import { TaonBaseEntity, TaonBaseController, Taon, TaonBaseClass, EndpointContext, Models } from 'taon/browser';
+import { BaseClientCompiler, BaseClientCompilerOptions, ChangeOfFile } from 'incremental-compiler/browser';
+import * as vscode from 'vscode';
+import { OutputChannel, ExtensionContext, Uri } from 'vscode';
+
+declare namespace HelpersAngular {
+    class SerializedSubject<T> {
+        id: string;
+        constructor(id: string);
+    }
+    /**
+     * if you are using this.. please call Helpers.ng.unsubscribe(this.$destroy) in ngOnDestroy();
+     */
+    function serialize(destroy$: Subject<any>): SerializedSubject<any>;
+    /**
+     * if you are using this.. please call Helpers.ng.unsubscribe(this.$destroy) in ngOnDestroy();
+     */
+    function deserialize(destroy$: SerializedSubject<any>): Subject<any>;
+    function unsubscribe(destroy$: Subject<any>): void;
+    /**
+    get properties from scss file
+  
+    import styles from './tasks-ngrx-data.component.scss';
+  
+    export class ExampleComponent {
+      sassFile = sassFile(styles);
+  
+      async ngOnInit() {
+        this.tasksService.getAll();
+        console.log(this.sassFile.stringValue('--max-container-size'))
+        console.log(this.sassFile.numberValue('--max-container-size'))
+      }
+    }
+       */
+    function sassFile(styles: string): {
+        stringValue: (name: string) => string;
+        numberValue: (name: string) => number;
+    };
+}
+
+declare namespace UtilsNpm {
+    export const isProperVersion: (npmVersion: string) => any;
+    export const isSpecialVersion: (version: string) => boolean;
+    export const clearVersion: (version: string, options: {
+        removePrefixes?: boolean;
+        /**
+         * Remove alpha, beta, rc, latest, next etc.
+         */
+        removeSuffix?: boolean;
+    }) => string;
+    export const fixMajorVerNumber: (version: string) => string;
+    type LatestType = 'major' | 'minor' | 'patch' | {
+        majorUpTo?: number;
+        minorUpTo?: number;
+    };
+    export const getLatestVersionFromNpm: (packageName: string, options?: {
+        currentPackageVersion?: string;
+        latestType?: LatestType;
+        skipAlphaBetaNext?: boolean;
+    }) => Promise<string>;
+    export const checkIfPackageVersionAvailable: (pkgName: string, pkgVersion: string) => Promise<boolean>;
+    export const getLastMajorVersions: (pkgName: string) => Promise<string[]>;
+    export const getLastMinorVersionsForMajor: (majorVer: number, pkgName: string) => Promise<string[]>;
+    export interface VersionObjectNpm {
+        major: number;
+        minor: number;
+        patch: number;
+    }
+    export const getVerObj: (version: string) => VersionObjectNpm;
+    /**
+     * @deprecated TODO remvoe
+     */
+    export const getLastVersions: (pkgName: string, currentVerObj: VersionObjectNpm, latestVerObj: VersionObjectNpm) => Promise<string[]>;
+    export {};
+}
+declare namespace UtilsTypescript {
+    /**
+     * Remove TypeScript region blocks by their name, including nested regions.
+     *
+     * @param sourceCode - The TypeScript source code as a string.
+     * @param regionName - The name of the region to remove.
+     * @returns Modified TypeScript code without the specified regions.
+     */
+    const removeRegionByName: (sourceCode: string, regionName: string) => string;
+    interface ExportInfo {
+        type: 'class' | 'function' | 'const' | 'let' | 'var' | 'enum' | 'type' | 'interface' | 'default' | 'module' | 'namespace';
+        name: string;
+    }
+    /**
+     * Function to extract exports from a TypeScript file
+     */
+    const exportsFromFile: (filePath: string) => ExportInfo[];
+    /**
+     * Function to extract exports from a TypeScript file
+     */
+    const exportsFromContent: (fileContent: string) => ExportInfo[];
+    const extractDefaultClassNameFromString: (sourceCode: string) => string | undefined;
+    const extractClassNameFromString: (sourceCode: string) => string[];
+    const extractClassNamesFromFile: (absoluteFilePath: string) => string[];
+    const extractDefaultClassNameFromFile: (absoluteFilePath: string) => any;
+    const formatFile: (absPathToFile: string | string[]) => void;
+    const formatAllFilesInsideFolder: (absPathToFolder: string) => void;
+    const eslintFixFile: (absPathToFile: string | string[]) => void;
+    const eslintFixAllFilesInsideFolder: (absPathToFolder: string | string[]) => void;
+    const getTaonContextFromContent: (fileContent: string) => string[];
+    const getTaonContextsNamesFromFile: (tsAbsFilePath: string) => string[];
+    const extractAngularComponentSelectors: (fileAbsPath: string) => {
+        className: string;
+        selector: string;
+    }[];
+    const wrapWithComment: (oneLineComment: string, absDestFilePath: string) => any;
+    /**
+     * Attempts to set or add an exported const with given name and value.
+     */
+    const setValueToVariableInTsFile: (tsAbsFilePath: string, variableName: string, valueOfVariable: any, options?: {
+        skipAddIfNotExists?: boolean;
+        useRawStringValue?: boolean;
+    }) => void;
+    class TsImportExport {
+        /**
+         * for external modification
+         */
+        embeddedPathToFileResult: string;
+        /**
+         * for external modification
+         */
+        packageName: string;
+        /**
+         * for external modification
+         */
+        isIsomorphic?: boolean;
+        readonly type: 'export' | 'import' | 'async-import' | 'require';
+        /**
+         * ORIGNAL
+         * Name of the file that is being imported/exported
+         * with parenthesis included , example
+         * 'my-file' or "my-file" or `my-file`
+         */
+        readonly embeddedPathToFile: string;
+        /**
+         * same as cleanEmbeddedPathToFile but without quotes (parenthesis), example:
+         * my-file or my-file or my-file
+         */
+        readonly cleanEmbeddedPathToFile: string;
+        readonly startRow: number;
+        readonly startCol: number;
+        readonly endRow: number;
+        readonly endCol: number;
+        readonly parenthesisType: 'single' | 'double' | 'tics';
+        readonly importElements: string[];
+        constructor(type: 'export' | 'import' | 'async-import' | 'require', embeddedPathToFile: string, start: ts.LineAndCharacter, end: ts.LineAndCharacter, parenthesisType: 'single' | 'double' | 'tics', importElements?: string[]);
+        private removeStartEndQuotes;
+        /**
+         * it will extract part of the file content
+         * that is between startRow, startCol and endRow, endCol
+         * and contains import/export/require statement
+         */
+        getStringPartFrom(wholeContentOfFile: string): string;
+        wrapInParenthesis(str: string): string;
+    }
+    const recognizeImportsFromFile: (fileAbsPAth: string) => TsImportExport[];
+    const recognizeImportsFromContent: (fileContent: string) => TsImportExport[];
+    /**
+     * Transition methods ng18 => ng19
+     * Adds standalone: false if not exists in component decorator
+     */
+    function transformComponentStandaloneOption(sourceText: string): string;
+    const fixHtmlTemplatesInDir: (directoryPath: string) => void;
+    function removeTaggedImportExport(tsFileContent: string, tags: string[]): string;
+    const wrapFirstImportsInImportsRegion: (fileContent: string) => string;
+    /**
+     * wrap class field with decorators
+     * wrap class methods with decorators
+     */
+    function wrapContentClassMembersDecoratorsWithRegion(classFileContent: string, wrapTag?: string): string;
+    type FlattenMapping = {
+        [modulePath: string]: {
+            [oldQualifiedName: string]: string;
+        };
+    };
+    function transformFlatImports(sourceText: string, mapping: FlattenMapping): string;
+    const clearRequireCacheRecursive: (modulePath: string, seen?: Set<string>) => void;
+    type DeepWritable<T> = {
+        -readonly [P in keyof T]: T[P] extends object ? T[P] extends Function ? T[P] : DeepWritable<T[P]> : T[P];
+    };
+}
+declare namespace UtilsHttp {
+    const startHttpServer: (cwd: string, port: number, options?: {
+        startMessage?: string;
+    }) => Promise<any>;
+}
+declare namespace UtilsMd {
+    /**
+     * extract assets pathes from .md file
+     */
+    const getAssets: (mdfileContent: string) => string[];
+    const getAssetsFromFile: (absPathToFile: string) => string[];
+    /**
+     * Extract links to other Markdown files from a given Markdown content.
+     * @param mdfileContent
+     */
+    const getLinksToOtherMdFiles: (mdfileContent: string) => string[];
+    const moveAssetsPathsToLevelFromFile: (absFilePath: string, level?: number) => string | undefined;
+    /**
+     * Move asset paths to a higher directory level by adding "../" before each path.
+     *
+     * @param mdfileContent - The content of the .md file.
+     * @param level - The number of levels to go up (default is 1).
+     * @returns The modified content with updated asset paths.
+     */
+    const moveAssetsPathsToLevel: (mdfileContent: string, level?: number) => string;
+}
+declare namespace UtilsQuickFixes {
+    /**
+     *
+     * @param node_modules/sql.js/dist/sql-wasm.js
+     */
+    const replaceKnownFaultyCode: (contentofSQLWasmJS: string) => string;
+    /**
+     * for some reason electron is being bundled - and it is not needed for cli
+     */
+    const replaceElectronWithNothing: (jsContent: string, packageName: string) => string;
+}
+declare namespace UtilsVSCode {
+    const calculateContrastingHexColor: (hex: string) => string;
+    const generateFancyColor: () => string;
+    const vscodeImport: () => any;
+    const regenerateVsCodeSettingsColors: (cwd: string, overideBottomColor?: string) => void;
+}
+declare namespace UtilsZipBrowser {
+    const zipDirBrowser: (fileList: FileList) => Promise<Blob>;
+    const unzipArchiveBrowser: (zipBlob: Blob) => Promise<Map<string, Blob>>;
+}
+declare namespace UtilsZip {
+    const splitFile7Zip: (inputPath: string, partSizeMB?: number) => Promise<number>;
+    /**
+     * Splits a file into smaller parts if its size exceeds the specified part size.
+     * @returns true if file was split, false if not needed
+     */
+    const splitFile: (inputPath: string, partSizeMB?: number) => Promise<number>;
+    /**
+     * @returns absolute path to zip file
+     */
+    const zipDir: (absPathToDir: string, options?: {
+        /**
+         * default false
+         */
+        overrideIfZipFileExists?: boolean;
+    }) => Promise<string>;
+    const unzipArchive: (absPathToZip: string) => Promise<void>;
+}
+declare namespace UtilsTaonWorker {
+    const getUniqueForTask: (task: string, location: string | string[]) => string;
+}
+declare namespace UtilsJava {
+    const selectJdkVersion: () => Promise<string | undefined>;
+    const detectJavaVersionMacOS: (javaHome: string) => string;
+    const updateJavaHomePath: (selectedPath: string) => void;
+    const selectTomcatVersion: () => Promise<string>;
+    const updateTomcatHomePath: (selectedPath: string) => void;
+}
+declare namespace UtilsPasswords {
+    const hashPassword: (password: string) => Promise<string>;
+    const verifyPassword: (password: string, stored: string) => Promise<boolean>;
+}
+declare namespace UtilsDocker {
+    const DOCKER_LABEL_KEY = "com.docker.compose.project";
+    const DOCKER_TAON_PROJECT_LABEL = "com.docker.compose.taon.project=true";
+    const cleanImagesAndContainersByDockerLabel: (labelKey: string, labelValue: string) => Promise<void>;
+    interface DockerComposeActionOptions {
+        composeFileName?: string;
+        cwd?: string;
+        env?: NodeJS.ProcessEnv;
+        skipBuild?: boolean;
+        stdio?: StdioOptions;
+        useFirstYmlFound?: boolean;
+    }
+    type DockerComposeActionType = 'up' | 'down';
+    /**
+     * @returns cmd + args array
+     * you can use with child_process.spawn
+     * const [cmd, ...args] = getDockerComposeActionCommand('up');
+     * child.spawn(cmd, args, { ... });
+     *
+     * @param action 'up' | 'down'
+     */
+    const getDockerComposeActionCommand: (action: DockerComposeActionType, options?: Omit<DockerComposeActionOptions, "cwd" | "env" | "stdio" | "useFirstYmlFound">) => string[];
+    const getDockerComposeActionChildProcess: (action: DockerComposeActionType, options?: DockerComposeActionOptions) => ChildProcess;
+    const removeAllTaonContainersAndImagesFromDocker: () => Promise<void>;
+    /**
+     * @TODO @REFACTOR use async stuff
+     */
+    const linkPodmanAsDockerIfNecessary: () => Promise<void>;
+}
+/**
+ * ! TODO @IN_PROGRESS @LAST
+ */
+declare namespace UtilsFileSync {
+    interface FoldersSyncOptions {
+        androidFolder: string;
+        macPhotosLibrary: string;
+        tempConvertFolder: string;
+        /**
+         * If true, skips the terminal menu confirmation on startup
+         * (default: false) - perfect for automated scripts
+         */
+        skipTerminalMenu?: boolean;
+        /**
+         * for testing purposes only
+         */
+        onlyProcessFiles?: string[];
+    }
+    export const forFolders: (folder: FoldersSyncOptions) => Promise<void>;
+    export {};
+}
+
+declare class HelpersArrayObj {
+    from(s: string | string[]): string[];
+    second(arr: any): any;
+    /**
+     * @deprecated
+     * use moveObjectBefore
+     */
+    arrayMoveElementBefore<T = any>(arr: any[], a: any, b: any, prop?: keyof T): any[];
+    /**
+     * @deprecated
+     * use moveObjectAfter
+     */
+    arrayMoveElementAfterB<T = any>(arr: any[], a: any, b: any, prop?: keyof T): any[];
+    moveObjectBefore<T = any>(array: T[], target: T, before: T): T[];
+    moveObjectAfter<T = any>(array: T[], target: T, after: T): T[];
+    /**
+     * @deprecated use Utils.uniqArray from tnp-core
+     */
+    uniqArray<T = any>(array: any[], uniqueProperty?: keyof T): T[];
+    /**
+     * @deprecated use Utils.uniqArray from tnp-core
+     */
+    sortKeys(obj: any): any;
+    /**
+     * Fuzzy search
+     */
+    fuzzy<T = any>(query: string, list: T[], valueFn?: (modelFromList: T) => string): {
+        matches: string[];
+        results: T[];
+    };
+}
+
+declare class HelpersStringsRegexes {
+    escapeStringForRegEx(s: string): string;
+    matchExactOnce(s: string, regex: RegExp): string;
+    get regex(): {
+        /**
+       * mathes
+       * xxx.xxx.xxx.xxx
+       * xxx.xxx.xxx.xxx:port
+       * http://xxx.xxx.xxx.xxx:port
+       * http://xxx.xxx.xxx.xxx
+       * https://xxx.xxx.xxx.xxx:port
+       * https://xxx.xxx.xxx.xxx   *
+       */
+        readonly forStringWithIpHost: RegExp;
+        /**
+      * mathes
+      * http://domain.com:port
+      * http://domain.com
+      * http://domain:port
+      * http://domain
+      * https://domain.com:port
+      * https://domain.com
+      * https://domain:port
+      * https://domain
+      */
+        readonly forStringWithDomainHost: RegExp;
+    };
+}
+
+declare class HelpersStrings {
+    /**
+     * Example:
+     *
+     * const result = interpolateString("I'm {age} years old!")
+     * .withParameters({ age: 29 });
+     *
+     * const result = interpolateString("The {a} says {n}, {n}, {n}!")
+     * .withParameters({ a: 'cow', n: 'moo' });
+     *
+     *
+     * @param value string to interpolate
+     * @param parameters object with parametes
+     */
+    interpolateString<T = any>(value: string): {
+        withParameters(parameters: T): string;
+    };
+    /**
+     *
+     * @param pixelsCss exmaple: 100px
+     * @returns number value
+     */
+    numValue(pixelsCss: string): number;
+    /**
+     * examples:
+     * 'aa bb bb' => ['aa','bb','cc'],
+     * 'aa' => ['aa']
+     * ['aa'] => ['aa']
+     */
+    splitIfNeed(stringOrArr: string | string[]): string[];
+    removeDoubleOrMoreEmptyLines(s: string): string;
+    /**
+     *
+     * https://stackoverflow.com/a/57129703/1345101
+     *
+     * Returns the plural of an English word.
+     *
+     * @export
+     * @param {string} word
+     * @param {number} [amount]
+     * @returns {string}
+     */
+    plural(word: string, amount?: number): string;
+    /**
+     * https://stackoverflow.com/a/57129703/1345101
+     *
+    * Returns the singular of an English word.
+    *
+    * @export
+    * @param {string} word
+    * @param {number} [amount]
+    * @returns {string}
+    */
+    singular(word: string, amount?: number): string;
+}
+
+declare class HelpersProcess {
+    restartApplicationItself(nameOfApp: string): Promise<any>;
+    osIsMacOs(versino: 'big-sur' | 'catalina'): any;
+    generatedFileWrap(content: string): any;
+    changeCwdWrapper(dir: string, functionToExecure: Function, logLevel?: Level): Promise<any>;
+    changeCwd(dir?: string): any;
+    /**
+     * // TODO refactor this
+     * @deprecated
+     */
+    goToDir(dir?: string): any;
+    pressKeyOrWait(message?: string, printWaitMessages?: number): Promise<any>;
+    /**
+     * @deprecated use UtilsTerminal.pressAnyKey
+     */
+    pressKeyAndContinue(message?: string): any;
+    /**
+     * @deprecated use UtilsTerminal.multiselect
+     */
+    list<T = string>(question: string, choices: {
+        name: string;
+        value: T;
+    }[] | {
+        [choice: string]: {
+            name: string;
+        };
+    }): Promise<any>;
+    /**
+     * @deprecated use UtilsTerminal.multiselect
+     */
+    multipleChoicesAsk(question: string, choices: {
+        name: string;
+        value: string;
+    }[], autocomplete?: boolean, selected?: {
+        name: string;
+        value: string;
+    }[]): Promise<string[]>;
+    /**
+     * @deprecated use UtilsTerminal.input
+     */
+    input(options: {
+        defaultValue?: string;
+        question: string;
+        validate?: (value: string) => boolean;
+    }): Promise<string>;
+    /**
+     * @deprecated use UtilsTerminal.multiselect
+     * TODO wierd problem when pressing key like "i"
+     */
+    selectChoicesAsk<T = string>(question: string, choices: {
+        name: string;
+        value: T;
+    }[] | {
+        [choice: string]: {
+            name: string;
+        };
+    }): Promise<T>;
+    autocompleteAsk<T = string>(question: string, choices: {
+        name: string;
+        value: T;
+    }[], pageSize?: number): Promise<T>;
+    getWorkingDirOfProcess(PID: number): any;
+    outputToVScode(data: {
+        label: string;
+        option: string;
+    }[] | string, disableEncode?: boolean): any;
+    actionWrapper(fn: () => void, taskName?: string): Promise<any>;
+    terminalLine(): any;
+    /**
+     * THIS DEOS NOT WORK !
+     * ! TOOD FIX THIS
+     */
+    killAllNodeExceptCurrentProcess(): Promise<any>;
+    killAllNode(): any;
+    formatPath(pathToFileOrFolder: string): any;
+    /**
+     * @deprecated
+     */
+    prepareWatchCommand(cmd: any): any;
+    /**
+     * @deprecated
+     */
+    getStringFrom(command: string, descriptionOfCommand?: string): any;
+    waitForMessegeInStdout(proc: ChildProcess$1, message: string): Promise<any>;
+}
+
+interface GetRecrusiveFilesFromOptions {
+}
+declare class HelpersFileFolders {
+    /**
+     * Calculate file or string checksum
+     */
+    checksum(absolutePathToFileOrContent: string, algorithm?: 'md5' | 'sha1'): any;
+    getValueFromJSON(filepath: string, lodashGetPath: string, defaultValue?: any): any;
+    getValueFromJSONC(filepath: string, lodashGetPath: string, defaultValue?: any): any;
+    readValueFromJson(filepath: string, lodashGetPath: string, defaultValue?: any): any;
+    readValueFromJsonC(filepath: string, lodashGetPath: string, defaultValue?: any): any;
+    setValueToJSON(filepath: string | string[], lodashGetPath: string, value: any): void;
+    setValueToJSONC(filepath: string, lodashGetPath: string, value: any): void;
+    /**
+     * file size in bytes
+     */
+    size(filePath: string): number;
+    pathFromLink(filePath: string): string;
+    /**
+     * @deprecated
+     */
+    renameFolder(from: string, to: string, cwd?: string): void;
+    /**
+     * @deprecated
+     */
+    renameFiles(from: string, to: string, cwd?: string): void;
+    getTempFolder(): any;
+    isPlainFileOrFolder(filePath: string): boolean;
+    /**
+     * @deprecated
+     * use import (or modules only on backend)
+     */
+    requireUncached(module: string): any;
+    /**
+     * @deprecated
+     * use import (or modules only on backend)
+     *
+     * get default export object from  js file
+     * @param jsFilePath
+     */
+    require(jsFilePath: string): any;
+    tryRecreateDir(dirpath: string): void;
+    /**
+     * @deprecated
+     */
+    tryCopyFrom(source: string, destination: string, options?: {}): void;
+    move(from: string, to: string, options?: {
+        purpose?: string;
+    }): void;
+    findChildren<T>(location: string, createFn: (childLocation: string) => T, options?: {
+        allowAllNames: boolean;
+    }): T[];
+    /**
+     * @deprecated
+     */
+    findChildrenNavi<T>(location: string, createFn: (childLocation: string) => T): T[];
+    /**
+     * get all files from folder
+     * absolute paths
+     */
+    getRecrusiveFilesFrom(dir: string, ommitFolders?: string[], options?: GetRecrusiveFilesFromOptions): string[];
+    checkIfNameAllowedForTaonProj(folderName: string): boolean;
+    getLinesFromFiles(filename: string, lineCount?: number): Promise<string[]>;
+    /**
+     * Get the most recent changes file in direcory
+     * @param dir absoulute path to file
+     */
+    getMostRecentFileName(dir: string): string;
+    getMostRecentFilesNames(dir: string): string[];
+    removeExcept(fromPath: string, exceptFolderAndFiles: string[]): void;
+    /**
+     * Copy folder using os native command
+     * (perfect for large folders/files)
+     */
+    copyFolderOsNative(from: string, to: string, options?: {
+        removeDestination?: boolean;
+    }): Promise<void>;
+    copy(sourceDir: string | string[], destinationDir: string | string[], options?: {
+        filter?: any;
+        overwrite?: boolean;
+        recursive?: boolean;
+        asSeparatedFiles?: boolean;
+        asSeparatedFilesAllowNotCopied?: boolean;
+        asSeparatedFilesSymlinkAsFile?: boolean;
+        /**
+         * folders to omit: example: ['src','node_modules']
+         *
+         * This option works only with omitFoldersBaseFolder
+         */
+        omitFolders?: string[];
+        /**
+         * absolute path for base folder for omitFolder option
+         */
+        omitFoldersBaseFolder?: string;
+        copySymlinksAsFiles?: boolean;
+        copySymlinksAsFilesDeleteUnexistedLinksFromSourceFirst?: boolean;
+        useTempFolder?: boolean;
+        dontAskOnError?: boolean;
+    } & CopyOptionsSync): void;
+    filterDontCopy(basePathFoldersTosSkip: string[], projectOrBasepath: string): any;
+    filterOnlyCopy(basePathFoldersOnlyToInclude: string[], projectOrBasepath: string): any;
+    copyFile(sourcePath: string | string[], destinationPath: string | string[], options?: {
+        transformTextFn?: (input: string) => string;
+        debugMode?: boolean;
+        fast?: boolean;
+        dontCopySameContent?: boolean;
+    }): boolean;
+    /**
+     * get real absolute path
+     */
+    resolve(fileOrFolderPath: string): string;
+}
+
+declare class HelpersNumber {
+    /**
+     * @deprecated
+     * use _.random()
+     */
+    randomInteger: (max: any, min: any) => any;
+}
+
+declare class HelpersBrowser {
+    private static callbacks;
+    static onInit(callback: (ins: HelpersBrowser) => any): void;
+    get win(): Window & typeof globalThis;
+    private get tabIdSessionStorage();
+    readonly tabId: number;
+    private static inst;
+    init: void;
+    private constructor();
+    static get instance(): HelpersBrowser;
+}
+
+/**
+ * Mixing for multiclass inheritance
+ *
+ * How to use It:
+ *
+ * class Wolverine {}
+ * class Jean {}
+ * export class Child {}
+ * export interface MyChild implements Wolverine, Jean {}
+ * applyMixing(Child,[Wolverine, Jean]);
+ *
+ * @param derivedCtor Target Class
+ * @param baseCtors Base Classes
+ */
+declare function applyMixins(derivedCtor: any, baseCtors: any[]): void;
+declare class HelpersTaon extends CoreHelpers {
+    arrays: HelpersArrayObj;
+    strings: HelpersStrings;
+    numbers: HelpersNumber;
+    browser: HelpersBrowser;
+    ng: typeof HelpersAngular;
+    private static _instance;
+    static get Instance(): HelpersTaon;
+    private constructor();
+    CLIWRAP(f: Function, name: string): Function;
+    /**
+     * Bundle file with node_modules into one file
+     * default strategy is cli
+     * Please keep:  'ts-node', 'typescript' as dependency in your package.json
+     */
+    bundleCodeIntoSingleFile(pathToJsFile: string, outputFilePath: string, options?: {
+        strategy?: 'cli' | 'vscode-ext' | 'node-app' | 'electron-app';
+        /**
+         * ! beforeWrite needs to return output
+         */
+        beforeWrite?: (options: {
+            output?: string;
+            copyToDestination?: (fileOrFolderAbsPath: string) => void;
+        }) => string;
+        additionalExternals?: string[];
+        additionalReplaceWithNothing?: string[];
+        skipFixingSQLlite?: boolean;
+        minify?: boolean;
+    }): Promise<void>;
+    /**
+     * @deprecated
+     * use Utils.uniqArray from tnp-core
+     */
+    uniqArray<T = any>(array: any[], uniqueProperty?: keyof T): T[];
+    slash(pathFromWindowsOrUnixType: string): any;
+    isElevated(): Promise<void>;
+    mesureExectionInMs(description: string, functionToExecute: Function, ...functionArguments: any[]): Promise<number>;
+    mesureExectionInMsSync(description: string, functionToExecute: () => void): number;
+    waitForCondition(conditionFn: (any: any) => boolean, howOfftenCheckInMs?: number): Promise<unknown>;
+    getMethodName(classObject: any, method: any): string;
+    /**
+     * @deprecated
+     */
+    fixWebpackEnv(env: Object): void;
+    /**
+     * @deprecated
+     */
+    workerCalculateArray(dataToSplit: any[], operation: (dataChunk: any[], workerNumber?: number | undefined) => Promise<void>, options?: {
+        maxesForWorkes?: {
+            [workerMaxes: number]: number;
+        };
+        workerLimit?: number;
+        globals?: any;
+    }): Promise<void>;
+    checkEnvironment(deps?: CoreModels.GlobalDependencies): any;
+    applyMixins: typeof applyMixins;
+}
+interface HelpersTaon extends HelpersStringsRegexes, HelpersProcess, HelpersFileFolders {
+}
+
+declare abstract class BaseFeatureForProject<PROJECT extends BaseProject<any, any> = BaseProject<any, any>> {
+    protected project: PROJECT;
+    get ins(): tnp_helpers.BaseProjectResolver<any>;
+    constructor(project: PROJECT);
+}
+
+declare class BaseProcessManger<PROJECT extends BaseProject<any, any> = BaseProject<any, any>> extends BaseFeatureForProject<PROJECT> {
+    private initialOptions;
+    private allProcesses;
+    private selectedProcesses;
+    outputBuffer: string[];
+    startedProcesses: Set<CommandProcess>;
+    watch: boolean;
+    private _showLogs;
+    set showLogs(value: boolean);
+    get showLogs(): boolean;
+    /**
+     * special config for Helpers.executer
+     */
+    hideOutput: {
+        stderr: boolean;
+        stdout: boolean;
+        acceptAllExitCodeAsSuccess: boolean;
+    };
+    constructor(project: PROJECT);
+    init<PROJECT = BaseProject<any, any>>(initialOptions: ProcessManagerConfig<PROJECT>): Promise<void>;
+    private showOutput;
+    private killOrBuildMenu;
+    makeSureSelectedProcessesAreRunning(): Promise<void>;
+    private startProcessWithDependencies;
+    private buildMenu;
+}
+
+type BaseProjectType = CoreModels.BaseProjectType;
+declare const BaseProjectTypeArr: string[];
+/**
+ * Angular project type
+ */
+type NgProject = {
+    projectType: 'library' | 'application';
+    /**
+     * where ng-packagr.json is located, tsconfig etc.
+     */
+    root: string;
+    /**
+     * Source code project
+     */
+    sourceRoot: string;
+    prefix: string;
+};
+type LibraryBuildCommandOptions = {
+    watch?: boolean;
+};
+type LibrariesBuildOptions<PROJECT extends BaseProject = BaseProject> = {
+    strategy?: 'link' | 'copy';
+    /**
+     * by default we are copying all libraries to node_modules of itself
+     */
+    copylink_to_node_modules?: string[];
+    releaseBuild?: boolean;
+    /**
+     * override build options for specific libraries
+     * @todo
+     */
+    libraries?: PROJECT[];
+    outputLineReplace?: (libForOutput: PROJECT, useExternalProvidedLibs: boolean) => (line: string) => string;
+    useLastUserConfiguration?: boolean;
+};
+type TestBuildOptions = {
+    onlySpecyficFiles?: string[];
+    updateSnapshot?: boolean;
+};
+interface ChangelogData {
+    changes: string[];
+    version: string;
+    date: string;
+}
+interface PushProcessOptions {
+    force?: boolean;
+    typeofCommit?: TypeOfCommit;
+    mergeUpdateCommits?: boolean;
+    askToConfirmPush?: boolean;
+    askToConfirmCommit?: boolean;
+    skipLint?: boolean;
+    askToConfirmBranchChange?: boolean;
+    origin?: string;
+    args?: string[];
+    setOrigin?: 'ssh' | 'http';
+    exitCallBack?: () => void;
+    forcePushNoQuestion?: boolean;
+    overrideCommitMessage?: string;
+    commitMessageRequired?: boolean;
+    /**
+     * only needed when push github
+     * and I forgot to add my username before issue
+     * taon pfix proper input my-repo#344
+     * that should be
+     * taon pfix proper input my-username/my-repo#344
+     */
+    currentOrigin?: string;
+    skipChildren?: boolean;
+    noExit?: boolean;
+}
+declare class CommandConfig {
+    static from(config: CommandConfig): CommandConfig;
+    private constructor();
+    name: string;
+    cmd: string;
+    headerMessageWhenActive?: string;
+    /**
+     * If true, the output will be stored in a buffer and displayed when requested.
+     * Default: true
+     */
+    useDataBuffer?: boolean;
+    /**
+     * Process that should be started
+     * before this process starts.
+     */
+    shouldBeActiveOrAlreadyBuild?: CommandConfig[];
+    goToNextCommandWhenOutput?: string | {
+        stdoutContains?: string | string[];
+        stderrContains?: string | string[];
+    };
+}
+interface ProcessManagerConfig<PROJECT> {
+    title: string;
+    header?: string;
+    commands: CommandConfig[];
+    /**
+     * Default: false
+     * If false - after first selection of processes, it will be not possible
+     * to add new processes to build and build will be done after
+     * all processes are done.
+     */
+    watch?: boolean;
+}
+declare enum CommandProcessState {
+    NOT_STARTED = "not-started",
+    WAITING_TO_START = "waiting-to-start",
+    RUNNING = "running",
+    FINISHED_AND_RUNNING = "finished-and-running",// only for watch mode
+    FINISHED = "finished"
+}
+interface CommandProcessRunOptions {
+    progress?: (n: number, total: number) => void;
+    resolveNextProcess?: (currentProcess: CommandProcess) => Promise<CommandProcess>;
+    resolveWhenFinish?: boolean;
+}
+declare class CommandProcess {
+    private project;
+    private config;
+    private manager;
+    private state;
+    readonly child_process?: ChildProcess$1;
+    protected get cmd(): string;
+    get name(): string;
+    get headerMessageWhenActive(): string | undefined;
+    get pid(): number | undefined;
+    get isFinished(): boolean;
+    get isRunning(): boolean;
+    get isWaitingToStart(): boolean;
+    markForStart(): void;
+    dependenciesProcesses: CommandProcess[];
+    constructor(project: BaseProject, config: CommandConfig, manager: BaseProcessManger);
+    start(options?: CommandProcessRunOptions): Promise<void>;
+    stop(): Promise<void>;
+}
+interface DockerComposeFile {
+    version: string;
+    services: Record<string, DockerService>;
+    networks?: Record<string, DockerNetwork>;
+    volumes?: Record<string, DockerVolume>;
+}
+interface DockerService {
+    build?: string | DockerBuild;
+    image?: string;
+    container_name?: string;
+    ports?: string[];
+    environment?: Record<string, string> | string[];
+    volumes?: string[];
+    depends_on?: string[];
+    command?: string | string[];
+    networks?: string[] | Record<string, unknown>;
+    restart?: string;
+    entrypoint?: string | string[];
+    working_dir?: string;
+    labels?: Record<string, string>;
+    env_file?: string | string[];
+    args?: Record<string, string> | string[];
+}
+interface DockerBuild {
+    context: string;
+    dockerfile?: string;
+    args?: Record<string, string>;
+    target?: string;
+}
+interface DockerNetwork {
+    driver?: string;
+    external?: boolean;
+    name?: string;
+}
+interface DockerVolume {
+    driver?: string;
+    external?: boolean;
+    name?: string;
+}
+
+declare class BaseDocker<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    /**
+     * Updates ports in .env file based on available ports range.
+     */
+    updateDockerComposePorts(): Promise<void>;
+    getDockerComposeActionChildProcess(action: UtilsDocker.DockerComposeActionType, options?: UtilsDocker.DockerComposeActionOptions): ChildProcess$1;
+    removeAllImagesBy_Env_COMPOSE_PROJECT_NAME(): Promise<void>;
+}
+
+declare class BaseFileFoldersOperations<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    /**
+     * Relative to project root
+     * @returns list of files and folders to copy when copying project
+     */
+    protected fielsAndFoldersToCopy(): string[];
+    moveProjectTo(destination: string): Promise<void>;
+    deleteProject(options?: {
+        skipChildren?: boolean;
+    }): void;
+    copyProjectTo(destination: string, options?: {
+        skipChildren?: boolean;
+    }): Promise<void>;
+}
+
+declare class BaseGit<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    unstageAllFiles(): void;
+    revertFileChanges(fileReletivePath: string): void;
+    clone(url: string, destinationFolderName?: string, branchName?: string): Promise<string>;
+    restoreLastVersion(relativeFilePath: string): void;
+    stageAllFiles(): void;
+    stageFile(relativeFilePath: string): void;
+    stash(options?: {
+        onlyStaged?: boolean;
+    }): void;
+    rebase(toBranch: string): void;
+    stashApply(): void;
+    fetch(all?: boolean): void;
+    resetFiles(...relativePathes: string[]): void;
+    get isInsideGitRepo(): boolean;
+    get isWithoutGitRepository(): boolean;
+    get isGitRoot(): boolean;
+    get originURL(): string;
+    commit(commitMessage?: string): void;
+    /**
+     * alias to stage all and commit
+     */
+    addAndCommit(commitMessage: string): void;
+    /**
+     * general default development branch for all kinds of projects
+     */
+    getDefaultDevelopmentBranch(): string;
+    isUsingActionCommit(): boolean;
+    jiraIssuesAreOutsideBrackets(): boolean;
+    getUserInfo(global?: boolean): Promise<{
+        name?: string;
+        email?: string;
+    }>;
+    setUserInfo({ name, email }: {
+        name?: string;
+        email?: string;
+    }, global?: boolean): Promise<void>;
+    stageAllAndCommit(commitMessage: string): void;
+    pushCurrentBranch(options?: {
+        force?: boolean;
+        origin?: string;
+        askToRetry?: boolean;
+        forcePushNoQuestion?: boolean;
+    }): Promise<boolean>;
+    get allOrigins(): {
+        origin: string;
+        url: string;
+    }[];
+    get uncommitedFiles(): string[];
+    get thereAreSomeUncommitedChange(): boolean;
+    thereAreSomeUncommitedChangeExcept(filesList?: string[]): boolean;
+    /**
+     * Resolve last changes
+     * - uncommited changes
+     * - action commits to melt
+     */
+    resolveLastChanges(options?: {
+        tryAutomaticActionFirst?: boolean;
+        projectNameAsOutputPrefix?: string;
+        questionPrefixMessage?: string;
+    }): Promise<void>;
+    get hasActionCommitsToMelt(): boolean;
+    /**
+     * @returns number of melted commits
+     */
+    meltActionCommits(): number;
+    /**
+     *
+     * @param newVersion
+     * @param pushWithoutAsking
+     */
+    tagAndPushToGitRepo(newVersion: string, autoReleaseUsingConfig: boolean, isCiProcess: boolean): Promise<void>;
+    pullCurrentBranch(options?: {
+        askToRetry?: boolean;
+        /**
+         * default true, when false it will throw error instead process.exit(0)
+         */
+        exitOnError?: boolean;
+        defaultHardResetCommits?: number;
+    }): Promise<void>;
+    get currentBranchName(): string;
+    get listOfCurrentGitChanges(): {
+        modified: string[];
+        deleted: string[];
+        created: string[];
+    };
+    getBranchesNamesBy(pattern: string | RegExp): string[];
+    resetSoftHEAD(HEAD?: number): void;
+    resetHard(options?: {
+        HEAD?: number;
+    }): void;
+    countCommits(): number;
+    hasAnyCommits(): any;
+    get isInMergeProcess(): any;
+    lastCommitDate(): any;
+    lastCommitHash(): any;
+    lastCommitMessage(): string;
+    penultimateCommitMessage(): Promise<string>;
+    getCommitMessageByIndex(index: number): Promise<string>;
+    getCommitMessageByHash(hash: string): Promise<string>;
+    getCommitHashByIndex(index: number): Promise<string>;
+    penultimateCommitHash(): string;
+    checkTagExists(tag: string): boolean;
+    checkout(branchName: string, options?: {
+        createBranchIfNotExists?: boolean;
+        fetchBeforeCheckout?: boolean;
+        switchBranchWhenExists?: boolean;
+    }): void;
+    allowedGitEmailDomains(): string[];
+    cleanRepoFromAnyFilesExceptDotGitFolder(): void;
+    checkoutFromTo(checkoutFromBranch: string, branch: string, origin?: string): void;
+    /**
+     *
+     * @param majorVersion example: v1, v2 etc.
+     * @returns tag name
+     */
+    lastTagNameForMajorVersion(majorVersion: any): string;
+    lastTagHash(): string;
+    get remoteOriginUrl(): string;
+    /**
+     * get provider of remote origin
+     */
+    get remoteProvider(): string;
+    get lastTagVersionName(): string;
+    get stagedFiles(): string[];
+    get stagedFilesRelativePaths(): string[];
+    /**
+     * TODO does this make any sense
+     */
+    renameOrigin(newNameOrUlr: string): void;
+    /**
+     * By default no translation of commit
+     */
+    transalteGitCommitFromArgs(): {
+        from: string;
+        to: string;
+    };
+    /**
+     * By defult true.. when commit branches will not function.
+     * (false is better for simple projects)
+     */
+    useGitBranchesWhenCommitingAndPushing(): boolean;
+    /**
+     * usefull when pushing in project with childrens as git repos
+     */
+    automaticallyAddAllChangesWhenPushingToGit(): boolean;
+    /**
+     * usefull when pushing in project with childrens as git repos
+     */
+    useGitBranchesAsMetadataForCommits(): boolean;
+    /**
+     * @returns true if clone was successful
+     */
+    cloneTo(cwd: string, newProjectName?: string): Promise<boolean>;
+    /**
+     * This is only for push/pull process
+     *
+     * There are 2 types of projects:
+     * - with linked-projects.json
+     * - with children from external folder
+     *
+     * projects that are children of this project (with its own git repo)
+     */
+    get gitChildren(): PROJECT[];
+    protected setRemoteOriginType(setOrigin: 'ssh' | 'http'): Promise<void>;
+    pullProcess(options?: {
+        skipCloneGitChildren?: boolean;
+        setOrigin?: 'ssh' | 'http';
+    }): Promise<void>;
+    validateEmailDomain(allowedEmailsEnds: string[]): Promise<void>;
+    protected _afterPullProcessAction(setOrigin: 'ssh' | 'http', skipCloneGitChildren?: boolean): Promise<void>;
+    backupBranch(branchName?: string): Promise<string>;
+    pushProcess(options?: PushProcessOptions): Promise<void>;
+    _beforeAnyActionOnGitRoot(): void;
+    protected _beforePushProcessAction(setOrigin: 'ssh' | 'http'): Promise<void>;
+    protected _beforePullProcessAction(setOrigin: 'ssh' | 'http', skipCloneGitChildren?: boolean): Promise<void>;
+    protected _getCommitMessage(typeOfCommit: TypeOfCommit, args: string[], commitMessageRequired?: boolean, 
+    /**
+     * only needed when push github
+     * and I forgot to add my username before issue
+     * taon pfix proper input my-repo#344
+     * that should be
+     * taon pfix proper input my-username/my-repo#344
+     */
+    currentOrigin?: string): Promise<CommitData>;
+    /**
+     * This will prevent accidental branch change for taon projects
+     * @returns branch name
+     */
+    duringPushWarnIfProjectNotOnSpecyficDevBranch(): string;
+    getChangedFilesInCommitByHash(hash: string): Promise<string[]>;
+    /**
+     * @param index 0 - means last commit
+     */
+    getChangedFilesInCommitByIndex(index: number): Promise<string[]>;
+    changesSummary(options?: {
+        prefix?: string;
+    }): Promise<string>;
+    /**
+     * If true command navi reset will reset project
+     * and its children.
+     *
+     * If false command navi reset will reset only project.
+     */
+    resetIsRestingAlsoChildren(): boolean;
+    useBranchNameDirectlyAsCommitMessage(): boolean;
+}
+
+/**
+ * Git Ignore
+ * Vscode Files Hide
+ * Npm Ignore
+ */
+declare class BaseIgnoreHideHelpers<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    /**
+     * (@default: false)
+     *
+     * If true, the files/folders/patterns that aren't really code and can
+     * be recreated from template project like (tsconfig.json, .babelrc, .prettierc etc.)
+     * will are stored in the repo
+     */
+    protected storeInRepoConfigFiles(): boolean;
+    init(): Promise<void>;
+    /**
+     * @param data list of patterns
+     * @returns list of patterns for recrusive ignore
+     */
+    private recursivePatternTransformFn;
+    /**
+     * Have to start with /
+     *
+     * Usefull if you are generating some files and folder in src/*.* folder
+     * (Taon CLI does this for automatic host generation)
+     * @returns patterns that are ignored in repo but visible to user
+     */
+    protected getPatternsIgnoredInRepoButVisibleToUser(): string[];
+    protected alwaysIgnoredHiddenPatterns(): string[];
+    alwaysUseRecursivePattern(): string[];
+    protected alwaysIgnoredAndHiddenFilesAndFolders(): string[];
+    protected hiddenButNeverIgnoredInRepo(): string[];
+    protected hiddenButNotNecessaryIgnoredInRepoFilesAndFolders(): string[];
+    protected hiddenButNotNecessaryIgnoredInRepoPatterns(): string[];
+    protected npmIgnoreFilesFoldersPatterns(): string[];
+    writeGitIgnore(): void;
+    /**
+     * Use can apply this to .vscode/settings.json [files.exclude] property
+     */
+    getVscodeFilesFoldersAndPatternsToHide(): {
+        [fileFolderOrPattern: string]: true;
+    };
+    writeNpmIgnore(): void;
+}
+
+declare class BaseJavaJdk<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    selectJdkVersion(): Promise<string | undefined>;
+    updateJavaHomePath(selectedPath: string): void;
+    selectTomcatVersion(): Promise<string>;
+    updateTomcatHomePath(selectedPath: string): void;
+}
+
+/**
+ * Base library build for standard angular/typescript projects
+ */
+declare abstract class BaseLibraryBuild<PROJECT extends BaseProject<BaseProject, any>> extends BaseFeatureForProject<PROJECT> {
+    private cache;
+    protected readonly tempOrgTsConfigFile: string;
+    protected sortByDeps(libraries: PROJECT[]): PROJECT[];
+    /**
+     * Use cases:
+     * 1. build all libraries in normal mode
+     * 2. build all libraries in watch mode
+     * 3. build selected libraries in normal mode
+     *   (with first time all libraries will be build)
+     * 4. build selected libraries in watch mode
+     *    (use normal build for not selected libraries)
+     * 5. build selected libraries in watch mode
+     *    (skip normal build for not selected libraries)
+     */
+    selectAndSaveLibraries({ selectedLibs, watch, watchBuildSupported, skipAllLibsQuestion, useLastUserConfiguration, }: {
+        selectedLibs: PROJECT[];
+        watch: boolean;
+        watchBuildSupported?: boolean;
+        skipAllLibsQuestion?: boolean;
+        useLastUserConfiguration?: boolean;
+    }): Promise<{
+        selectedLibs: PROJECT[];
+        skipRebuildingAllForWatch: boolean;
+    }>;
+    /**
+     * angular libraries from angular.json
+     */
+    get libraries(): PROJECT[];
+    protected getLibraries(): any;
+    /**
+     * Angular library build
+     */
+    buildLibraries({ watch, strategy, releaseBuild, copylink_to_node_modules, outputLineReplace, libraries, useLastUserConfiguration, }?: LibrariesBuildOptions<PROJECT> & {
+        watch?: boolean;
+    }): Promise<void>;
+    protected libWatchBuildProcess({ lib, locationsForNodeModules, strategy, outputLineReplace, }: {
+        lib: PROJECT;
+        locationsForNodeModules: string[];
+        strategy: 'link' | 'copy';
+        outputLineReplace?: (outputLine: string) => string;
+    }): Promise<any>;
+    protected libNormalBuildProcess({ lib, locationsForNodeModules, strategy, outputLineReplace, }: {
+        lib: PROJECT;
+        locationsForNodeModules: string[];
+        strategy: 'link' | 'copy';
+        outputLineReplace?: (outputLine: string) => string;
+    }): Promise<any>;
+    getLibraryBuildCommand(options?: LibraryBuildCommandOptions): string | undefined;
+    get getLibraryBuildSuccessComamnds(): string[];
+    selectCopytoProjects(): Promise<string[]>;
+    private changeTsConfigForLibrariesTypes;
+    protected replaceTsConfigsPathes(): Promise<any>;
+    private restoreOriginalTsConfig;
+}
+
+declare class BaseLinkedProjects<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    private cache;
+    get embeddedProject(): PROJECT;
+    get projectsDbLocation(): any;
+    saveLocationToDB(): Promise<any>;
+    saveAllLinkedProjectsToDB(): Promise<void>;
+    addLinkedProject(linkedProj: LinkedProject | string, options?: {
+        skipFormat?: boolean;
+    }): any;
+    addLinkedProjects(linkedProjs: LinkedProject[], options?: {
+        skipFormat?: boolean;
+    }): any;
+    setLinkedProjectsConfig(linkedPorjectsConfig: Partial<LinkedPorjectsConfig>, options?: {
+        skipFormat?: boolean;
+    }): any;
+    formatConfigFile(): any;
+    private get linkedProjectsConfigPath();
+    private get linkedProjectsConfigTempPath();
+    protected recreateLinkedProjectsConfig(): any;
+    getLinkedProjectsConfig(): LinkedPorjectsConfig;
+    get linkedProjects(): LinkedProject[];
+    get detectedLinkedProjects(): LinkedProject[];
+    get linkedProjectsPrefix(): string;
+    resetLinkedProjectsOnlyToCoreBranches(): boolean;
+    cloneNonexistedLinkedProjects(setOrigin: 'ssh' | 'http'): Promise<any>;
+}
+
+declare class BaseLinter<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    init(): Promise<void>;
+    getLintFiles(): string[];
+    getConfigEditorconfig(): string;
+    getConfigPrettierrc(): object;
+    getConfigPrettierignore(): string;
+    isEnableForProject(): boolean;
+    writeLintFiles(): void;
+}
+
+interface BaseJsonFileReaderOptions<DATA> {
+    /**
+     * cwd for <my-json>.json
+     * <cwd>/<my-json>
+     * (you can also provide full path - basename will be cut)
+     */
+    cwd?: string;
+    /**
+     * file name
+     * example: package.json, taon.json etc.
+     */
+    fileName?: string;
+    /**
+     * json content to read from memory
+     */
+    jsonContent?: Partial<DATA>;
+    /**
+     * callback for external reload
+     */
+    reloadInMemoryCallback?: (data: DATA) => void;
+    /**
+     * use json with comments reader to read json file
+     */
+    readJsonAsJsonWithComments?: boolean;
+    /**
+     * default value for data
+     * if file not exist
+     * (ONLY FOR cwd + fileName mode)
+     */
+    defaultValue?: Partial<DATA>;
+}
+/**
+ * Base class for reading json files
+ * There are 2 modes of reading json files:
+ * - cwd + fileName (read and write to disk in cwd)
+ * - jsonContent (read and write to memory and use
+ *   reloadInMemoryCallback for external reload)
+ */
+declare class BaseJsonFileReader<DATA> {
+    /**
+     * null when package.json not exist
+     */
+    protected data: DATA | null;
+    /**
+     * use json with comments reader to read package.json
+     */
+    protected readonly readJsonAsJsonWithComments: boolean;
+    readonly cwd: string;
+    protected readonly fileName: string;
+    /**
+     * @deprecated
+     * use only when cwd and fileName are not provided
+     */
+    protected readonly jsonContent?: Partial<DATA>;
+    protected readonly defaultValue?: Partial<DATA>;
+    protected readonly reloadInMemoryCallback?: (data: DATA) => void;
+    constructor(options: BaseJsonFileReaderOptions<DATA>);
+    /**
+     * cwd + fileName
+     */
+    get path(): string;
+    /**
+     * if something else change package.json in this project
+     * and you know that you need to reload it..
+     */
+    reloadPackageJsonInMemory(): void;
+    saveToDisk(purpose?: string): any;
+    linkTo(destination: string): void;
+    getAllData(): DATA;
+    setAllData(data: DATA): void;
+}
+
+/**
+ * Minimal interface describing a bower.json file according to:
+ * https://github.com/bower/spec/blob/master/json.md
+ */
+interface BowerJson {
+    name: string;
+    version?: string;
+    description?: string;
+    main?: string | string[];
+    keywords?: string[];
+    authors?: Array<string | {
+        name: string;
+        email?: string;
+        homepage?: string;
+    }>;
+    license?: string;
+    homepage?: string;
+    private?: boolean;
+    repository?: {
+        type: string;
+        url: string;
+    };
+    ignore?: string[];
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    resolutions?: Record<string, string>;
+    moduleType?: string | string[];
+}
+declare class BaseBowerJson extends BaseJsonFileReader<BowerJson> {
+    cwd: string;
+    constructor(cwd: string);
+    get dependencies(): Record<string, string>;
+}
+
+type DedupePackage = string | {
+    package: string;
+    excludeFrom?: string[];
+    includeOnlyIn?: string[];
+};
+declare class BaseNodeModules<NPM_HELPERS extends BaseNpmHelpers = BaseNpmHelpers> {
+    /**
+     * my-path/node_modules
+     */
+    protected cwd: string;
+    protected npmHelpers: NPM_HELPERS;
+    protected _npmHelpersType: NPM_HELPERS;
+    constructor(
+    /**
+     * my-path/node_modules
+     */
+    cwd: string, npmHelpers: NPM_HELPERS);
+    /**
+     * cwd + node_modules
+     */
+    get path(): string;
+    /**
+     * Path to package inside node_modules folder
+     * @example <project-path>/node_modules/<package-name>
+     */
+    pathFor(packageName: string | string[]): string;
+    /**
+     * real path of node_modules
+     * if node_modules is a link
+     * it will return real path.
+     * if node_modules is folder = path
+     */
+    get realPath(): string;
+    protected preventWrongLinkDestination(dest: string): string;
+    linkToProject(project: Partial<BaseProject>): any;
+    copyToProject(project: BaseProject): void;
+    linkToLocation(location: string): void;
+    makeSureInstalled(options?: Omit<CoreModels.NpmInstallOptions, 'pkg'>): Promise<void>;
+    remove(options?: {
+        skipQuestion?: boolean;
+    }): Promise<void>;
+    removePackage(packageInside: string): void;
+    reinstall(options?: Omit<CoreModels.NpmInstallOptions, 'pkg'>): Promise<any>;
+    get isLink(): boolean;
+    unlinkNodeModulesWhenLinked(): any;
+    get empty(): any;
+    /**
+     * @returns true if node_modules folder is empty
+     * DEEP CHECK - also if node_modules is a link
+     * and is not existent
+     */
+    isEmpty(): any;
+    /**
+     *  Prepare command for npm install
+     * (or yarn install)
+     */
+    prepareCommand(options: CoreModels.NpmInstallOptions, cwd?: string): Promise<string>;
+    /**
+     *
+     * @param rootDir
+     * @param packageName
+     * @returns absolute paths to package dirs
+     */
+    private findPackageDirs;
+    dedupePackages(packagesConfig?: DedupePackage[], countOnly?: boolean, fake?: boolean): void;
+}
+
+type PackageJson = PackageJson$1 & {
+    lastBuildTagHash?: string;
+    publisher?: string;
+    displayName?: string;
+};
+type PackageJsonDependencyObj = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'resolutions';
+declare const PackageJsonDependencyObjArr: PackageJsonDependencyObj[];
+declare class BasePackageJson extends BaseJsonFileReader<PackageJson> {
+    constructor(options: Omit<BaseJsonFileReaderOptions<PackageJson>, 'fileName'>);
+    /**
+     * 'dependencies'
+     * 'devDependencies'
+     * 'peerDependencies'
+     * 'resolutions';
+     * and whatever is in package.json to npm install
+     */
+    get dependenciesTypesArray(): PackageJsonDependencyObj[];
+    get name(): string;
+    setName(name: string): Promise<void>;
+    /**
+     * devDependencies dependencies
+     */
+    get devDependencies(): PackageJson['devDependencies'];
+    /**
+     * resolutions dependencies
+     */
+    get resolutions(): PackageJson['resolutions'];
+    /**
+     * npm dependencies from package.json
+     */
+    get dependencies(): PackageJson['dependencies'];
+    get optionalDependencies(): PackageJson['optionalDependencies'];
+    get description(): string;
+    get displayName(): string;
+    get publisher(): string;
+    get contributes(): PackageJson['contributes'];
+    get repository(): PackageJson['repository'];
+    setRepository(repository: PackageJson['repository']): void;
+    /**
+     * set the WHOLE dependencies object
+     * THIS WILL NOT MERGE -> IT WILL REPLACE WHOLE DEPENDENCIES OBJECT
+     */
+    setDependencies(dependencies: PackageJson['dependencies']): void;
+    /**
+     * set the WHOLE dependencies object
+     * THIS WILL NOT MERGE -> IT WILL REPLACE WHOLE DEPENDENCIES OBJECT
+     */
+    setDevDependencies(devDependencies: PackageJson['devDependencies']): void;
+    /**
+     * peerDependencies dependencies
+     */
+    get peerDependencies(): PackageJson['peerDependencies'];
+    /**
+     * set the WHOLE peerDependencies object
+     * THIS WILL NOT MERGE -> IT WILL REPLACE WHOLE PEER DEPENDENCIES OBJECT
+     */
+    setPeerDependencies(peerDependencies: PackageJson['peerDependencies']): void;
+    setOptionalDependencies(optionalDependencies: PackageJson['optionalDependencies']): void;
+    removeDevDependencies(): void;
+    /**
+     * @returns object witl all deps from current project package json
+     */
+    get allDependencies(): {
+        [packageName: string]: string;
+    };
+    /**
+     * @returns object witl all deps from package json
+     */
+    allDepsFromPackageJson(packageJson: PackageJson): any;
+    /**
+     * version from package.json -> property version
+     */
+    get version(): string;
+    setVersion(version: string): void;
+    /**
+     * bin with cli config from package.json
+     */
+    get bin(): Partial<Record<string, string>>;
+    set bin(value: Partial<Record<string, string>>);
+    get engines(): PackageJson['engines'];
+    setEngines(engines: PackageJson['engines']): Promise<void>;
+    get homepage(): PackageJson['homepage'];
+    setHomepage(homepage: PackageJson['homepage']): Promise<void>;
+    get versionWithPatchPlusOne(): string;
+    get versionWithMinorPlusOneAndPatchZero(): string;
+    get versionWithMajorPlusOneAndMinorZeroAndPatchZero(): string;
+    get versionPathAsNumber(): number;
+    /**
+     * Major Version from package.json
+     */
+    get majorVersion(): number;
+    /**
+     * Minor Version from package.json
+     */
+    get minorVersion(): number;
+    /**
+     * @deprecated TODO not usefull ?
+     */
+    getVersionAsNumber(releaseType: CoreModels.ReleaseVersionType): number;
+    bumpPatchVersion(): Promise<any>;
+    getBumpedVersionFor(releaseType: CoreModels.ReleaseVersionType): string;
+    updateDepsFrom(locations: string[]): any;
+    /**
+     * this will NOT SET dependency if
+     * dependency name is not in package.json
+     */
+    updateDependency({ packageName, version, createNewEntryIfNotExist, }: {
+        packageName: string;
+        version: string | null;
+        createNewEntryIfNotExist?: boolean;
+    }): void;
+    get isPrivate(): boolean;
+    setIsPrivate(value: boolean): any;
+    get sideEffects(): boolean;
+    setMainProperty(main: string, purpose?: string): Promise<void>;
+    setBuildHash(hash: string): void;
+    getBuildHash(): string;
+    copyTo(location: string | string[]): void;
+}
+
+declare class BaseNpmHelpers<PROJECT extends BaseProject = BaseProject> extends BaseFeatureForProject<PROJECT> {
+    readonly packageJson: BasePackageJson;
+    readonly _packageJsonType: typeof BasePackageJson;
+    private readonly _packageJsonTypeOriginal;
+    readonly nodeModules: BaseNodeModules;
+    readonly _nodeModulesType: typeof BaseNodeModules;
+    private readonly __nodeModulesTypeOriginal;
+    readonly bowerJson: BaseBowerJson;
+    constructor(project: PROJECT);
+    preferYarnOverNpm(): boolean;
+    resetPackageLockJson(): Promise<any>;
+    startNpmTask(taskName: string, additionalArguments?: string | object): any;
+    /**
+     *
+     * @param registry without specified registr is checking npm registry
+     * @returns
+     */
+    isLoggedInToRegistry(registry?: string): Promise<boolean>;
+    /**
+     * Prompt the user to log in to a specific npm registry.
+     * @param {string} [registry] - Optional npm registry URL.
+     * @returns {Promise<void>} - A promise that resolves when the login process completes.
+     */
+    loginToRegistry(registry?: string): Promise<void>;
+    makeSureLoggedInToNpmRegistry(registry?: string): Promise<void>;
+    shouldReleaseMessage(options: {
+        releaseVersionBumpType: CoreModels.ReleaseVersionType;
+        versionToUse?: string;
+        children?: BaseProject[];
+        whatToRelease: {
+            itself: boolean;
+            children: boolean;
+        };
+        skipQuestionToUser?: boolean;
+        messagePrefix?: string;
+    }): Promise<boolean>;
+    /**
+     * @param registry when not specified, it will use the default npm registry
+     */
+    publishToNpmRegistry(options?: {
+        registry?: string;
+    }): Promise<void>;
+    getPackageVersionFromNpmRegistry(packageName: string, options?: {
+        registry?: string;
+    }): Promise<string | undefined>;
+}
+
+declare class BaseDb<DB extends object> {
+    private ins;
+    private dbName;
+    private defaultDb;
+    constructor(ins: BaseProjectResolver, dbName: string, defaultDb: DB);
+    get isUsingDB(): boolean;
+    get projectsDbLocation(): any;
+}
+
+declare const defaultDb$1: {
+    config: {
+        [key: string]: string | number | boolean | null;
+    };
+};
+declare class ConfigDatabase extends BaseDb<typeof defaultDb$1> {
+    constructor(ins: BaseProjectResolver);
+    private get selectedCodeEditorKey();
+    selectCodeEditor(): Promise<'code' | 'idea' | 'idea64' | string>;
+    getCodeEditor(): Promise<'code' | 'idea' | 'idea64' | string>;
+}
+
+declare const defaultDb: {
+    projects: {
+        location: string;
+    }[];
+};
+declare class ProjectDatabase extends BaseDb<typeof defaultDb> {
+    constructor(ins: BaseProjectResolver);
+    getAllProjectsFromDB(): Promise<any>;
+}
+
+type PortStatus = 'unassigned' | 'assigned' | 'assigned-not-registered' | 'assigned-taken-by-os';
+declare const PortStatusArr: PortStatus[];
+declare class Port extends TaonBaseEntity {
+    static from(opt: Omit<Port, 'version' | '_' | 'clone' | 'titleOnList' | 'relation' | 'relations'>): Port & Omit<Port, "_" | "version" | "clone" | "titleOnList" | "relation" | "relations">;
+    static getTitleForFreePort(port: Number): string;
+    get titleOnList(): string;
+    port: number;
+    serviceId: string;
+    /**
+     * Port status
+     */
+    status: PortStatus;
+    /**
+     * When port was assigned as registered service
+     */
+    whenAssignedTimestamp?: Number;
+}
+
+declare class BaseCliWorkerConfig {
+    static from(opt: Partial<BaseCliWorkerConfig>): BaseCliWorkerConfig;
+    /**
+     * path to file where config is stored
+     */
+    pathToFile: string;
+    /**
+     * port taken by service
+     */
+    port: number;
+    /**
+     * unique in whole system id of service
+     */
+    serviceID: string;
+    /**
+     * pid of service process
+     */
+    pid: number;
+    /**
+     * timestamp when service was started
+     * (in other cases = null)
+     */
+    startTimestamp: number;
+    /**
+     * version
+     */
+    version: string;
+    hasBiggerOrEqualWorkerVersionThan(other: BaseCliWorkerConfig): boolean;
+    isEquals(other: BaseCliWorkerConfig): boolean;
+    get isEmpty(): boolean;
+}
+
+declare abstract class TaonBaseCliWorkerController<UPLOAD_FILE_QUERY_PARAMS = {}> extends TaonBaseController<UPLOAD_FILE_QUERY_PARAMS> {
+    /**
+     * service id
+     */
+    private cliWorkerServiceId;
+    private cliWorkerServiceVersion;
+    baseCLiWorkerCommand_initializeMetadata(serviceId: string, serviceVersion: string): Taon.Response<void>;
+    baseCLiWorkerCommand_kill(dontRemoveConfigFile?: boolean): Taon.Response<void>;
+    info(): Taon.ResponseHtml;
+    baseCLiWorkerCommand_isHealthy(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
+    baseCLiWorkerCommand_hasUpToDateVersion(checkingProcessConfig: BaseCliWorkerConfig): Taon.Response<boolean>;
+}
+
+type BaseWorkerTerminalActionReturnType = {
+    [uniqeActionName: string]: {
+        name: string;
+        action: () => unknown | Promise<unknown>;
+    };
+};
+declare class BaseCliWorkerTerminalUI<WORKER extends BaseCliWorker<TaonBaseCliWorkerController<any>, any>> {
+    protected worker: WORKER;
+    constructor(worker: WORKER);
+    protected headerText(): Promise<string>;
+    protected textHeaderStyle(): CoreModels.CfontStyle;
+    protected headerTextAlign(): CoreModels.CfontAlign;
+    /**
+     * override whole terminal header
+     */
+    protected header(): Promise<void>;
+    infoMessageBelowHeader(options?: BaseCliWorkerGuiUrlOptions): Promise<void>;
+    protected get backAction(): {
+        back: {
+            name: string;
+        };
+    };
+    protected get chooseAction(): {
+        emptyAction: {
+            name: string;
+            action: () => Promise<void>;
+        };
+    };
+    protected getWorkerTerminalActions(options?: {
+        exitIsOnlyReturn?: boolean;
+        chooseAction?: boolean;
+    }): BaseWorkerTerminalActionReturnType;
+    private headerDisplayed;
+    infoScreen(options?: {
+        exitIsOnlyReturn?: boolean;
+    }): Promise<void>;
+    displaySpecialWorkerReadyMessage(): void;
+}
+
+interface BaseCliWorkerOptionCallable {
+    /**
+     * Name of the function from which the option was called
+     */
+    calledFrom: string;
+}
+declare class BaseCliWorkerConfigGetContextOptions {
+    /**
+     * default localhost
+     */
+    ipAddressOfTaonInstance?: string;
+    /**
+     * if null nothing is used as port (ip address will be clean)
+     */
+    port?: number | null;
+}
+/**
+ * Default mode: DETACHED_CHILD_PROCESS
+ */
+declare enum BaseCLiWorkerStartMode {
+    CHILD_PROCESS = "child",
+    IN_CURRENT_PROCESS = "process",
+    DETACHED_WINDOW = "window"
+}
+declare class BaseCLiWorkerStartParams {
+    /**
+     * Start mode
+     * Default mode DETACHED_CHILD_PROCESS
+     */
+    mode: BaseCLiWorkerStartMode;
+    restart?: boolean;
+    kill?: boolean;
+}
+declare class BaseCliMethodOptions extends TaonBaseClass<BaseCliMethodOptions> implements BaseCliWorkerOptionCallable {
+    static from(opt?: Partial<BaseCliMethodOptions>): BaseCliMethodOptions;
+    connectionOptions?: BaseCliWorkerConfigGetContextOptions;
+    cliParams?: BaseCLiWorkerStartParams;
+    /**
+     * Name of the function from which the option was called
+     */
+    calledFrom: string;
+}
+
+interface BaseCliWorkerGuiUrlOptions {
+    domain?: string;
+    port?: number | null;
+    useHttps?: boolean;
+}
+declare abstract class BaseCliWorker<REMOTE_CTRL extends TaonBaseCliWorkerController<any>, TERMINAL_UI extends BaseCliWorkerTerminalUI<any> = any> {
+    /**
+     * unique id for service
+     */
+    readonly serviceID: string;
+    /**
+     * external command that will start service
+     */
+    readonly startCommand: string;
+    /**
+     * unique id for service
+     */
+    readonly serviceVersion: string;
+    /**
+     * Indicates if worker is part of cloud
+     * and should use cloud ip address
+     */
+    static readonly isCloudEnable: Pick<BehaviorSubject<boolean>, 'next' | 'getValue'>;
+    /**
+     * Cloud ip address of the worker (if part of cloud)
+     */
+    static readonly cloudIp: Pick<BehaviorSubject<string | null>, 'next' | 'getValue'>;
+    private static workers;
+    readonly SPECIAL_WORKER_READY_MESSAGE = "$$$ WORKER_READY $$$";
+    /**
+     * dependency workers that should be started before this worker
+     */
+    readonly dependencyWorkers: Map<string, BaseCliWorker<any, any>>;
+    readonly terminalUI: TERMINAL_UI;
+    readonly workerContextTemplate: ReturnType<typeof Taon.createContextTemplate>;
+    /**
+     * Name of the worker context
+     */
+    get contextName(): string;
+    /**
+     * Port where worker is running
+     * (getter only accessible from host machine)
+     */
+    get port(): number | undefined;
+    getWorkerInfoGuiUrl(options?: BaseCliWorkerGuiUrlOptions): string;
+    readonly controllerClass: new () => REMOTE_CTRL;
+    constructor(
+    /**
+     * unique id for service
+     */
+    serviceID: string, 
+    /**
+     * external command that will start service
+     */
+    startCommand: string, 
+    /**
+     * unique id for service
+     */
+    serviceVersion: string);
+    static getAllWorkersStartedInSystemFromCurrentCli(): BaseCliWorker<any, any>[];
+    get processLocalInfoObj(): BaseCliWorkerConfig;
+    getRemoteControllerFor<ctrl = REMOTE_CTRL>(options?: {
+        methodOptions: Partial<BaseCliMethodOptions>;
+        /**
+         * Optionally get other controller from remote context
+         */
+        controllerClass?: new () => ctrl;
+    }): Promise<ctrl>;
+    /**
+     * stop if started
+     */
+    kill(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+        dontRemoveConfigFile?: boolean;
+    }): Promise<void>;
+    /**
+     * kill detached process and start again
+     * @param options.detached - default true
+     */
+    restart(options?: {
+        methodOptions?: BaseCliMethodOptions;
+    }): Promise<void>;
+    /**
+     * only for cli start
+     * @param cliParams on from cli
+     */
+    cliStartProcedure(options: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<{
+        controller: REMOTE_CTRL;
+        worker: BaseCliWorker<any, any>;
+        serviceId: string;
+    }>;
+    protected getRemoteContextFor(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<EndpointContext>;
+    protected get pathToProcessLocalInfoJson(): string;
+    protected get processLocalInfoPortNotInited(): boolean;
+    protected get workerIsStarting(): boolean;
+    protected startDetachedIfNeedsToBeStarted(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    /**
+     * <strong>IMPORTANT USE ONLY IN DEVELOPMENT !!!</strong>
+     * for production use startDetachedIfNeedsToBeStarted()
+     * start normally process
+     * this will crash if process already started
+     */
+    protected startNormallyInCurrentProcess(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+        actionBeforeTerminalUI?: () => Promise<void>;
+    }): Promise<void>;
+    protected preventExternalConfigChange(): void;
+    protected preventStartIfAlreadyStarted(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    protected killWorkerWithLowerVersion(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    /**
+     * This has 2 purposes:
+     * - infinite check when when detached process finished starting
+     * - quick check if service is healthy / already started
+     */
+    protected isServiceHealthy(options: {
+        healthCheckRequestTrys?: number;
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<boolean>;
+    /**
+     * start if not started detached process
+     */
+    protected startDetached(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    private saveProcessInfo;
+    protected initializeWorkerMetadata(options?: {
+        methodOptions?: Partial<BaseCliMethodOptions>;
+    }): Promise<void>;
+    protected waitForProcessPortSavedToDisk(options: {
+        methodOptions: BaseCliMethodOptions;
+    }): Promise<void>;
+    protected getServicePort(): Promise<number>;
+}
+
+/**
+ * Get taon service database config
+ * (database is stored in user's home directory)
+ * @param serviceNameUniqueInSystem - unique name of the service in the system
+ * @param recreateMode - mode of database recreation, default is 'DROP_DB+MIGRATIONS'
+ * @returns DatabaseConfig object with location and recreateMode
+ */
+declare const getBaseCliWorkerDatabaseConfig: (serviceNameUniqueInSystem: string, recreateMode?: Models.DBRecreateMode) => any;
+
+declare namespace BaseCliWorkerUtils {
+    const getPathToProcessLocalInfoJson: (serviceID: string) => string;
+    const getAllServicesFromOS: () => BaseCliWorkerConfig[];
+}
+
+declare class TaonPortsController extends TaonBaseCliWorkerController {
+    START_PORT: number;
+    END_PORT: number;
+    readonly portsCache: Map<string, Port>;
+    protected get firstFreePort(): Port | null | undefined;
+    protected firstUnassignedPortMoreThan(port: number): any;
+    getFirstFreePort(): Taon.Response<Port>;
+    getPortByNumber(portNumber: number): Taon.Response<Port>;
+    getPortsByStatus(status: PortStatus): Taon.Response<Port[]>;
+    /**
+     * make it unassigned
+     */
+    deletePort(portNumber: number): Taon.Response<Port>;
+    /**
+     * make it unassigned
+     */
+    updatePortUniqueId(portNumber: number, serviceId: string): Taon.Response<Port>;
+    addTakeByOsPort(portNumber: number, uniqueId: string): Taon.Response<Port>;
+    /**
+     * @param uniqueServiceName unique service name
+     * @param startFrom start searching for free port from this number
+     * @returns
+     */
+    registerAndAssignPort(uniqueServiceName: string, startFrom?: number): Taon.Response<Port>;
+}
+
+declare class TcpUdpPortsTerminalUI extends BaseCliWorkerTerminalUI<PortsWorker> {
+    protected headerText(): Promise<string>;
+    protected textHeaderStyle(): CoreModels.CfontStyle;
+    protected crudMenuForTakeByOsPorts(): Promise<void>;
+    protected addPortTerminalUiProcess(): Promise<void>;
+    protected selectPortProcess(ports: Port[], title: string): Promise<Port>;
+    protected deletePortTerminalUiProcess(): Promise<void>;
+    protected editPortTerminalUiProcess(): Promise<void>;
+    getWorkerTerminalActions(options?: {
+        exitIsOnlyReturn?: boolean;
+    }): any;
+    protected displayItemsForPortsStatus(status: PortStatus): Promise<any>;
+    private getNewPortToAdd;
+}
+
+declare class PortsWorker extends BaseCliWorker<TaonPortsController, TcpUdpPortsTerminalUI> {
+    terminalUI: TcpUdpPortsTerminalUI;
+    workerContextTemplate: any;
+    controllerClass: typeof TaonPortsController;
+}
+
+declare class BaseProjectResolver<PROJECT extends Partial<BaseProject> = any> {
+    protected readonly classFn: any;
+    readonly cliToolName: string;
+    configDb: ConfigDatabase;
+    projectsDb: ProjectDatabase;
+    readonly portsWorker: PortsWorker;
+    protected readonly NPM_PROJECT_KEY = "npm";
+    protected projects: PROJECT[];
+    /**
+     * To speed up checking folder I am keeping paths for already checked folder
+     * This may break things that are creating new projects
+     */
+    protected emptyLocations: string[];
+    constructor(classFn: any, cliToolName: string);
+    get allowedTypes(): string[];
+    /**
+     * project from process.cwd()
+     */
+    get Current(): PROJECT;
+    /**
+     * override this
+     */
+    typeFrom(location: string, recrusiveCall?: boolean): string;
+    From(locationOfProject: string | string[], options?: any): PROJECT;
+    nearestTo(absoluteLocation: string | string[], options?: {
+        type?: string | string[];
+        findGitRoot?: boolean;
+        onlyOutSideNodeModules?: boolean;
+    }): PROJECT;
+    unload(projectOrLocationOfProject: PROJECT | string): void;
+    remove(project: PROJECT): void;
+    add(project: PROJECT): void;
+    allProjectFrom(absoluteLocation: string, stopOnCwd?: string): any;
+    allProjectsFromFolder(folderLocation: string): PROJECT[];
+    sortGroupOfProject<T extends BaseProject<any, any> = BaseProject<any, any>>(projects: T[], resoveDepsArray: (proj: T) => string[], projNameToCompare: (proj: T) => string): T[];
+}
+
+declare class BaseQuickFixes<PROJECT extends BaseProject<any, any> = BaseProject<any, any>> extends BaseFeatureForProject<PROJECT> {
+    project: PROJECT;
+    constructor(project: PROJECT);
+    /**
+     * filesRelativePaths example:
+     * ['node_modules/@types/glob/index.d.ts', '/home/user/project/src/app.ts']
+     *
+     * @param filesRelativeAbsPaths\ Quick fix for typescript check
+     */
+    excludeNodeModulesDtsFromTypescriptCheck(filesRelativeAbsPaths: string[]): any;
+    fixSQLLiteModuleInNodeModules(): any;
+    createDummyEmptyLibsReplacements(missingLibsNames?: string[]): any;
+}
+
+declare class BaseReleaseProcess<PROJECT extends BaseProject<any, any> = any> extends BaseFeatureForProject<PROJECT> {
+    /**
+     * Automatic release process of patch plus one version
+     */
+    automaticRelease: boolean;
+    versionType: CoreModels.ReleaseVersionType;
+    preReleaseVersionTag: CoreModels.PreReleaseVersionTag;
+    lastChangesSummary: string;
+    newVersion: string;
+    commitsForChangelog: {
+        commitMessages: string;
+        index: number;
+    }[];
+    startRelease(options?: Partial<BaseReleaseProcess<PROJECT>>): Promise<void>;
+    getReleaseWords(): string[];
+    selectChangelogCommits(): Promise<{
+        commitMessages: string;
+        index: number;
+    }[]>;
+    private getCommitsUpToReleaseCommit;
+    checkBundleQuestion(cwdForCode: string, checkMessage?: string): Promise<boolean>;
+    /**
+     * @returns true if publish , faslse if just version bump
+     */
+    publishToNpm(cwdForCode?: any, automaticRelease?: boolean): Promise<boolean>;
+    protected testAfterPublish(): Promise<boolean>;
+    protected testBeforePublish(): Promise<boolean>;
+    protected commitAndPush(): Promise<void>;
+    protected releaseCommitTemplate(): string;
+    private testLibraries;
+    buildAllLibraries(): Promise<void>;
+    resetReleaseFiles(): Promise<any>;
+    get toBumpProjects(): PROJECT[];
+    bumpNewVersionEverywhere(): Promise<any>;
+    confirmNewVersion(): Promise<void>;
+    protected selectReleaseType(versionToUseResolveFn?: (releaseVersionBumpType: CoreModels.ReleaseVersionType) => string, options?: {
+        quesitonPrefixMessage?: string;
+    }): Promise<CoreModels.ReleaseVersionType>;
+    protected commitMessageInChangelogTransformFn(message: string): Promise<string>;
+    getChangelogContentToAppend(askForEveryItem: boolean): Promise<string>;
+    /**
+     * TODO extend this to all commits from last release
+     */
+    updateChangeLogFromCommits(): Promise<void>;
+    extractChangedLibrariesInCommit(hashOrIndex: string | number): Promise<string>;
+    changelogItemTemplate(hashOrIndex: string | number, confirmEveryItem?: boolean): Promise<string>;
+    generateLastChangesSummary(): Promise<string>;
+    getLastChangesFromCommits({ maxMessagesToCheck, stopOnCommitMessage, }?: {
+        /**
+         * default 3
+         */
+        maxMessagesToCheck?: number;
+        /**
+         * stop serching on commit message
+         */
+        stopOnCommitMessage?: string;
+    }): Promise<string>;
+    getLastReleaseCommitData(): Promise<{
+        lastReleaseCommitMsg: string;
+        /**
+         * -1 if not found
+         */
+        index: number;
+    }>;
+    getLastPackageVersionChangesFromChnagelog(): Promise<string>;
+    private get changeLogPath();
+    get changelogContent(): any;
+    changeLogKeyWord(): string;
+    getChnagelogData(): ChangelogData[];
+}
+
+/**
+ * Easy way to create github pages
+ * (or similar static site hosting)
+ */
+declare class BaseStaticPages<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    readonly TMP_STATIC_PAGE_SITE_REPOS = "tmp-static-pages-sites-repos";
+    protected cleanFolderForStaticPages(pathToBranchRepoFolder: string): Promise<any>;
+    protected get mainFolder(): any;
+    get mainFolderAbsPath(): any;
+    get pagesBranchName(): string;
+    init(mainFolder: string, completeProcess?: boolean): Promise<any>;
+}
+
+declare class BaseVscodeHelpers<PROJECT extends BaseProject = any> extends BaseFeatureForProject<PROJECT> {
+    init(options?: {
+        skipHiddingTempFiles?: boolean;
+    }): Promise<void>;
+    /**
+     * settings.json relative path
+     */
+    readonly relativePathSettingsJsonVscode = ".vscode/settings.json";
+    readonly relativePathExtensionJsonVScode = ".vscode/extensions.json";
+    readonly currentSettingsValue: CoreModels.VSCodeSettings;
+    constructor(project: PROJECT);
+    protected modifyVscode(modifyFN: (settings: CoreModels.VSCodeSettings) => CoreModels.VSCodeSettings): void;
+    saveCurrentSettings(): void;
+    getExtensions(): string[];
+    /**
+     * @deprecated use getExtensions() instead
+     */
+    private get extensions();
+    recreateExtensions(): void;
+    protected getExecuteParamsForSettings(): any[];
+    recreateBaseSettings(options?: {
+        save?: boolean;
+    }): Promise<void>;
+    recreateWindowTitle(options?: {
+        save?: boolean;
+    }): void;
+    installExtensions(extensions?: string[], defaultSelectedAll?: boolean): Promise<void>;
+    /**
+     * This pattern finds a dash followed by at least one digit.
+     * It removes everything from that dash to the end of the string.
+     * Examples:
+     * "name-of-extension-1.2.3" -> "name-of-extension"
+     * "extension-0.9.5-win32-x64" -> "extension"
+     */
+    protected stripVersion(folderName: string): string;
+    get installedExtensions(): string[];
+    static applyProperGlobalSettings(): Promise<void>;
+    /**
+     * by default left menu color and bottom status bar are the same
+     */
+    getVscodeBottomColor(): string;
+    refreshColorsInSettings(): void;
+    getBasicSettins(): Promise<object>;
+    protected resolveParamsVscode(obj: any, prams: any[]): Promise<void>;
+    toogleFilesVisibilityInVscode(options: {
+        action: 'show-files' | 'hide-files';
+        skipSaving?: boolean;
+    }): void;
+    changeColorThemeVscode(white?: boolean): void;
+}
+
+declare abstract class BaseProject<PROJECT extends BaseProject<any, any> = BaseProject<any, any>, TYPE = BaseProjectType> {
+    static ins: BaseProjectResolver<BaseProject<BaseProject<any, any>, CoreModels.BaseProjectType>>;
+    cache: any;
+    static cache: any;
+    get globalCache(): any;
+    readonly type: TYPE | string;
+    /**
+     * resolve instance
+     */
+    abstract readonly ins: BaseProjectResolver<PROJECT>;
+    /**
+     * Unique free port for project instance
+     * only available after executing *this.assignFreePort()*
+     */
+    readonly port: string;
+    libraryBuild?: BaseLibraryBuild<BaseProject>;
+    npmHelpers?: BaseNpmHelpers;
+    fileFoldersOperations?: BaseFileFoldersOperations;
+    get packageJson(): Partial<BasePackageJson>;
+    get nodeModules(): Partial<BaseNodeModules>;
+    linkedProjects?: BaseLinkedProjects;
+    vsCodeHelpers?: BaseVscodeHelpers;
+    releaseProcess?: BaseReleaseProcess;
+    git?: BaseGit;
+    linter?: BaseLinter;
+    ignoreHide: BaseIgnoreHideHelpers;
+    quickFixes?: BaseQuickFixes;
+    staticPages?: BaseStaticPages;
+    javaJdk?: BaseJavaJdk;
+    docker?: BaseDocker;
+    private __location;
+    get location(): string;
+    set location(v: string);
+    /**
+     * TODO move this to framework
+     * Linked projects are actual inside repo
+     * not in separated folders/git sub repos
+     */
+    get isMonorepo(): boolean;
+    protected orderCoreProjects(coreProjects: CoreProject[]): CoreProject[];
+    get core(): CoreProject;
+    get linkedProjectsExisted(): PROJECT[];
+    setType(type: TYPE): void;
+    typeIs(...types: TYPE[]): boolean;
+    typeIsNot(...types: TYPE[]): boolean;
+    /**
+     * project folder basename
+     */
+    get basename(): string;
+    /**
+     * project folder parent basename
+     */
+    get parentBasename(): string;
+    /**
+     * name from package.json
+     */
+    get name(): string;
+    get nameForCli(): string;
+    get nameForNpmPackage(): string;
+    get nameFromPomXML(): string;
+    protected getFoldersForPossibleProjectChildren(): string[];
+    protected getAllChildren(): any;
+    /**
+     * alias to getAllChildren
+     */
+    get children(): PROJECT[];
+    getChildBy(nameOrBasename: string, errors?: boolean): PROJECT;
+    get parent(): PROJECT;
+    get nearestParent(): PROJECT;
+    get grandpa(): PROJECT;
+    get allNpmPackagesNames(): string[];
+    get titleBarName(): string;
+    get genericName(): any;
+    private checkAndBoldenPath;
+    /**
+     * same has project.hasFile();
+     */
+    pathExists(relativePath: string | string[]): boolean;
+    /**
+     * same as project.pathExists();
+     */
+    hasFile(relativePath: string | string[]): boolean;
+    hasFolder(relativePath: string | string[]): boolean;
+    /**
+     * Function will return relative path from project location
+     */
+    relative(absoultePath: string): string;
+    /**
+     *
+     * @param relativePath
+     * @param override it will remove ex
+     */
+    createFolder(relativePath: string | string[], options?: {
+        override?: boolean;
+    }): any;
+    formatFile(specificRelativePath: string | string[]): any;
+    formatAllFiles(): any;
+    /**
+     * same as project.pathhasFileExists();
+     * but with path.resolve
+     */
+    containsFile(fileRelativeToProjectPath: string): any;
+    /**
+     * absolute path:
+     * concated project location with relative path
+     */
+    pathFor(relativePath: string | string[]): any;
+    writeJson(relativePath: string, json: object): any;
+    writeJsonC(relativePath: string, json: object): any;
+    /**
+     * @deprecated us execute instead
+     * use output from or more preciese crafted api
+     */
+    run(command: string, options?: Omit<CoreModels.RunOptions, 'cwd'>): {
+        sync(): any;
+        async(detach?: boolean, mockFun?: (stdoutCallback: (dataForStdout: any) => any, stdErrcCallback: (dataForStder: any) => any, shouldProcesBeDead?: () => boolean) => Promise<number> | number): child_process.ChildProcess;
+        asyncAsPromise(): Promise<void>;
+        unitlOutput(optionsOutput: {
+            stdoutMsg: string | string[];
+            stderMsg?: string | string[];
+            timeout?: number;
+            stdoutOutputContainsCallback?: () => any;
+            outputLineReplace?: (outputLine: string) => string;
+        }): Promise<void>;
+        unitlOutputContains(stdoutMsg: string | string[], stderMsg?: string | string[], timeout?: number, stdoutOutputContainsCallback?: () => any): any;
+    };
+    /**
+     * same as run but async
+     */
+    execute(command: string, options?: CoreModels.ExecuteOptions & {
+        showCommand?: boolean;
+    }): Promise<any>;
+    /**
+     * try run but continue when it fails
+     * @param command
+     * @param options
+     * @returns
+     */
+    tryRunSync(command: string): void;
+    outputFrom(command: string): any;
+    removeFile(fileRelativeToProjectPath: string): any;
+    readFile(fileRelativeToProjectPath: string): any;
+    /**
+     * read json file
+     * handle all json files
+     * jsonc, json5 , json
+     * @param fileRelativeToProjectPath
+     * @returns
+     */
+    readJson<T = {}>(fileRelativeToProjectPath: string): T;
+    /**
+     * copy files or folders from
+     * project to destination
+     */
+    copy(filesOrFolderRelativePathes: string[]): {
+        to: (destination: string) => void;
+    };
+    remove(relativePath: string | string[], exactPath?: boolean): any;
+    removeFolderByRelativePath(relativePathToFolder: string): void;
+    get isAngularLib(): any;
+    refreshChildrenProjects(options?: {
+        askUserAboutUpdate?: boolean;
+    }): Promise<void>;
+    protected getUniqueForTask(task: string): string;
+    registerAndAssignPort(taskName: string, options?: {
+        startFrom?: number;
+    }): Promise<number>;
+    /**
+     * @deprecated use this.registerAndAssignPort() or Utils.getFreePort() instead
+     */
+    assignFreePort(startFrom?: number): Promise<number>;
+    /**
+     * Purpose: not initializing all classes at the beginning
+     * Only for BaseFeatureForProject class
+     */
+    defineProperty<PROJECT>(variableName: keyof PROJECT, classFn: Function, options?: {
+        customInstanceReturn?: () => object;
+    }): any;
+    /**
+     * fs.copy option filter function for copying only selected folders from project
+     */
+    filterOnlyCopy(basePathFoldersOnlyToInclude: string[]): any;
+    /**
+     * fs.copy option filter function for copying only not selected folders from project
+     */
+    filterDontCopy(basePathFoldersTosSkip: string[]): any;
+    /**
+     * main/default hardcoded branches
+     */
+    getMainBranches(): string[];
+    useFeatureInBranchNameForTests(): boolean;
+    resetProcess(overrideBranch?: string, recrusive?: boolean): Promise<void>;
+    linkTo(destPackageLocation: string): void;
+    setValueToJSON(relativePath: string | string[], lodashGetPath: string, value: any): void;
+    setValueToJSONC(relativePath: string | string[], lodashGetPath: string, value: any): void;
+    setValueToJSON5(relativePath: string | string[], lodashGetPath: string, value: any): void;
+    getValueFromJSON(relativePath: string | string[], lodashGetPath: string, defaultValue?: any): any;
+    getValueFromJSONC(relativePath: string | string[], lodashGetPath: string, defaultValue?: any): any;
+    writeFile(relativePath: string | string[], content: string, options?: {
+        formatWithPrettier?: boolean;
+    }): void;
+    runCommandGetString(this: BaseProject, command: string): any;
+    toString: () => string;
+    get parentsNames(): any;
+    openLocation(relativeFolderPath: string): any;
+    private findParentsNames;
+    tryKillAllElectronInstances(): any;
+    /**
+     * init project files structure and depedencies
+     */
+    init(initOptions?: any): Promise<void>;
+    /**
+     * globally link npm as package
+     */
+    link(): Promise<void>;
+    /**
+     * init project files structure without depedencies
+     */
+    struct(initOptions?: any): Promise<void>;
+    /**
+     * init and build() project
+     */
+    test(testOptions?: any): Promise<void>;
+    /**
+     * init and build() project
+     */
+    build(buildOptions?: any): Promise<void>;
+    /**
+     * publish project to npm
+     */
+    publish(publishOptions?: any): Promise<void>;
+    release(releaseOptions?: any): Promise<void>;
+    /**
+     * lint porject
+     */
+    lint(lintOptions?: any): Promise<void>;
+    /**
+     * get info about porject
+     */
+    info(): Promise<string>;
+}
+
+declare abstract class BaseCompilerForProject<ADDITIONAL_DATA = any, PROJECT extends BaseProject = BaseProject> extends BaseClientCompiler<ADDITIONAL_DATA> {
+    project: PROJECT;
+    protected checkFolderCompiler(project: PROJECT, options: BaseClientCompilerOptions, dontCheck?: boolean): BaseClientCompilerOptions;
+    constructor(project: PROJECT, options?: BaseClientCompilerOptions, allowFolderOutSideProject?: boolean);
+}
+
+declare abstract class BaseDebounceCompilerForProject<ADDITIONAL_DATA = any, PROJECT extends BaseProject = BaseProject> extends BaseCompilerForProject<ADDITIONAL_DATA, PROJECT> {
+    protected initialParams: ADDITIONAL_DATA;
+    /**
+     * default debounce time is 1s
+     */
+    protected debounceTime: number;
+    abstract action({ changeOfFiles, asyncEvent, }: {
+        changeOfFiles: ChangeOfFile[];
+        asyncEvent: boolean;
+    }): any;
+    /**
+     * current files that are in project
+     */
+    protected exitedFilesAbsPathes: string[];
+    /**
+     * @deprecated use action() instead
+     */
+    syncAction(absFilesPathes: string[], initialParams: ADDITIONAL_DATA): Promise<void>;
+    private lastAsyncFilesChanges;
+    private debounceAction;
+    /**
+     * @deprecated use action() instead
+     */
+    asyncAction(asyncEvents: ChangeOfFile, initialParams?: ADDITIONAL_DATA): Promise<void>;
+}
+
+declare abstract class BaseCommandLineFeature<PARAMS extends {} = any, PROJECT extends BaseProject<any, any> = BaseProject, PROJECT_RESOLVER extends BaseProjectResolver<PROJECT> = BaseProjectResolver<PROJECT>> {
+    readonly argsWithParams: string;
+    protected readonly methodNameToCall: string;
+    /**
+     * process.cwd()
+     */
+    protected cwd: string;
+    /**
+     * params from command line
+     */
+    protected params: PARAMS;
+    protected ins: PROJECT_RESOLVER;
+    protected __transformArgsBeforeResolvingParams__(args: string[]): string[];
+    /**
+     * clean args without params from command line
+     */
+    args: string[];
+    /**
+     * first arg from args
+     */
+    get firstArg(): string;
+    /**
+     * last arg from args
+     */
+    get lastArg(): string;
+    private __project;
+    protected get project(): PROJECT;
+    protected set project(v: PROJECT);
+    constructor(argsWithParams: string, methodNameToCall: string, 
+    /**
+     * nearest project to cwd
+     */
+    project: PROJECT, 
+    /**
+     * process.cwd()
+     */
+    cwd: string, ins: PROJECT_RESOLVER);
+    _exit(code?: number): void;
+    protected __initialize__(): void;
+    _tryResolveChildIfInsideArg(): void;
+    /**
+     * method called when not using class methods
+     */
+    abstract _(): any;
+}
+
+type CommonCommitMsgBranch = 'refactor' | 'chore' | 'style' | 'docs' | 'test' | 'ci' | 'build' | 'release';
+type TypeOfCommit = 'feature' | 'bugfix' | 'performance' | CommonCommitMsgBranch;
+type TypeOfMsgPrefix = 'feat' | 'fix' | 'perf' | CommonCommitMsgBranch;
+declare class CommitData {
+    private static cleanHttpFromCommitMessage;
+    private static getTeamsIdFrom;
+    private static getModuleNameFrom;
+    /**
+     *
+     * @returns jiras (from oldest to newset)
+     */
+    static extractAndOrderJiraNumbers(commitOrBranchName: string): string[];
+    /**
+     *
+     * @returns jiras (from oldest to newset)
+     */
+    static extractAndOrderIssuesFromOtherProjects(
+    /**
+     * example:
+     * commit: proper git commands tnp/GH-9 darekf77/tnp-helpers/GH-10
+     * feature/__tnp-GH-9____darekf77_tnp-helpers-GH10__-proper-git-commands
+     */
+    commitOrBranchName: string, currentOrigin?: string): string[];
+    static cleanMessageFromJiraNumTeamIdEtc(message: string, optinos?: {
+        teamID: string;
+        commitModuleName: string;
+        jiraNumbers: string[];
+        issuesFromOtherProjects: string[];
+    }): string;
+    private static getModuleNameFromBranch;
+    static getFromArgs(args: string[], options: {
+        typeOfCommit: TypeOfCommit;
+        /**
+         * only needed when push github
+         * and I forgot to add my username before issue
+         * taon pfix proper input my-repo#344
+         * that should be
+         * taon pfix proper input my-username/my-repo#344
+         */
+        currentOrigin?: string;
+        jiraIssuesAreOutsideBrackets?: boolean;
+    }): Promise<CommitData>;
+    static getFromBranch(currentBranchName: string, options?: {
+        releaseWords?: string[];
+        /**
+         * only needed when push github
+         * and I forgot to add my username before issue
+         * taon pfix proper input my-repo#344
+         * that should be
+         * taon pfix proper input my-username/my-repo#344
+         */
+        currentOrigin?: string;
+        jiraIssuesAreOutsideBrackets?: boolean;
+    }): Promise<CommitData>;
+    static from(options: Pick<CommitData, 'message' | 'jiraNumbers' | 'typeOfCommit' | 'commitModuleName' | 'teamID' | 'issuesFromOtherProjects' | 'jiraIssuesAreOutsideBrackets'>): CommitData;
+    private _message;
+    typeOfCommit: TypeOfCommit;
+    /**
+     * ex. JIRA-2132 or MYJIRAREFIX-234234
+     */
+    jiraNumbers: string[];
+    /**
+     * if true then jira issues are outside brackets
+     * feat: proper git commands JIRA-1234
+     *
+     * by default is false
+     * feat(JIRA-1234): proper git commands
+     */
+    jiraIssuesAreOutsideBrackets: boolean;
+    /**
+     * when set -> jiraIssuesAreOutsideBrackets is true
+     */
+    readonly commitModuleName: string;
+    readonly teamID: string;
+    private clearMessage;
+    /**
+     * pure message what was done (without jira or prefixes)
+     * => is included in this.commitMessage
+     */
+    get message(): string;
+    set message(message: string);
+    useFeatureBranchForTestBranch: boolean;
+    get branchPrefix(): TypeOfMsgPrefix;
+    /**
+     * ex. taon/GH-12  darekf77/tnp-helpers/GH-4
+     */
+    get issuesFromOtherProjects(): string[];
+    set issuesFromOtherProjects(value: string[]);
+    private __issuesFromOtherProjects;
+    get commitMessage(): string;
+    get branchName(): string;
+    get isActionCommit(): any;
+}
+
+declare class BaseGlobalCommandLine<PARAMS = any, PROJECT extends BaseProject<any, any> = BaseProject<any, any>, PROJECT_RESOLVER extends BaseProjectResolver<PROJECT> = BaseProjectResolver<PROJECT>> extends BaseCommandLineFeature<PARAMS, PROJECT, PROJECT_RESOLVER> {
+    _(): void;
+    /**
+     * @returns true is sudo was used to restart the process
+     */
+    protected _runAsSudoIfNotElevated({ globalCommandName, }: {
+        globalCommandName?: string;
+    }): Promise<boolean>;
+    /**
+     * TODO return argument not need for now
+     */
+    cwdIsProject(options?: {
+        requireProjectWithGitRoot?: boolean;
+    }): Promise<boolean>;
+    hosts(): any;
+    countCommits(): any;
+    removeSubmodules(): any;
+    removeSubmodule(): any;
+    setEditor(): Promise<any>;
+    upapi(): Promise<any>;
+    apiup(): Promise<any>;
+    apiUpdate(): Promise<any>;
+    cu(): Promise<any>;
+    choreUpdate(): Promise<any>;
+    colorvscode(): any;
+    /**
+     * Generate or update .vscode/settings.json file color settings
+     */
+    settingsVscode(): any;
+    refreshVscodeColors(): any;
+    protected _regenerateVscodeSettingsColors(overideBottomColor?: string): void;
+    private updateProject;
+    forceUpdate(): Promise<void>;
+    /**
+     * alias for forceupdate
+     */
+    forceup(): Promise<void>;
+    update(): Promise<void>;
+    /**
+     * alias for update
+     */
+    up(): Promise<void>;
+    /**
+     * alias for update
+     */
+    pu(): Promise<void>;
+    docsUpdate(): Promise<void>;
+    /**
+     * alias for docsUpdate
+     */
+    docsUp(): Promise<void>;
+    deepUpdate(): Promise<void>;
+    /**
+     * alias for deepupdate
+     */
+    deepUp(): Promise<void>;
+    updateAll(): Promise<void>;
+    /**
+     * alias for updateAll
+     */
+    upAll(): Promise<void>;
+    deepUpdateForce(): Promise<void>;
+    /**
+     * alias for deepUpdateForce
+     */
+    deepUpForce(): Promise<void>;
+    develop(): Promise<any>;
+    dev(): Promise<any>;
+    repul(): Promise<any>;
+    repull(): Promise<any>;
+    pul(): Promise<any>;
+    pull(): Promise<any>;
+    pullAll(): Promise<any>;
+    pp(): Promise<any>;
+    private __resetInfo;
+    fetch(): Promise<any>;
+    reset(): Promise<any>;
+    soft(): Promise<any>;
+    rebase(): Promise<any>;
+    /**
+     * stash only staged files
+     */
+    stash(): Promise<any>;
+    /**
+     * stash all files
+     */
+    stashAll(): Promise<any>;
+    /**
+     * push force to all origins
+     */
+    pushAllForce(): Promise<void>;
+    pAllForce(): Promise<void>;
+    pAllf(): Promise<void>;
+    pAll(): Promise<void>;
+    /**
+     * push to all origins
+     */
+    pushAll(force?: boolean): Promise<void>;
+    forcePush(): Promise<void>;
+    pushForce(): Promise<void>;
+    /**
+     * Commit and push this for single repo
+     */
+    commit(options?: {
+        force?: boolean;
+        typeofCommit?: TypeOfCommit;
+        origin?: string;
+        commitMessageRequired?: boolean;
+        noExit?: boolean;
+    }): Promise<void>;
+    _preventPushPullFromNotCorrectBranch(): Promise<void>;
+    qPush(): Promise<void>;
+    quickPush(): Promise<void>;
+    repushauto(): Promise<void>;
+    rePush(skipQuesion?: boolean): Promise<void>;
+    push(options?: PushProcessOptions): Promise<void>;
+    melt(): Promise<void>;
+    meltUp(): Promise<any>;
+    meltAll(): Promise<any>;
+    private __meltCommitsFunc;
+    private meltUpdateCommits;
+    pf(): Promise<any>;
+    pRel(): Promise<any>;
+    pRelease(): Promise<any>;
+    pushRelease(): Promise<any>;
+    mPush(): Promise<any>;
+    fmPush(): Promise<any>;
+    mfPush(): Promise<any>;
+    mforcePush(): Promise<any>;
+    meltforcePush(): Promise<any>;
+    forceMeltPush(): Promise<any>;
+    meltPush(force?: boolean): Promise<any>;
+    pushFeature(): Promise<any>;
+    pushFix(): Promise<any>;
+    pfix(): any;
+    pushChore(): Promise<any>;
+    pc(): Promise<any>;
+    pushRefactor(): Promise<any>;
+    pushref(): Promise<any>;
+    pref(): Promise<any>;
+    pushStyle(): Promise<any>;
+    pstyl(): Promise<any>;
+    pstyle(): Promise<any>;
+    pushDocs(): Promise<any>;
+    pd(): Promise<any>;
+    pdocs(): Promise<any>;
+    pushTest(): Promise<any>;
+    pTest(): Promise<any>;
+    pTests(): Promise<any>;
+    pushPerf(): Promise<any>;
+    pushCi(): Promise<any>;
+    branch(): Promise<any>;
+    pushBuild(): Promise<any>;
+    SET_ORIGIN(): Promise<any>;
+    $COPY_AND_RENAME(): Promise<any>;
+    RENAME_ORIGIN(): Promise<any>;
+    LAST_TAG_HASH(): Promise<any>;
+    LAST_TAG(): Promise<any>;
+    CHECK_TAG_EXISTS(): any;
+    /**
+     * TODO move somewhere
+     */
+    lint(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    version(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    init(): Promise<any>;
+    /**
+     * init parent and first level children
+     */
+    initAll(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    struct(): Promise<any>;
+    /**
+     * TODO move somewhere
+     */
+    info(): Promise<any>;
+    modified(): Promise<any>;
+    refresh(): Promise<void>;
+    changes(): Promise<any>;
+    allTags(): Promise<any>;
+    removeTag(): Promise<any>;
+    BRANCH_NAME(): any;
+    REMOTES(): any;
+    SET_REMOTE_SSH(): Promise<any>;
+    SET_REMOTE_http(): Promise<any>;
+    SET_REMOTE_https(): Promise<any>;
+    protected _resolveChildFromArg(): any;
+    origin(): any;
+    remote(): any;
+    originHttp(): any;
+    originHttps(): any;
+    originssh(): any;
+    origins(): any;
+    gitConfig(): any;
+    LAST_COMMIT_HASH(): any;
+    COMMIT_MESSAGE_BY_HASH(): Promise<any>;
+    LAST_5_COMMITS(): Promise<any>;
+    updateDepsFrom(): Promise<any>;
+    isSupportedTaonTerminal(): any;
+    isRunningInWindowsCmd(): any;
+    isRunningInWindowsPowerShell(): any;
+    INSTALL_PROJECT_EXTENSIONS(): Promise<void>;
+    INSTALL_PROJECT_EXT(): Promise<void>;
+    INS_PROJ_EXT(): Promise<void>;
+    INSTALL_PROJ_EXT(): Promise<void>;
+    projdb(): Promise<any>;
+    private __filterBranchesByPattern;
+    private __selectBrach;
+    clone(): Promise<any>;
+    ghSave(): Promise<any>;
+    ghRestore(): Promise<any>;
+    ports(): Promise<any>;
+    /**
+     * tnp startCliServicePortsWorker --restart
+     */
+    startCliServicePortsWorker(): Promise<void>;
+    waitForUserAnyKey(): Promise<any>;
+    pauseTerminal(): any;
+    sleepTerminal(): any;
+    ghPagesInit(): Promise<any>;
+    isPortInUse(): Promise<any>;
+    procInfo(): any;
+    processInfo(): any;
+    lastGitTag(): any;
+    checkPort(): Promise<any>;
+    checkPorts(): Promise<any>;
+    symlink(): any;
+    removeSymlinksDryRun(): any;
+    selectJava(): Promise<any>;
+    selectTomcat(): Promise<any>;
+    LN(): any;
+    copy(): any;
+    simulateDomain(): Promise<void>;
+    preview(): Promise<void>;
+    /**
+     * read huge file and display only lines with specyfic words
+     */
+    shorten(): Promise<any>;
+    dumpPackagesVersions(): void;
+    zip(): Promise<any>;
+    unzip(): Promise<any>;
+    startTransmission(): Promise<any>;
+    _removeTransmission(): Promise<any>;
+    backupBranch(): Promise<any>;
+    bb(): Promise<any>;
+    countCodeLines(): Promise<any>;
+    countCode(): Promise<any>;
+    countLines(): Promise<any>;
+    isNodeVersionOk(): any;
+    pwd(): void;
+    more(): Promise<any>;
+    less(): Promise<any>;
+    /**
+     *  npm install --global bin-version-check-cli
+     *  npm i -g yt-dlp
+     *  choco install ffmpeg
+     */
+    MP3(args: any): any;
+    MP4(args: any): any;
+    gif(): void;
+    killZs(): any;
+    startZs(): any;
+    zsKill(): any;
+    zsStart(): any;
+    startZscaller(): any;
+    killZscaller(): any;
+    hasCommand(): Promise<void>;
+    hasCommandSync(): void;
+    publicIpAddress(): Promise<void>;
+    publicIp(): Promise<void>;
+    localIps(): Promise<void>;
+    isOnline(): Promise<any>;
+    configureBash(): Promise<void>;
+    configureShell(): Promise<void>;
+    confBash(): void;
+    confShell(): void;
+    gitResetAll(): any;
+    isElevated(): Promise<any>;
+    sudoCheck(): Promise<void>;
+    pythonModuleExists(): Promise<any>;
+}
+
+type CoreProjectEnvironment = {
+    shortName?: string;
+    name?: string;
+    description?: string;
+    onlineLink?: string;
+};
+type CoreCommandArgOptions<PROJECT extends BaseProject<any, any>> = {
+    project?: PROJECT;
+    /**
+     * watch mode
+     */
+    watch?: boolean;
+    prod?: boolean;
+    debug?: boolean;
+    isInReleaseProcess?: boolean;
+    libraryBuildOptions?: LibrariesBuildOptions;
+    testBuildOptions?: TestBuildOptions;
+    /**
+     * first arg from command line
+     */
+    firstArg?: string;
+    /**
+     * Not question for user ex.
+     * - automatic process of patch release
+     * - automatic deployment for default server
+     */
+    automaticProcess?: boolean;
+    /**
+     * orignal args with params
+     */
+    argsWithParams?: string;
+    copyto?: string[];
+    copytoall?: boolean;
+    /**
+     * args from command line (clearn from params)
+     */
+    args?: string[];
+    exitCallback?: () => void;
+};
+declare class CoreProject<PROJECT extends BaseProject = BaseProject> {
+    static coreProjects: CoreProject<any>[];
+    static from<Proj extends BaseProject = BaseProject<any, any>>(options: Omit<CoreProject<Proj>, 'name' | 'url' | 'branch'>): CoreProject<Proj>;
+    private constructor();
+    extends?: CoreProject<any>;
+    color?: string;
+    /**
+     * second color for project (optional)
+     */
+    secondColor?: string;
+    /**
+     * second color for project (optional)
+     */
+    thirdColor?: string;
+    npmRegistry?: string;
+    description?: string;
+    /**
+     * ssh url for git repo
+     */
+    urlSSH?: string;
+    /**
+     * https url for git repo
+     */
+    urlHttp?: string;
+    /**
+     * main branches - first is default
+     */
+    branches: string[];
+    /**
+     * project environments
+     */
+    environments?: CoreProjectEnvironment[];
+    cleanCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    initCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    /**
+     * Build whatever is needed to run project
+     * buildCommand includes initCommand
+     */
+    buildCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    /**
+     * startCommand includes initCommand, buildCommand and launchCommand
+     */
+    startCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    /**
+     * launch already built project
+     */
+    launchCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    releaseCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    publishCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    deployCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    testCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    docsCommand?: (options: CoreCommandArgOptions<PROJECT>) => Promise<void>;
+    /**
+     * function to recognize project
+     */
+    recognizedFn: (project: PROJECT) => boolean;
+    /**
+     * core porject name from repo basename
+     */
+    get name(): string;
+    /**
+     * main (default for reset) branch
+     */
+    get branch(): string;
+    /**
+     * url for git repo
+     */
+    get url(): string;
+}
+declare const CoreTypescriptProject: CoreProject<BaseProject<BaseProject<any, any>, tnp_core_browser.CoreModels.BaseProjectType>>;
+declare const CoreAngularProject: CoreProject<BaseProject<BaseProject<any, any>, tnp_core_browser.CoreModels.BaseProjectType>>;
+
+declare class LinkedProject {
+    static from(options: Partial<LinkedProject>): LinkedProject;
+    static fromName(projectName: string, currentRemoteUrl?: string, currentBranch?: string): any;
+    static detect(insideLocation: string, options?: {
+        recursive?: boolean;
+        checkAlsoNonRepos?: boolean;
+    }): LinkedProject[];
+    /**
+     * sometime there is project that has one project
+     * embede inside another project
+     */
+    internalRealtiveProjectPath?: string;
+    /**
+     * don't access directly, use remoteUrl() instead
+     */
+    repoUrlSsh?: string;
+    /**
+     * don't access directly, use remoteUrl() instead
+     */
+    repoUrlHttp?: string;
+    /**
+     * don't access directly, use remoteUrl() instead
+     */
+    repoUrl?: string;
+    /**
+     * url for git repo
+     */
+    remoteUrl(): string;
+    remoteUrlTransformed(setOrigin: 'ssh' | 'http'): string;
+    defaultBranch?: string;
+    purpose?: string;
+    relativeClonePath?: string;
+}
+declare class LinkedPorjectsConfig {
+    static from(options: Partial<LinkedPorjectsConfig>): any;
+    prefix?: string;
+    skipRecrusivePush?: boolean;
+    resetOnlyChildren?: boolean;
+    projects: LinkedProject[];
+}
+
+type CommandType = {
+    command?: string;
+    exec?: ExecCommandType;
+    title?: string;
+    group?: string;
+    hideContextMenu?: boolean;
+    options?: ProcesOptions;
+    isDefaultBuildCommand?: boolean;
+};
+type ResolveVariable = {
+    variable: string;
+    resolveValueFromCommand?: string;
+    prompt?: string;
+    placeholder?: string | Function;
+    variableValue?: any;
+    encode?: boolean;
+    options?: {
+        option: any;
+        label: string;
+    }[] | string;
+    optionsResolved?: {
+        option: any;
+        label: string;
+        skipNextVariableResolve?: boolean;
+    }[];
+    useResultAsLinkAndExit?: boolean;
+    exitWithMessgeWhenNoOptions?: string;
+    /**
+     * { label: 'action item !!!', option: { action: 'STRING_SECRET_CODE' } }
+     * { label: 'normal item', option: < primitive value > }
+     */
+    fillNextVariableResolveWhenSelectedIsActionOption?: boolean;
+};
+type ProcesOptions = {
+    progressLocation?: 'notification' | 'statusbar';
+    findNearestProject?: boolean;
+    findNearestProjectWithGitRoot?: boolean;
+    findNearestProjectType?: CoreModels.LibType;
+    findNearestProjectTypeWithGitRoot?: CoreModels.LibType;
+    syncProcess?: boolean;
+    reloadAfterSuccesFinish?: boolean;
+    cancellable?: boolean;
+    titleWhenProcessing?: string;
+    tnpNonInteractive?: boolean;
+    tnpShowProgress?: boolean;
+    debug?: boolean;
+    showOutputDataOnSuccess?: boolean;
+    showSuccessMessage?: boolean;
+    askBeforeExecute?: boolean;
+    resolveVariables?: ResolveVariable[];
+};
+/**
+ * @deprecated
+ */
+type PROGRESS_DATA_TYPE = 'info' | 'error' | 'warning' | 'event';
+/**
+ * @deprecated
+ */
+interface IProgressData {
+    /**
+     * How man percent of progress
+     */
+    value?: number;
+    msg?: string;
+    type?: PROGRESS_DATA_TYPE;
+    date?: Date;
+}
+/**
+ * @deprecated
+ */
+declare class ProgressData implements IProgressData {
+    value: number;
+    msg: string;
+    type: PROGRESS_DATA_TYPE;
+    date: Date;
+    static resolveFrom(chunk: string, callbackOnFounded?: (json: ProgressData) => any, checkSplit?: boolean): ProgressData[];
+    constructor(value?: number, msg?: string, type?: PROGRESS_DATA_TYPE, date?: Date);
+}
+
+/**
+ * @deprecated
+ */
+type LogMode = 'dialog' | 'logmsg';
+/**
+ * @deprecated
+ */
+declare class Log {
+    private name;
+    private mode;
+    private debugMode;
+    outputChannel: OutputChannel;
+    constructor(name: string, mode?: LogMode, debugMode?: boolean);
+    static instance(name: string, mode: LogMode, debugMode?: boolean): Log;
+    data(data: string): void;
+    info(data: string): void;
+    error(data: string): void;
+}
+
+type ExecCommandTypeOpt = {
+    vscode?: typeof vscode;
+    log?: Log;
+    context?: ExtensionContext;
+    cwd?: string;
+    uri: Uri;
+    selectedUris: Uri[];
+    rootFolderPath?: string;
+};
+type ExecCommandType = string | string[] | ((opt: ExecCommandTypeOpt) => any);
+declare function executeCommand(titleOfTask: any, registerName: string, commandToExecute: ExecCommandType, pOptions?: ProcesOptions, isDefaultBuildCommand?: boolean, context?: ExtensionContext, debug?: boolean): any;
+
+declare const Helpers: HelpersTaon;
+
+export { BaseCLiWorkerStartMode, BaseCLiWorkerStartParams, BaseCliMethodOptions, BaseCliWorker, BaseCliWorkerConfig, BaseCliWorkerConfigGetContextOptions, BaseCliWorkerTerminalUI, BaseCliWorkerUtils, BaseCommandLineFeature, BaseCompilerForProject, BaseDebounceCompilerForProject, BaseFeatureForProject, BaseFileFoldersOperations, BaseGit, BaseGlobalCommandLine, BaseIgnoreHideHelpers, BaseJsonFileReader, BaseLibraryBuild, BaseLinkedProjects, BaseLinter, BaseNodeModules, BaseNpmHelpers, BasePackageJson, BaseProcessManger, BaseProject, BaseProjectResolver, BaseProjectTypeArr, BaseQuickFixes, BaseReleaseProcess, BaseVscodeHelpers, CommandConfig, CommandProcess, CommandProcessState, CommitData, CoreAngularProject, CoreProject, CoreTypescriptProject, Helpers, HelpersAngular, LinkedPorjectsConfig, LinkedProject, PackageJsonDependencyObjArr, Port, PortStatusArr, PortsWorker, ProgressData, TaonBaseCliWorkerController, TaonPortsController, UtilsDocker, UtilsFileSync, UtilsHttp, UtilsJava, UtilsMd, UtilsNpm, UtilsPasswords, UtilsQuickFixes, UtilsTaonWorker, UtilsTypescript, UtilsVSCode, UtilsZip, UtilsZipBrowser, executeCommand, getBaseCliWorkerDatabaseConfig };
+export type { BaseCliWorkerGuiUrlOptions, BaseJsonFileReaderOptions, BaseProjectType, BaseWorkerTerminalActionReturnType, ChangelogData, CommandProcessRunOptions, CommandType, CommonCommitMsgBranch, CoreCommandArgOptions, CoreProjectEnvironment, DedupePackage, DockerBuild, DockerComposeFile, DockerNetwork, DockerService, DockerVolume, ExecCommandType, ExecCommandTypeOpt, IProgressData, LibrariesBuildOptions, LibraryBuildCommandOptions, NgProject, PROGRESS_DATA_TYPE, PackageJson, PackageJsonDependencyObj, PortStatus, ProcesOptions, ProcessManagerConfig, PushProcessOptions, ResolveVariable, TestBuildOptions, TypeOfCommit, TypeOfMsgPrefix };