/**
 * 并行执行promise 根据配置设置最大并行数，并将结果组装返回
 * @param promises
 * @param opts:{
 *   taskCont: number,  // 最大并行数
 *   callback?: (result: unknown, index: number) => unknown // 回调函数
 * }
 */
export declare const promiseScheduler: (promises: Array<() => Promise<unknown>>, opts?: {
    taskCont: number;
    callback?: (result: unknown, index: number) => unknown;
}) => Promise<unknown>;
/**
 * 并发任务管理器
 * 单个任务addTask
 * 多个任务all
 * 通过on('end', callBack) // 监听结束事件
 */
declare type Task = () => Promise<unknown> | unknown;
export declare class PromiseTasks {
    promises: Array<{
        task: Task;
        callBack?: (val: unknown, index: number) => unknown;
        resolve: (value: unknown) => void;
        reject: (reason?: any) => void;
    }>;
    results: Array<{
        result: unknown;
        type: 'error' | 'success';
    }>;
    callBack: Array<{
        event: 'end';
        callBack: Function;
    }>;
    taskCont: number;
    index: number;
    currentIndex: number;
    hasResultsIndex: number;
    constructor(taskCont?: number);
    init(): void;
    _createTask(task: Task, callBack?: <T>(val: T, index: number) => T, afterCreate?: Function): Promise<unknown>;
    addTask(task: Task, callBack?: <T>(val: T, index: number) => T): Promise<unknown>;
    run(): void;
    all(tasks: Array<Task>, callBack?: <T>(val: T, index: number) => T): void;
    on(event: 'end', callBack: Function): void;
    eventLoop(event: 'end'): void;
    end(): void;
}
/**
 * 任务分片，将耗时任务拆解 在空闲时间执行 避免卡顿
 */
export declare class FreeTasks {
    tasks: Array<Function>;
    constructor();
    addTask(task: Function): void;
    run(): void;
}
/**
 * 消除异步传染性
 */
declare type AsyncToSyncPromise = Promise<unknown> & {
    status: 'fulfilled' | 'rejected' | 'pending';
    value: unknown;
    reason: unknown;
};
export declare class AsyncToSync {
    useIndex: number;
    promiseIndex: number;
    promiseCache: Array<AsyncToSyncPromise>;
    constructor();
    run(fn: Function): void;
    use(_promise: Promise<unknown>): unknown;
}
export {};