/// <reference types="node" />
import { Task } from './task';
import { ShellContext } from './exec';
import { ILoggerProps, Logger } from './logger';
export interface GlobalOptions {
    /**
     * @default true
     */
    loading?: boolean;
    indent?: number;
    /**
     * @description Whether task options only allow defined options, default false
     * @default false
     */
    strict?: boolean;
    logger?: ILoggerProps;
    logCommand?: boolean;
    options?: any;
    rawArgs?: string[];
    /** @default true */
    showTaskDuration?: boolean;
}
export interface RunDepOptions {
    rawArgs?: string[];
    parentCtx?: TaskContext | null;
    /** default is false */
    loading?: boolean;
    indent?: number;
}
export interface RunTaskOptions extends RunDepOptions {
    options?: any;
    rawArgs?: string[];
    parentCtx?: TaskContext | null;
    force?: boolean;
}
export declare enum TaskState {
    waiting = "waiting",
    pending = "pending",
    skipped = "skipped",
    loading = "loading",
    succeeded = "succeeded",
    failed = "failed"
}
export interface DepsTree {
    uid: string;
    task: Task;
    asyncDeps: DepsTree[][];
    syncDeps: DepsTree[];
    state: TaskState;
    depth: number;
    priority: number;
    duration: number;
}
export declare class TaskContext<O = any> extends ShellContext {
    task: Task<O>;
    global: GlobalOptions;
    fs: typeof import("fs") & typeof import("fs/promises") & {
        watchDir: {
            (dir: string, cb: import("./fs").WatchDirHandler): void;
            (dir: string, options: import("./fs").WatchDirOptions, cb: import("./fs").WatchDirHandler): void;
        };
        copy: (src: string, dist: string, opts?: {
            skip?: ((file: string, stat: import("fs").Stats) => boolean | void | Promise<boolean | void>) | undefined;
            overwrite?: boolean | undefined;
        } | undefined) => Promise<void>;
        exists(path: import("fs").PathLike): Promise<boolean>;
        lexists(path: import("fs").PathLike): Promise<boolean>;
        isFile(path: import("fs").PathLike): Promise<boolean>;
        isDirectory(path: import("fs").PathLike): Promise<boolean>;
        isSymbolicLink(path: import("fs").PathLike): Promise<boolean>;
        copyFile: typeof import("fs").copyFile.__promisify__ | ((src: import("fs").PathLike, dist: import("fs").PathLike) => Promise<unknown>);
        mkdirp(dir: string): Promise<void>;
        mkdirpSync(dir: string): void;
        rmrf(path: string): Promise<void>;
        outputFile(path: string, data: any, options?: import("./fs").WriteOptions | undefined): Promise<void>;
        outputFileSync(path: string, data: any, options?: import("./fs").WriteOptions | undefined): void;
        outputJson(path: string, data: object, options?: ({
            space?: number | undefined;
            replacer?: ((key: string, value: any) => any) | undefined;
        } & import("./fs").WriteOptions) | undefined): Promise<void>;
        outputJsonSync(path: string, data: any, options?: ({
            space?: number | undefined;
            replacer?: ((key: string, value: any) => any) | undefined;
        } & import("./fs").WriteOptions) | undefined): void;
        readJson<T = any>(path: string, options?: {
            encoding?: null | undefined;
            flag?: string | undefined;
        } | null | undefined): Promise<T>;
        readJsonSync<T_1 = any>(path: string, options?: {
            encoding?: null | undefined;
            flag?: string | undefined;
        } | null | undefined): T_1;
        iter(dir: string, skip: (path: string, stat: import("fs").Stats) => boolean | void | Promise<boolean | void>): Promise<void>;
    };
    protected _logger: Logger;
    get debug(): (...args: any[]) => void;
    get info(): (...args: any[]) => void;
    get log(): (...args: any[]) => void;
    get warn(): (...args: any[]) => void;
    get error(): (...args: any[]) => void;
    constructor(task: Task<O>, global: GlobalOptions);
    /**
     * get task options
     */
    get options(): O;
    /**
     * run a task manually
     * @param task
     * @param options
     */
    run(task: string | Task, options?: RunTaskOptions): Promise<void>;
}
export declare type Callback = {
    fn: (args?: any) => void | Promise<void>;
    namespaces: string[];
};
export declare type ListenerNames = 'before' | 'after' | 'onerror';
export declare class TaskManager {
    private _tasks;
    private _didMap;
    namespaces: string[];
    listeners: {
        before: Callback[];
        after: Callback[];
        onerror: Callback[];
    };
    globalOptions: GlobalOptions;
    getTasks(): Task<any>[];
    addTask(task: Task): Task<any>;
    resolveDependencyTree(t: Task, depth?: number): DepsTree;
    isLoading(t: Task, props: RunTaskOptions): boolean;
    runDepsTree(depsTree: DepsTree, props: RunTaskOptions): Promise<void>;
    runListner(name: ListenerNames, ns: string[], args?: any[]): Promise<void>;
    run(name?: string | Task, props?: RunTaskOptions): Promise<void>;
}