import { Event, Callback, CallbackList } from './event';
import { MaybePromise } from './prioritizeable';
export interface EmitterOptions {
    onFirstListenerAdd?: Function;
    onLastListenerRemove?: Function;
}
export declare class Emitter<T = any> {
    private _options?;
    private static LEAK_WARNING_THRESHHOLD;
    private static _noop;
    private _event;
    protected _callbacks: CallbackList | undefined;
    private _disposed;
    private _leakingStacks;
    private _leakWarnCountdown;
    constructor(_options?: EmitterOptions | undefined);
    /**
     * For the public to allow to subscribe
     * to events from this Emitter
     */
    get event(): Event<T>;
    protected checkMaxListeners(maxListeners: number): (() => void) | undefined;
    protected pushLeakingStack(): () => void;
    protected popLeakingStack(stack: string): void;
    /**
     * To be kept private to fire an event to
     * subscribers
     */
    fire(event: T): any;
    /**
     * Process each listener one by one.
     * Return `false` to stop iterating over the listeners, `true` to continue.
     */
    sequence(processor: (listener: (e: T) => any) => MaybePromise<boolean>): Promise<void>;
    dispose(): void;
}
export interface WaitUntilEvent {
    /**
     * Allows to pause the event loop until the provided thenable resolved.
     *
     * *Note:* It can only be called during event dispatch and not in an asynchronous manner
     *
     * @param thenable A thenable that delays execution.
     */
    waitUntil(thenable: Promise<any>): void;
}
export declare namespace WaitUntilEvent {
    /**
     * Fire all listeners in the same tick.
     *
     * Use `AsyncEmitter.fire` to fire listeners async one after another.
     */
    function fire<T extends WaitUntilEvent>(emitter: Emitter<T>, event: Omit<T, 'waitUntil'>, timeout?: number | undefined): Promise<void>;
}
import { CancellationToken } from './cancellation';
export declare class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
    protected deliveryQueue: Promise<void> | undefined;
    /**
     * Fire listeners async one after another.
     */
    fire(event: Omit<T, 'waitUntil'>, token?: CancellationToken, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void>;
    protected deliver(listeners: Callback[], event: Omit<T, 'waitUntil'>, token: CancellationToken, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void>;
}
//# sourceMappingURL=emitter.d.ts.map