/**
 * A simple FIFO queue, delivering items in order.
 *
 * Paremeters:
 * `T`: Type that is pushed onto the stack.
 * `R`: Type that the passed `callback` maps to.
 */
export default class SimpleQueue<T, R = void> {
    private readonly worker;
    private readonly callback;
    private readonly done?;
    private readonly concurrent;
    private readonly queue;
    /** Stores elements that are finished. */
    private stack;
    private working;
    private lastStarted;
    private finished;
    paused: boolean;
    /**
     * Creates a new FIFO queue.
     * @param worker Method to call for each child. Args:
     * @param callback Method to call when an element was processed.
     * @param done Method to call once the stack is cleared.
     * @param concurrent Number of elements to process in parallel. Defaults to 20.
     */
    constructor(worker: (element: T, callback: (error: Error | null, result: R) => void) => void, callback: (error: Error | null, result: R, element: T) => void, done?: (() => void) | undefined, concurrent?: number);
    /**
     * Adds an element to the queue.
     * @param properties Element to enqueue for processing.
     */
    push(properties: T): void;
    /**
     * Clears the queue (can't stop running processes).
     */
    abort(): void;
    /**
     * Pause the queue execution.
     * Will not stop already in-flight items.
     */
    pause(): void;
    /**
     * Resume the queue execution,
     * and catch up with remaining items.
     */
    resume(): void;
    private checkStack;
    private scan;
}
//# sourceMappingURL=index.d.ts.map