/**
 * @internal
 */
export declare class Queue<T> {
    private head;
    private tail;
    size: number;
    constructor();
    enqueue(value: T): void;
    dequeue(): T | undefined;
    clear(): void;
    [Symbol.iterator](): Generator<T, void, unknown>;
}
type LimitFunctionCallSignature = {
    /**
     * @param fn - Promise-returning/async function.
     * @param arguments - Any arguments to pass through to `fn`. Support for passing arguments on to the `fn` is provided in order to be able to avoid creating unnecessary closures. You probably don't need this optimization unless you're pushing a lot of functions.
     * @returns The promise returned by calling `fn(...arguments)`.
     */
    <Arguments extends unknown[], ReturnType>(fn: (...arguments_: Arguments) => PromiseLike<ReturnType> | ReturnType, ...arguments_: Arguments): Promise<ReturnType>;
};
type LimitFunction = {
    /**
     * The number of promises that are currently running.
     */
    readonly activeCount: number;
    /**
     * The number of promises that are waiting to run (i.e. their internal `fn` was not called yet).
     */
    readonly pendingCount: number;
    /**
     * Discard pending promises that are waiting to run.
     *
     * This might be useful if you want to teardown the queue at the end of your program's lifecycle or discard any function calls referencing an intermediary state of your app.
     *
     * Note: This does not cancel promises that are already running.
     */
    clearQueue: () => void;
} & LimitFunctionCallSignature;
/**
 * Run multiple promise-returning & async functions with limited concurrency.
 * @param concurrency
 * @internal
 */
export declare function pLimit(concurrency: number): LimitFunction;
export {};
//# sourceMappingURL=p-limit.d.ts.map