interface IDisposable {
    dispose(): void;
}
declare function isDisposable<E extends object>(thing: E): thing is E & IDisposable;
declare function dispose<T extends IDisposable>(disposable: T): T;
declare function dispose<T extends IDisposable>(disposable: T | undefined): T | undefined;
declare function dispose<T extends IDisposable>(disposables: Array<T>): Array<T>;
declare function dispose<T extends IDisposable>(disposables: ReadonlyArray<T>): ReadonlyArray<T>;
declare function combinedDisposable(...disposables: IDisposable[]): IDisposable;
declare function toDisposable(fn: () => void): IDisposable;
declare class DisposableStore implements IDisposable {
    static DISABLE_DISPOSED_WARNING: boolean;
    private _toDispose;
    private _isDisposed;
    /**
     * Dispose of all registered disposables and mark this object as disposed.
     *
     * Any future disposables added to this object will be disposed of on `add`.
     */
    dispose(): void;
    /**
     * Dispose of all registered disposables but do not mark this object as disposed.
     */
    clear(): void;
    add<T extends IDisposable>(t: T): T;
}
declare abstract class Disposable implements IDisposable {
    static readonly None: Readonly<IDisposable>;
    private readonly _store;
    constructor();
    dispose(): void;
    protected _register<T extends IDisposable>(t: T): T;
} /**
 * Manages the lifecycle of a disposable value that may be changed.
 *
 * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
 * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
 */
/**
 * Manages the lifecycle of a disposable value that may be changed.
 *
 * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
 * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
 */
