/// <reference types="node" />
import { EventEmitter } from 'events';
import { IAsyncQueueOptions } from './IAsyncQueueOptions';
import { IQueueProcessor } from './IQueueProcessor';
import { IQueueWorkload } from './IQueueWorkload';
import { QueueJob } from './QueueJob';
import { IAsyncQueueStats } from './IAsyncQueueStats';
import { ILoggerApi } from '../logging/ILoggerApi';
import { IQueue } from './IQueue';
import { QueueJobRef } from './QueueJobRef';
export declare class AsyncWorkerQueue<T extends IQueueWorkload> extends EventEmitter implements IQueue {
    private _inc;
    private _done;
    private _error;
    private _paused;
    private enqueueing;
    private options;
    private processor;
    private runningTasks;
    private all;
    private worker;
    private done;
    private active;
    private logger;
    private concurrent;
    private maxConcurrent;
    constructor(processor: IQueueProcessor<T>, options?: IAsyncQueueOptions);
    getInc(): number;
    getLogger(): ILoggerApi;
    private cleanup;
    private next;
    getConcurrent(): number;
    speedUp(): void;
    speedDown(): void;
    status(): IAsyncQueueStats;
    private process;
    private enqueue;
    private drained;
    private fireProcess;
    get(id: string): Promise<QueueJob<T>> | QueueJob<T>;
    set(x: QueueJob<T>): QueueJob<T> | Promise<QueueJob<T>>;
    /**
     * all processed queue is empty
     */
    await(): Promise<void>;
    /**
     * Creates a new QueueJob for passed entry and return a promise which that the job will be enqueued
     *
     * @param entry
     * @returns {QueueJob<T>}
     */
    push(entry: T): QueueJobRef<T>;
    running(): number;
    doingEnqueueing(): number;
    enqueued(): number;
    amount(): number;
    isPaused(): boolean;
    isRunning(): boolean;
    isIdle(): boolean;
    isOccupied(): boolean;
    pause(): Promise<boolean>;
    resume(): void;
    shutdown(doAwait?: boolean): Promise<void>;
}