import { markAsSingleton, setDisposableTracker } from './tracker';
export { markAsSingleton, setDisposableTracker };
export declare class MultiDisposeError extends Error {
    readonly errors: any[];
    constructor(errors: any[]);
}
export interface Disposable {
    dispose(): void;
}
export declare function isDisposable<E extends object>(thing: E): thing is E & Disposable;
export declare function dispose<T extends Disposable>(disposable: T): T;
export declare function dispose<T extends Disposable>(disposable: T | undefined): T | undefined;
export declare function dispose<T extends Disposable, A extends IterableIterator<T> = IterableIterator<T>>(disposables: IterableIterator<T>): A;
export declare function dispose<T extends Disposable>(disposables: Array<T>): Array<T>;
export declare function dispose<T extends Disposable>(disposables: ReadonlyArray<T>): ReadonlyArray<T>;
export declare function combinedDisposable(...disposables: Disposable[]): Disposable;
export declare function toDisposable(fn: () => void): Disposable;
export declare class DisposableStore implements Disposable {
    static DISABLE_DISPOSED_WARNING: boolean;
    private _toDispose;
    constructor();
    private _isDisposed;
    /**
     * Returns `true` if this object has been disposed
     */
    get isDisposed(): boolean;
    /**
     * 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 Disposable>(o: T): T;
    add(o: Disposable['dispose']): Disposable;
}
export declare namespace Disposable {
    const None: Readonly<Disposable>;
}
export declare abstract class DisposableObject implements Disposable {
    protected readonly _store: DisposableStore;
    protected constructor();
    dispose(): void;
    protected _register<T extends Disposable>(o: T): T;
}