declare class MutableDisposable<T extends IDisposable> implements IDisposable {
    private _value?;
    private _isDisposed;
    constructor();
    get value(): T | undefined;
    set value(value: T | undefined);
    clear(): void;
    dispose(): void;
}
interface IReference<T> extends IDisposable {
    readonly object: T;
}
declare abstract class ReferenceCollection<T> {
    private readonly references;
    acquire(key: string): IReference<T>;
    protected abstract createReferencedObject(key: string): T;
    protected abstract destroyReferencedObject(key: string, object: T): void;
}
declare class ImmortalReference<T> implements IReference<T> {
    object: T;
    constructor(object: T);
    dispose(): void;
}
declare namespace CancellationToken$0 {
    function isCancellationToken(thing: any): thing is CancellationToken$0;
    const None: CancellationToken$0;
    const Cancelled: CancellationToken$0;
}
declare class CancellationTokenSource {
    private _token?;
    private _parentListener?;
    constructor(parent?: CancellationToken$0);
    get token(): CancellationToken$0;
    cancel(): void;
    dispose(cancel?: boolean): void;
}
/*---------------------------------------------------------------------------------------------
*  Copyright (c) Microsoft Corporation. All rights reserved.
*  Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
interface IteratorDefinedResult<T> {
    readonly done: false;
    readonly value: T;
}
interface IteratorUndefinedResult {
    readonly done: true;
    readonly value: undefined;
}
type IteratorResult<T> = IteratorDefinedResult<T> | IteratorUndefinedResult;
interface NativeIteratorYieldResult<TYield> {
    done?: false;
    value: TYield;
}
interface NativeIteratorReturnResult<TReturn> {
    done: true;
    value: TReturn;
}
type NativeIteratorResult<T, TReturn = any> = NativeIteratorYieldResult<T> | NativeIteratorReturnResult<TReturn>;
interface NativeIterator<T> {
    next(): NativeIteratorResult<T>;
}
declare module Iterator$0 {
    function empty<T>(): Iterator$0<T>;
    function single<T>(value: T): Iterator$0<T>;
    function fromArray<T>(array: ReadonlyArray<T>, index?: number, length?: number): Iterator$0<T>;
    function fromNativeIterator<T>(it: NativeIterator<T>): Iterator$0<T>;
    function from<T>(elements: Iterator$0<T> | T[] | undefined): Iterator$0<T>;
    function map<T, R>(iterator: Iterator$0<T>, fn: (t: T) => R): Iterator$0<R>;
    function filter<T>(iterator: Iterator$0<T>, fn: (t: T) => boolean): Iterator$0<T>;
    function forEach<T>(iterator: Iterator$0<T>, fn: (t: T) => void): void;
    function collect<T>(iterator: Iterator$0<T>, atMost?: number): T[];
    function concat<T>(...iterators: Iterator$0<T>[]): Iterator$0<T>;
    function chain<T>(iterator: Iterator$0<T>): ChainableIterator<T>;
}
declare class ChainableIterator<T> implements Iterator$0<T> {
    private it;
    constructor(it: Iterator$0<T>);
    next(): IteratorResult<T>;
    map<R>(fn: (t: T) => R): ChainableIterator<R>;
    filter(fn: (t: T) => boolean): ChainableIterator<T>;
}
declare class LinkedList<E> {
    private _first;
    private _last;
    private _size;
    get size(): number;
    isEmpty(): boolean;
    clear(): void;
    unshift(element: E): () => void;
    push(element: E): () => void;
    private _insert;
    shift(): E | undefined;
    pop(): E | undefined;
    private _remove;
    iterator(): Iterator$0<E>;
    toArray(): E[];
}
declare namespace Event$0 {
    const None: Event$0<any>;
    /**
     * Given an event, returns another event which only fires once.
     */
    function once<T>(event: Event$0<T>): Event$0<T>; /**
     * Given an event and a `map` function, returns another event which maps each element
     * through the mapping function.
     */
    /**
     * Given an event and a `map` function, returns another event which maps each element
     * through the mapping function.
     */
    function map<I, O>(event: Event$0<I>, map: (i: I) => O): Event$0<O>; /**
     * Given an event and an `each` function, returns another identical event and calls
     * the `each` function per each element.
     */
    /**
     * Given an event and an `each` function, returns another identical event and calls
     * the `each` function per each element.
     */
    function forEach<I>(event: Event$0<I>, each: (i: I) => void): Event$0<I>; /**
     * Given an event and a `filter` function, returns another event which emits those
     * elements for which the `filter` function returns `true`.
     */
    /**
     * Given an event and a `filter` function, returns another event which emits those
     * elements for which the `filter` function returns `true`.
     */
    function filter<T>(event: Event$0<T>, filter: (e: T) => boolean): Event$0<T>;
    function filter<T, R>(event: Event$0<T | R>, filter: (e: T | R) => e is R): Event$0<R>;
    /**
     * Given an event, returns the same event but typed as `Event<void>`.
     */
    function signal<T>(event: Event$0<T>): Event$0<void>; /**
     * Given a collection of events, returns a single event which emits
     * whenever any of the provided events emit.
     */
    /**
     * Given a collection of events, returns a single event which emits
     * whenever any of the provided events emit.
     */
    function any<T>(...events: Event$0<T>[]): Event$0<T>;
    function any(...events: Event$0<any>[]): Event$0<void>;
    /**
     * Given an event and a `merge` function, returns another event which maps each element
     * and the cumulative result through the `merge` function. Similar to `map`, but with memory.
     */
    function reduce<I, O>(event: Event$0<I>, merge: (last: O | undefined, event: I) => O, initial?: O): Event$0<O>; /**
     * Given a chain of event processing functions (filter, map, etc), each
     * function will be invoked per event & per listener. Snapshotting an event
     * chain allows each function to be invoked just once per event.
     */
    /**
     * Given a chain of event processing functions (filter, map, etc), each
     * function will be invoked per event & per listener. Snapshotting an event
     * chain allows each function to be invoked just once per event.
     */
    function snapshot<T>(event: Event$0<T>): Event$0<T>; /**
     * Debounces the provided event, given a `merge` function.
     *
     * @param event The input event.
     * @param merge The reducing function.
     * @param delay The debouncing delay in millis.
     * @param leading Whether the event should fire in the leading phase of the timeout.
     * @param leakWarningThreshold The leak warning threshold override.
     */
    /**
     * Debounces the provided event, given a `merge` function.
     *
     * @param event The input event.
     * @param merge The reducing function.
     * @param delay The debouncing delay in millis.
     * @param leading Whether the event should fire in the leading phase of the timeout.
     * @param leakWarningThreshold The leak warning threshold override.
     */
    function debounce<T>(event: Event$0<T>, merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number): Event$0<T>;
    function debounce<I, O>(event: Event$0<I>, merge: (last: O | undefined, event: I) => O, delay?: number, leading?: boolean, leakWarningThreshold?: number): Event$0<O>;
    /**
     * Given an event, it returns another event which fires only once and as soon as
     * the input event emits. The event data is the number of millis it took for the
     * event to fire.
     */
    function stopwatch<T>(event: Event$0<T>): Event$0<number>; /**
     * Given an event, it returns another event which fires only when the event
     * element changes.
     */
    /**
     * Given an event, it returns another event which fires only when the event
     * element changes.
     */
    function latch<T>(event: Event$0<T>): Event$0<T>; /**
     * Buffers the provided event until a first listener comes
     * along, at which point fire all the events at once and
     * pipe the event from then on.
     *
     * ```typescript
     * const emitter = new Emitter<number>();
     * const event = emitter.event;
     * const bufferedEvent = buffer(event);
     *
     * emitter.fire(1);
     * emitter.fire(2);
     * emitter.fire(3);
     * // nothing...
     *
     * const listener = bufferedEvent(num => console.log(num));
     * // 1, 2, 3
     *
     * emitter.fire(4);
     * // 4
     * ```
     */
    /**
     * Buffers the provided event until a first listener comes
     * along, at which point fire all the events at once and
     * pipe the event from then on.
     *
     * ```typescript
     * const emitter = new Emitter<number>();
     * const event = emitter.event;
     * const bufferedEvent = buffer(event);
     *
     * emitter.fire(1);
     * emitter.fire(2);
     * emitter.fire(3);
     * // nothing...
     *
     * const listener = bufferedEvent(num => console.log(num));
     * // 1, 2, 3
     *
     * emitter.fire(4);
     * // 4
     * ```
     */
    function buffer<T>(event: Event$0<T>, nextTick?: boolean, _buffer?: T[]): Event$0<T>;
    interface IChainableEvent<T> {
        event: Event$0<T>;
        map<O>(fn: (i: T) => O): IChainableEvent<O>;
        forEach(fn: (i: T) => void): IChainableEvent<T>;
        filter(fn: (e: T) => boolean): IChainableEvent<T>;
        filter<R>(fn: (e: T | R) => e is R): IChainableEvent<R>;
        reduce<R>(merge: (last: R | undefined, event: T) => R, initial?: R): IChainableEvent<R>;
        latch(): IChainableEvent<T>;
        debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
        on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
        once(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
    }
    function chain<T>(event: Event$0<T>): IChainableEvent<T>;
    interface NodeEventEmitter {
        on(event: string | symbol, listener: Function): this;
        removeListener(event: string | symbol, listener: Function): this;
    }
    function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map?: (...args: any[]) => T): Event$0<T>;
    interface DOMEventEmitter {
        addEventListener(event: string | symbol, listener: Function): void;
        removeEventListener(event: string | symbol, listener: Function): void;
    }
    function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event$0<T>;
    function fromPromise<T = any>(promise: Promise<T>): Event$0<undefined>;
    function toPromise<T>(event: Event$0<T>): Promise<T>;
}
type Listener<T> = [(e: T) => void, any] | ((e: T) => void);
interface EmitterOptions {
    onFirstListenerAdd?: Function;
    onFirstListenerDidAdd?: Function;
    onListenerDidAdd?: Function;
    onLastListenerRemove?: Function;
    leakWarningThreshold?: number;
}
declare function setGlobalLeakWarningThreshold(n: number): IDisposable;
/**
 * The Emitter can be used to expose an Event to the public
 * to fire it from the insides.
 * Sample:
 class Document {
 
 private readonly _onDidChange = new Emitter<(value:string)=>any>();
 
 public onDidChange = this._onDidChange.event;
 
 // getter-style
 // get onDidChange(): Event<(value:string)=>any> {
 // 	return this._onDidChange.event;
 // }
 
 private _doIt() {
 //...
 this._onDidChange.fire(value);
 }
 }
 */
