import EventEmitter from 'node:events';
import EmittingPromise, { CancelablePromise, Executor, FinallyFn, FulfillmentFn, RejectionFn } from './emitting-promise.js';
type SemaphoreEvents = {
    released: [];
};
export type Semaphore = InstanceType<typeof SemaphoreImpl>;
declare class SemaphoreImpl extends EventEmitter<SemaphoreEvents> {
    #private;
    constructor(group: SemaphorePool, id: symbol);
    get id(): symbol;
    get released(): boolean;
    release(): Promise<void>;
}
type PendingSemaphoreEvents = {
    reserved: [Semaphore];
    error: [Error];
};
declare class PendingSemaphoreChain<Result> extends EmittingPromise<PendingSemaphoreEvents, Result> implements CancelablePromise<unknown> {
    #private;
    constructor(executor: Executor<Result>, parent?: SemaphorePromise);
    get pending(): boolean;
    then<TResult1 = Result, TResult2 = never>(onfulfilled?: FulfillmentFn<Result, TResult1>, onrejected?: RejectionFn<TResult2>): PendingSemaphoreChain<TResult1 | TResult2>;
    catch<TResult = never>(onrejected?: RejectionFn<TResult>): PendingSemaphoreChain<Result | TResult>;
    finally(onfinally?: FinallyFn): PendingSemaphoreChain<Result>;
    cancel(): any;
}
export type SemaphoreRequest = InstanceType<typeof PendingSemaphoreChain<Semaphore>>;
interface SemaphorePromise extends PendingSemaphoreChain<unknown> {
}
declare class PendingSemaphore extends PendingSemaphoreChain<Semaphore> {
    #private;
    constructor(timeoutMS?: number);
    resolve(semaphore: Semaphore): Promise<void>;
    cancel(): Promise<unknown>;
    reject(): Promise<unknown>;
}
type SemaphorePoolEvents = {
    requested: [PendingSemaphore];
    aborted: [PendingSemaphore, Error];
    reserved: [Semaphore, PendingSemaphore];
    released: [Semaphore];
};
export type SemaphorePoolConfig = {
    concurrency?: number;
    capacity?: number;
};
export interface SemaphorePool extends EventEmitter<SemaphorePoolEvents> {
    concurrency: number | undefined;
    capacity: number | undefined;
    reserved: number;
    queued: number;
    acquire(args?: {
        timeoutMS?: number;
        forOperation?: string;
    }): SemaphoreRequest;
    release(semaphore: Semaphore): void;
}
export declare class BasicSemaphorePool extends EventEmitter<SemaphorePoolEvents> implements SemaphorePool {
    #private;
    constructor(config?: SemaphorePoolConfig);
    get queued(): number;
    get reserved(): number;
    get concurrency(): number | undefined;
    set concurrency(concurrency: number | undefined);
    get capacity(): number | undefined;
    set capacity(capacity: number | undefined);
    acquire(args?: {
        timeoutMS?: number;
    }): PendingSemaphoreChain<Semaphore>;
    release(semaphore: Semaphore): void;
}
export {};