import { type Callback } from "./function.js";
import { type Nullish } from "./null.js";
/**
 * Safely dispose one or more synchronous `Disposable` values.
 * - If one disposal fails, the rest continue.
 *
 * @param values Zero or more disposables or callbacks.
 * - Callbacks are allowed because in real usage `[Symbol.asyncDispose]` may have other things to clean up too and it's neater to throw a single aggregate error.
 * - `Nullish` values are skipped (for convenience).
 *
 * @throws {Errors} Error that aggregates all the disposal errors.
 */
export declare function dispose(...values: Nullish<Disposable | Callback>[]): void;
/**
 * Safely dispose one or more `AsyncDisposable` or `Disposable` values in parallel — all are disposed even if some throw, errors are rethrown at the end.
 *
 * @param values Zero or more (possibly async) disposables, promises, or callbacks.
 * - Note that spec says `[Symbol.dispose]` is called on an object if `[Symbol.asyncDispose]` is not found.
 * - `Promises` and `Callback` are allowed because in real usage `[Symbol.asyncDispose]` may have other things to clean up too and it's neater to throw a single aggregate error.
 * - `Nullish` values are skipped (for convenience).
 *
 * @throws {Errors} Error that aggregates all the disposal errors.
 *
 * @todo Potentially rewrite this to use `AsyncDisposableStack` internally.
 */
export declare function awaitDispose(...values: Nullish<AsyncDisposable | Disposable | Callback | Promise<unknown>>[]): Promise<void>;
/** Is an unknown value a disposable object? */
export declare function isDisposable(v: unknown): v is Disposable;
/** Is an unknown value an async disposable object? */
export declare function isAsyncDisposable(v: unknown): v is AsyncDisposable;
/**
 * Version of `Map` that has disposable values.
 * - Old values are disposed when they're set to a new value.
 * - Values are disposed when they're deleted from the map.
 * - Values are disposed when all items are cleared.
 * - All items are cleared and their values are disposed when this map itself is disposed.
 */
export declare class DisposableMap<K, T extends Disposable> extends Map<K, T> implements Disposable {
    set(key: K, value: T): this;
    delete(key: K): boolean;
    clear(): void;
    [Symbol.dispose](): void;
}
/**
 * Version of `Set` that has disposable items.
 * - Values are disposed when they're deleted from the map.
 * - Values are disposed when all items are cleared.
 * - All items are cleared (and disposed) when this map itself is disposed.
 */
export declare class DisposableSet<T extends Disposable> extends Set<T> implements Disposable {
    delete(item: T): boolean;
    clear(): void;
    [Symbol.dispose](): void;
}