import { Disposable } from './disposable';
import { MaybePromise } from './types';
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};
type Exclude<T, U> = T extends U ? never : T;
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
export interface CancellationToken {
    isCancellationRequested: boolean;
    onCancellationRequested: Event<void>;
}
export declare namespace CancellationToken {
    const None: CancellationToken;
    const Cancelled: CancellationToken;
}
export declare class CancellationError extends Error {
    constructor();
}
export declare class CancellationTokenSource {
    private _token;
    readonly token: CancellationToken;
    cancel(): void;
    dispose(): void;
}
export declare function cancelled(): Error;
export declare function isCancelled(err: Error | undefined): boolean;
export declare function checkCancelled(token?: CancellationToken): void;
/**
 * Represents a typed event.
 */
export interface Event<T> {
    /**
     * @param listener The listener function will be call when the event happens.
     * @param thisArgs The 'this' which will be used when calling the event listener.
     * @param disposables An array to which a {{IDisposable}} will be added.
     * @return a disposable to remove the listener again.
     */
    (listener: (e: T) => any, thisArgs?: any, disposables?: {
        push(disposable: Disposable): void;
    }): Disposable;
}
export declare namespace Event {
    function getMaxListeners(event: Event<unknown>): number;
    function setMaxListeners<N extends number>(event: Event<unknown>, maxListeners: N): N;
    function addMaxListeners(event: Event<unknown>, add: number): number;
    const None: Event<any>;
    /**
     * Given an event and a `map` function, returns another event which maps each element
     * through the mapping function.
     */
    function map<I, O>(event: Event<I>, mapFunc: (i: I) => O): Event<O>;
}
type Callback = (...args: any[]) => any;
export declare class CallbackList implements Iterable<Callback> {
    private _callbacks;
    private _contexts;
    readonly length: number;
    add(callback: Function, context?: any, bucket?: Disposable[]): void;
    remove(callback: Function, context?: any): void;
    [Symbol.iterator](): IterableIterator<(...args: any[]) => any>;
    invoke(...args: any[]): any[];
    isEmpty(): boolean;
    dispose(): void;
}
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);
    /**
     * For the public to allow to subscribe
     * to events from this Emitter
     */
    readonly 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>;
}
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>;
}
export {};