import { UtilsOs } from 'tnp-core/lib';
import { CoreModels } from 'tnp-core/lib';
import { CommandOutputOptions, ProcessStartOptions } from 'tnp-core/lib';
import { BaseNodeModules, BasePackageJson, CoreProject } from '../../index';
import { BaseProjectType, CommandActionType, PushProcessOptions } from '../../models';
import { BaseDocker } from './base-docker';
import { BaseFileFoldersOperations } from './base-file-folders-operations';
import { BaseGit } from './base-git';
import { BaseIgnoreHideHelpers } from './base-ignore-hide';
import { BaseJavaJdk } from './base-java-jdk';
import type { BaseLibraryBuild } from './base-library-build';
import { BaseLinkedProjects } from './base-linked-projects';
import { BaseLinter } from './base-linter';
import { BaseNpmHelpers } from './base-npm-helpers';
import { BaseProjectResolver } from './base-project-resolver';
import { BaseQuickFixes } from './base-quick-fixes';
import { BaseReleaseProcess } from './base-release-process';
import { BaseStaticPages } from './base-static-pages';
import { BaseVscodeHelpers } from './base-vscode';
export 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);
    constructor(
    /**
     * doesn't need to be real path -> can be link
     */
    location: 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(): PROJECT[];
    /**
     * 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;
    }): void;
    formatFile(specificRelativePath: string | string[]): void;
    formatAllFiles(): void;
    /**
     * same as project.pathhasFileExists();
     * but with path.resolve
     */
    containsFile(fileRelativeToProjectPath: string): boolean;
    /**
     * absolute path:
     * concated project location with relative path
     */
    pathFor(relativePath: string | string[]): string;
    writeJson(relativePath: string, json: object): void;
    writeJsonC(relativePath: string, json: object): void;
    /**
     * @deprecated us execute instead
     * use output from or more preciese crafted api
     */
    run(command: string, options?: Omit<CoreModels.RunOptions, 'cwd'>): {
        sync(): string;
        async(detach?: boolean, mockFun?: (stdoutCallback: (dataForStdout: any) => any, stdErrcCallback: (dataForStder: any) => any, shouldProcesBeDead? /**
         * project folder basename
         */: () => boolean) => Promise<number> | number): import("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): Promise<any>;
    };
    /**
     * Open project location (or relative path to folder inside project)
     * in default editor
     */
    openInEditor(relativePath?: string, specyficEditor?: UtilsOs.Editor): Promise<void>;
    /**
     * same as run but async
     */
    execute(command: string, options?: Partial<ProcessStartOptions> & {
        showCommand?: boolean;
    }): Promise<any>;
    /**
     * try run but continue when it fails
     * @param command
     * @param options
     * @returns
     */
    tryRunSync(command: string, options?: Omit<CoreModels.RunOptions, 'cwd'>): void;
    outputFrom(command: string, options?: CommandOutputOptions): string;
    removeFile(fileRelativeToProjectPath: string | string[]): void;
    readFile(fileRelativeToProjectPath: string | string[]): string;
    /**
     * read json file
     * handle all json files
     * jsonc, json5 , json
     * @param fileRelativeToProjectPath
     * @returns
     */
    readJson<T = {}>(fileRelativeToProjectPath: string | string[]): T;
    /**
     * @deprecated TODO replace whit with create copyFileTo function
  
     * copy files or folders from
     * project to destination
     */
    copy(filesOrFolderRelativePathes: string[]): {
        to: (destination: string | string[]) => void;
    };
    remove(relativePath: string | string[], exactPath?: boolean): void;
    removeFolderByRelativePath(relativePathToFolder: string): void;
    get isAngularLib(): boolean;
    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;
    }): void;
    /**
     * fs.copy option filter function for copying only selected folders from project
     */
    filterOnlyCopy(basePathFoldersOnlyToInclude: string[]): (src: string, dest: string) => boolean;
    /**
     * fs.copy option filter function for copying only not selected folders from project
     */
    filterDontCopy(basePathFoldersTosSkip: string[]): (src: string, dest: string) => boolean;
    /**
     * main/default hardcoded branches
     */
    getMainBranches(): string[];
    useFeatureInBranchNameForTests(): boolean;
    resetProcess(overrideBranch?: string, options?: {
        commandActionType?: CommandActionType;
    }): 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): string;
    toString: () => string;
    get parentsNames(): string[];
    openLocation(relativeFolderPath: string): void;
    private findParentsNames;
    tryKillAllElectronInstances(): void;
    /**
     * 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?: CoreModels.NpmPublishOptions): Promise<void>;
    release(releaseOptions?: any): Promise<void>;
    /**
     * lint porject
     */
    lint(lintOptions?: PushProcessOptions): Promise<void>;
    /**
     * get info about porject
     */
    info(): Promise<string>;
}