declare class Emitter<T> {
    private static readonly _noop;
    private readonly _options?;
    private readonly _leakageMon?;
    private _disposed;
    private _event?;
    private _deliveryQueue?;
    protected _listeners?: LinkedList<Listener<T>>;
    constructor(options?: EmitterOptions);
    /**
     * For the public to allow to subscribe
     * to events from this Emitter
     */
    get event(): Event$0<T>; /**
     * To be kept private to fire an event to
     * subscribers
     */
    /**
     * To be kept private to fire an event to
     * subscribers
     */
    fire(event: T): void;
    dispose(): void;
}
declare class PauseableEmitter<T> extends Emitter<T> {
    private _isPaused;
    private _eventQueue;
    private _mergeFn?;
    constructor(options?: EmitterOptions & {
        merge?: (input: T[]) => T;
    });
    pause(): void;
    resume(): void;
    fire(event: T): void;
}
interface IWaitUntil {
    waitUntil(thenable: Promise<any>): void;
}
declare class AsyncEmitter<T extends IWaitUntil> extends Emitter<T> {
    private _asyncDeliveryQueue?;
    fireAsync(data: Omit<T, "waitUntil">, token: CancellationToken$0, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void>;
}
declare class EventMultiplexer<T> implements IDisposable {
    private readonly emitter;
    private hasListeners;
    private events;
    constructor();
    get event(): Event$0<T>;
    add(event: Event$0<T>): IDisposable;
    private onFirstListenerAdd;
    private onLastListenerRemove;
    private hook;
    private unhook;
    dispose(): void;
} /**
 * The EventBufferer is useful in situations in which you want
 * to delay firing your events during some code.
 * You can wrap that code and be sure that the event will not
 * be fired during that wrap.
 *
 * ```
 * const emitter: Emitter;
 * const delayer = new EventDelayer();
 * const delayedEvent = delayer.wrapEvent(emitter.event);
 *
 * delayedEvent(console.log);
 *
 * delayer.bufferEvents(() => {
 *   emitter.fire(); // event will not be fired yet
 * });
 *
 * // event will only be fired at this point
 * ```
 */
/**
 * The EventBufferer is useful in situations in which you want
 * to delay firing your events during some code.
 * You can wrap that code and be sure that the event will not
 * be fired during that wrap.
 *
 * ```
 * const emitter: Emitter;
 * const delayer = new EventDelayer();
 * const delayedEvent = delayer.wrapEvent(emitter.event);
 *
 * delayedEvent(console.log);
 *
 * delayer.bufferEvents(() => {
 *   emitter.fire(); // event will not be fired yet
 * });
 *
 * // event will only be fired at this point
 * ```
 */
/**
 * The EventBufferer is useful in situations in which you want
 * to delay firing your events during some code.
 * You can wrap that code and be sure that the event will not
 * be fired during that wrap.
 *
 * ```
 * const emitter: Emitter;
 * const delayer = new EventDelayer();
 * const delayedEvent = delayer.wrapEvent(emitter.event);
 *
 * delayedEvent(console.log);
 *
 * delayer.bufferEvents(() => {
 *   emitter.fire(); // event will not be fired yet
 * });
 *
 * // event will only be fired at this point
 * ```
 */
declare class EventBufferer {
    private buffers;
    wrapEvent<T>(event: Event$0<T>): Event$0<T>;
    bufferEvents<R = void>(fn: () => R): R;
} /**
 * A Relay is an event forwarder which functions as a replugabble event pipe.
 * Once created, you can connect an input event to it and it will simply forward
 * events from that input event through its own `event` property. The `input`
 * can be changed at any point in time.
 */
/**
 * A Relay is an event forwarder which functions as a replugabble event pipe.
 * Once created, you can connect an input event to it and it will simply forward
 * events from that input event through its own `event` property. The `input`
 * can be changed at any point in time.
 */
/**
 * A Relay is an event forwarder which functions as a replugabble event pipe.
 * Once created, you can connect an input event to it and it will simply forward
 * events from that input event through its own `event` property. The `input`
 * can be changed at any point in time.
 */
declare class Relay<T> implements IDisposable {
    private listening;
    private inputEvent;
    private inputEventListener;
    private readonly emitter;
    readonly event: Event$0<T>;
    set input(event: Event$0<T>);
    dispose(): void;
}
declare function isThenable<T>(obj: any): obj is Promise<T>;
interface CancelablePromise<T> extends Promise<T> {
    cancel(): void;
}
declare function createCancelablePromise<T>(callback: (token: CancellationToken$0) => Promise<T>): CancelablePromise<T>;
declare function raceCancellation<T>(promise: Promise<T>, token: CancellationToken$0): Promise<T | undefined>;
declare function raceCancellation<T>(promise: Promise<T>, token: CancellationToken$0, defaultValue: T): Promise<T>;
declare function asPromise<T>(callback: () => T | Thenable<T>): Promise<T>;
interface ITask<T> {
    (): T;
} /**
 * A helper to prevent accumulation of sequential async tasks.
 *
 * Imagine a mail man with the sole task of delivering letters. As soon as
 * a letter submitted for delivery, he drives to the destination, delivers it
 * and returns to his base. Imagine that during the trip, N more letters were submitted.
 * When the mail man returns, he picks those N letters and delivers them all in a
 * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.
 *
 * The throttler implements this via the queue() method, by providing it a task
 * factory. Following the example:
 *
 * 		const throttler = new Throttler();
 * 		const letters = [];
 *
 * 		function deliver() {
 * 			const lettersToDeliver = letters;
 * 			letters = [];
 * 			return makeTheTrip(lettersToDeliver);
 * 		}
 *
 * 		function onLetterReceived(l) {
 * 			letters.push(l);
 * 			throttler.queue(deliver);
 * 		}
 */
/**
 * A helper to prevent accumulation of sequential async tasks.
 *
 * Imagine a mail man with the sole task of delivering letters. As soon as
 * a letter submitted for delivery, he drives to the destination, delivers it
 * and returns to his base. Imagine that during the trip, N more letters were submitted.
 * When the mail man returns, he picks those N letters and delivers them all in a
 * single trip. Even though N+1 submissions occurred, only 2 deliveries were made.
 *
 * The throttler implements this via the queue() method, by providing it a task
 * factory. Following the example:
 *
 * 		const throttler = new Throttler();
 * 		const letters = [];
 *
 * 		function deliver() {
 * 			const lettersToDeliver = letters;
 * 			letters = [];
 * 			return makeTheTrip(lettersToDeliver);
 * 		}
 *
 * 		function onLetterReceived(l) {
 * 			letters.push(l);
 * 			throttler.queue(deliver);
 * 		}
 */
declare class Throttler {
    private activePromise;
    private queuedPromise;
    private queuedPromiseFactory;
    constructor();
    queue<T>(promiseFactory: ITask<Promise<T>>): Promise<T>;
}
declare class Sequencer {
    private current;
    queue<T>(promiseTask: ITask<Promise<T>>): Promise<T>;
} /**
 * A helper to delay execution of a task that is being requested often.
 *
 * Following the throttler, now imagine the mail man wants to optimize the number of
 * trips proactively. The trip itself can be long, so he decides not to make the trip
 * as soon as a letter is submitted. Instead he waits a while, in case more
 * letters are submitted. After said waiting period, if no letters were submitted, he
 * decides to make the trip. Imagine that N more letters were submitted after the first
 * one, all within a short period of time between each other. Even though N+1
 * submissions occurred, only 1 delivery was made.
 *
 * The delayer offers this behavior via the trigger() method, into which both the task
 * to be executed and the waiting period (delay) must be passed in as arguments. Following
 * the example:
 *
 * 		const delayer = new Delayer(WAITING_PERIOD);
 * 		const letters = [];
 *
 * 		function letterReceived(l) {
 * 			letters.push(l);
 * 			delayer.trigger(() => { return makeTheTrip(); });
 * 		}
 */
/**
 * A helper to delay execution of a task that is being requested often.
 *
 * Following the throttler, now imagine the mail man wants to optimize the number of
 * trips proactively. The trip itself can be long, so he decides not to make the trip
 * as soon as a letter is submitted. Instead he waits a while, in case more
 * letters are submitted. After said waiting period, if no letters were submitted, he
 * decides to make the trip. Imagine that N more letters were submitted after the first
 * one, all within a short period of time between each other. Even though N+1
 * submissions occurred, only 1 delivery was made.
 *
 * The delayer offers this behavior via the trigger() method, into which both the task
 * to be executed and the waiting period (delay) must be passed in as arguments. Following
 * the example:
 *
 * 		const delayer = new Delayer(WAITING_PERIOD);
 * 		const letters = [];
 *
 * 		function letterReceived(l) {
 * 			letters.push(l);
 * 			delayer.trigger(() => { return makeTheTrip(); });
 * 		}
 */
declare class Delayer<T> implements IDisposable {
    defaultDelay: number;
    private timeout;
    private completionPromise;
    private doResolve;
    private doReject;
    private task;
    constructor(defaultDelay: number);
    trigger(task: ITask<T | Promise<T>>, delay?: number): Promise<T>;
    isTriggered(): boolean;
    cancel(): void;
    private cancelTimeout;
    dispose(): void;
} /**
 * A helper to delay execution of a task that is being requested often, while
 * preventing accumulation of consecutive executions, while the task runs.
 *
 * The mail man is clever and waits for a certain amount of time, before going
 * out to deliver letters. While the mail man is going out, more letters arrive
 * and can only be delivered once he is back. Once he is back the mail man will
 * do one more trip to deliver the letters that have accumulated while he was out.
 */
/**
 * A helper to delay execution of a task that is being requested often, while
 * preventing accumulation of consecutive executions, while the task runs.
 *
 * The mail man is clever and waits for a certain amount of time, before going
 * out to deliver letters. While the mail man is going out, more letters arrive
 * and can only be delivered once he is back. Once he is back the mail man will
 * do one more trip to deliver the letters that have accumulated while he was out.
 */
declare class ThrottledDelayer<T> {
    private delayer;
    private throttler;
    constructor(defaultDelay: number);
    trigger(promiseFactory: ITask<Promise<T>>, delay?: number): Promise<T>;
    isTriggered(): boolean;
    cancel(): void;
    dispose(): void;
} /**
 * A barrier that is initially closed and then becomes opened permanently.
 */
/**
 * A barrier that is initially closed and then becomes opened permanently.
 */
declare class Barrier {
    private _isOpen;
    private _promise;
    private _completePromise;
    constructor();
    isOpen(): boolean;
    open(): void;
    wait(): Promise<boolean>;
}
declare function timeout(millis: number): CancelablePromise<void>;
declare function timeout(millis: number, token: CancellationToken$0): Promise<void>;
declare function disposableTimeout(handler: () => void, timeout?: number): IDisposable;
declare function ignoreErrors<T>(promise: Promise<T>): Promise<T | undefined>; /**
 * Runs the provided list of promise factories in sequential order. The returned
 * promise will complete to an array of results from each promise.
 */
/**
 * Runs the provided list of promise factories in sequential order. The returned
 * promise will complete to an array of results from each promise.
 */
declare function sequence<T>(promiseFactories: ITask<Promise<T>>[]): Promise<T[]>;
declare function first<T>(promiseFactories: ITask<Promise<T>>[], shouldStop?: (t: T) => boolean, defaultValue?: T | null): Promise<T | null>;
/**
 * A helper to queue N promises and run them all with a max degree of parallelism. The helper
 * ensures that at any time no more than M promises are running at the same time.
 */
declare class Limiter<T> {
    private _size;
    private runningPromises;
    private maxDegreeOfParalellism;
    private outstandingPromises;
    private readonly _onFinished;
    constructor(maxDegreeOfParalellism: number);
    get onFinished(): Event$0<void>;
    get size(): number;
    queue(factory: ITask<Promise<T>>): Promise<T>;
    private consume;
    private consumed;
    dispose(): void;
} /**
 * A queue is handles one promise at a time and guarantees that at any time only one promise is executing.
 */
/**
 * A queue is handles one promise at a time and guarantees that at any time only one promise is executing.
 */
declare class Queue<T> extends Limiter<T> {
    constructor();
} /**
 * A helper to organize queues per resource. The ResourceQueue makes sure to manage queues per resource
 * by disposing them once the queue is empty.
 */
/**
 * A helper to organize queues per resource. The ResourceQueue makes sure to manage queues per resource
 * by disposing them once the queue is empty.
 */
/**
 * A helper to organize queues per resource. The ResourceQueue makes sure to manage queues per resource
 * by disposing them once the queue is empty.
 */
declare function retry<T>(task: ITask<Promise<T>>, delay: number, retries: number): Promise<T>; //#region Task Sequentializer
//#region Task Sequentializer
//#region Task Sequentializer
//#region Task Sequentializer
export { isThenable, CancelablePromise, createCancelablePromise, raceCancellation, asPromise, Throttler, Sequencer, Delayer, ThrottledDelayer, Barrier, timeout, disposableTimeout, ignoreErrors, sequence, first, Limiter, Queue, retry, CancellationToken$0 as CancellationToken, CancellationTokenSource, Event$0 as Event, EmitterOptions, setGlobalLeakWarningThreshold, Emitter, PauseableEmitter, IWaitUntil, AsyncEmitter, EventMultiplexer, EventBufferer, Relay, IDisposable, isDisposable, dispose, combinedDisposable, toDisposable, DisposableStore, Disposable, MutableDisposable, IReference, ReferenceCollection, ImmortalReference };