import type { MaybeNamed } from '../../debugging/object-with-name.js';
import { Emitter } from '../event/event.js';
import type { EventRegister } from '../event/type.js';
export declare enum DuplicateDisposeAction {
    Disable = 0,
    Warning = 1,
    Allow = 2
}
/** @public */
export interface IDisposableEvents extends IBackReferenceDisposableEvent {
    readonly onDisposeError: EventRegister<Error>;
    readonly onPostDispose: EventRegister<void>;
    readonly disposed: boolean;
}
export interface IBackReferenceDisposableEvent {
    readonly onBeforeDispose: EventRegister<void>;
}
/** @public */
export interface IDisposable extends MaybeNamed {
    dispose(): void;
}
/** @public */
export interface IAsyncDisposable extends MaybeNamed {
    dispose(): void | Promise<void>;
}
type _Type<Async extends boolean> = Async extends true ? IAsyncDisposable : IDisposable;
type _RType<Async extends boolean> = Async extends true ? Promise<void> : void;
/**
 * 增强型Disposable
 */
export declare abstract class AbstractEnhancedDisposable<Async extends boolean> implements IDisposableEvents {
    protected readonly _onDisposeError: Emitter<Error>;
    readonly onDisposeError: EventRegister<Error>;
    protected readonly _onBeforeDispose: Emitter<void>;
    readonly onBeforeDispose: EventRegister<void>;
    protected readonly _onPostDispose: Emitter<void>;
    readonly onPostDispose: EventRegister<void>;
    /** settings */
    protected readonly duplicateDispose: DuplicateDisposeAction;
    /**
     * the "DisposableStack"
     */
    protected readonly _disposables: _Type<Async>[];
    /** for debug */
    readonly displayName?: string;
    /** @ts-ignore 禁止不使用debug库的项目报错 */
    protected readonly _logger: import('debug').Debugger;
    constructor(displayName?: string);
    /**
     * @throws if already disposed
     */
    assertNotDisposed(): void;
    /**
     * register a disposable object
     */
    _register<T extends _Type<Async>>(d: T): T;
    _register<T extends _Type<Async> & IBackReferenceDisposableEvent>(d: T, autoDereference?: boolean): T;
    _unregister(d: _Type<Async>): boolean;
    private __dispose_state;
    get disposed(): boolean;
    /**
     * 正在dispose中（已开始但未完成）
     */
    get disposing(): boolean;
    /**
     * 释放相关资源
     */
    dispose(): _RType<Async>;
    get [Symbol.toStringTag](): string;
    protected abstract _dispose(disposables: readonly _Type<Async>[]): _RType<Async>;
}
export declare function dumpDisposableStack(disposable: AbstractEnhancedDisposable<any>): void;
export {};
//# sourceMappingURL=disposable.d.ts.map