/// <reference types="node" />
import { EventEmitter } from 'events';
import { TaskObject } from './task-object';
export type TaskProcessor<T> = (task: TaskObject<T>) => void | Promise<void>;
export type AfterFinishProcessor = () => void | Promise<void>;
interface IQueuingItem<T> {
    queueId: number | null;
    task: T;
    processor: TaskProcessor<T>;
}
/**
 * Scarlet is a task queue that allows you to process tasks in parallel.
 */
export declare class Scarlet {
    #private;
    static TaskObject: typeof TaskObject;
    queueCount: number;
    processedCount: number;
    spouts: (IQueuingItem<any> | null)[];
    running: boolean[];
    queue: IQueuingItem<any>[];
    emitter: EventEmitter;
    afterFinishCount: number;
    afterFinishLoop: boolean;
    afterFinishProcessor: AfterFinishProcessor | undefined;
    /**
     * Create a new Scarlet instance.
     * @param {number} queueCount The number of queues to create.
     */
    constructor(queueCount?: number);
    /**
     * Get the number of processed tasks.
     * @return {number} The number of processed tasks.
     */
    numberOfProcessed(): number;
    /**
     * Reset the number of processed tasks.
     */
    resetNumberOfProcessed(): void;
    /**
     * Push a task into the queue.
     * @param {T} task The task to push into the queue.
     * @param {TaskProcessor<T>} processor The processor to run the task.
     */
    push<T>(task: T, processor: TaskProcessor<T>): void;
    /**
     * Mark a task as done.
     * @param {TaskObject<T>} taskObject The task object to mark as done.
     */
    taskDone<T>(taskObject: TaskObject<T>): void;
    /**
     * Set the after finish processor.
     * @param {number} count The number of tasks to process before calling the processor.
     * @param {AfterFinishProcessor} processor The processor to call after the tasks are processed.
     * @param {boolean} loop Whether to loop the after finish processor.
     */
    afterFinish(count: number, processor: AfterFinishProcessor, loop?: boolean): void;
    /**
     * Clear the after finish processor.
     */
    clearAfterFinish(): void;
}
export {};