/// <reference types="node" />
import { OptionConfig } from 'cac/types/Option';
import { DepBuilder } from './dep-builder';
import { GlobalOptions, TaskContext } from './task-manager';
import { Writable } from 'stream';
export declare type OptionDef = [string, string, OptionConfig | undefined];
export declare type TaskFn<O, T = any> = (ctx: TaskContext<O>) => T | Promise<T>;
export interface TaskDep<O = any> {
    name: string;
    /**
     * Dependences are executed serially by default.
     * If order doesn't matter and you want better performance via parallel, you can mark it as asynchronized.
     * Asynchronized will run immediately whether there are synchronized tasks before them or not.
     * You can pass a number as the priority of asynchronized tasks, bigger is formmer.
     */
    async?: boolean | number;
    /**
     * Whether rerun it when it occured in dependences tree more then once.
     */
    force?: boolean;
    /**
     * Parsed options
     */
    options?: O;
    resolveOptions?: (ctx: TaskContext) => Promise<O> | O;
    [k: string]: any;
}
export declare type Dependency = TaskDep | string | DepBuilder;
export interface Task<O = any> extends TaskDep<O> {
    dependencies?: TaskDep[];
    desc?: string;
    fn?: (ctx: TaskContext<O>) => void | Promise<void>;
    /**
     * Raw arg strings
     */
    rawArgs: string[];
    /**
     * @description Whether task options only allow defined options, default false
     * @default false
     */
    strict?: boolean;
    options: O;
    /**
     * @description whether show loading
     * @default globalOptions.loading
     */
    loading?: boolean;
    /**
     * @description whether log executed command
     * @default globalOptions.logCommand
     */
    logCommand?: boolean;
    /**
     * @description whether redirect all ctx.exec & ctx.spawn's output to file
     * @default globalOptions.redirectLog
     */
    redirectLog?: boolean | string | Writable;
}
/**
 * Set global options for all tasks.
 * @param options
 */
export declare function setGlobalOptions(options: GlobalOptions): void;
export declare const before: (fn: () => void | Promise<void>) => void;
export declare const after: (fn: () => void | Promise<void>) => void;
export declare const onerror: (fn: () => void | Promise<void>) => void;
declare namespace TaskOptions {
    let last: {
        desc: string | undefined;
        optionDefs: [string, string, OptionConfig | undefined][];
        strict: boolean | undefined;
        loading: boolean | undefined;
    };
    function empty(): {
        desc: string | undefined;
        optionDefs: [string, string, OptionConfig | undefined][];
        strict: boolean | undefined;
        loading: boolean | undefined;
    };
}
export declare function desc(desc: string): void;
export declare function option(rawName: string, description: string, config?: OptionConfig): void;
export declare function strict(): void;
/**
 * Set options for next task.
 * @param options
 */
export declare function setOption(options: Partial<typeof TaskOptions.last>): void;
export declare function task<O>(name: string, fn: TaskFn<O>): Task<O>;
export declare function task<O>(name: string, dependencies: Dependency[], fn?: TaskFn<O>): Task<O>;
export {};