interface Task {
    (): Promise<any>;
}
type Deconstruction<T extends (...args: any) => any> = ReturnType<T> extends Promise<infer U> ? U : ReturnType<T>;
interface TaskConfig<T extends Task> {
    taskId: string;
    handlePromise: Task;
    resolve: (value: Deconstruction<T>) => void;
    reject: (reason: any) => void;
}
interface ConcurrentLimitInterface {
    limitCount: number;
    queue: Array<TaskConfig<(...args: any) => Promise<any>>>;
    run: <T extends (...args: any) => Promise<any>>(task: T, taskId: string) => Promise<Deconstruction<T>>;
}
interface Params {
    limitCount: number;
}
declare class ConcurrentLimit implements ConcurrentLimitInterface {
    limitCount: number;
    queue: Array<TaskConfig<Task>>;
    runningCount: number;
    skipTasks: Set<string>;
    constructor(config: Params);
    private enqueue;
    private next;
    skip(taskId: string): void;
    run<T extends () => Promise<any>>(task: T, taskId: string): Promise<Deconstruction<T>>;
}

export { ConcurrentLimit };