@akala/core/dist/esm/teardown-manager.d.ts

/**
 * Checks if an object is a Promise-like instance
 * @template T - The expected resolved value type
 * @param {T | PromiseLike<T>} o - The object to check
 * @returns {boolean} True if the object has a 'then' method, indicating it's Promise-like
 */
export declare function isPromiseLike<T>(o: T | PromiseLike<T>): o is PromiseLike<T>;
/**
 * Callback type for teardown subscriptions that returns true when unsubscribed
 */
export type Subscription = () => boolean;
export type AsyncSubscription = () => Promise<boolean>;
export declare function combineSubscriptions(...subs: (void | undefined | Subscription)[]): Subscription;
export declare function teardown(subscription: Subscription | AsyncSubscription, abort: AbortSignal): void;
export declare function combineAsyncSubscriptions(...subs: (void | undefined | Subscription | AsyncSubscription)[]): AsyncSubscription;
/**
 * Manages cleanup of subscriptions and disposable resources
 */
export declare class TeardownManager implements Disposable {
    /**
     * @param subscriptions - Optional initial array of teardown subscriptions
     */
    constructor(subscriptions?: Subscription[]);
    protected readonly subscriptions: Subscription[];
    /**
     * Cleans up all registered subscriptions (implements Disposable pattern)
     */
    [Symbol.dispose](): void;
    /**
     * Registers a teardown subscription or Disposable
     * @typeParam T - Subscription function or Disposable object
     * @param sub - Subscription callback or Disposable object to register
     * @returns The original subscription for chaining
     */
    teardown<T extends Subscription | Disposable | undefined | null>(sub: T): T;
}
/**
 * Manages cleanup of subscriptions and disposable resources
 */
export declare class AsyncTeardownManager implements AsyncDisposable {
    /**
     * @param subscriptions - Optional initial array of teardown subscriptions
     */
    constructor(subscriptions?: (AsyncSubscription | Subscription)[]);
    protected readonly subscriptions: (AsyncSubscription | Subscription)[];
    /**
     * Cleans up all registered subscriptions (implements Disposable pattern)
     */
    [Symbol.asyncDispose](): Promise<void>;
    /**
     * Cleans up all registered subscriptions (implements Disposable pattern)
     */
    [Symbol.dispose](): void;
    /**
     * Registers a teardown subscription or Disposable
     * @typeParam T - Subscription function or Disposable object
     * @param sub - Subscription callback or Disposable object to register
     * @returns The original subscription for chaining
     */
    teardown<T extends Promise<AsyncSubscription | AsyncDisposable | Subscription | Disposable | undefined | null> | AsyncSubscription | AsyncDisposable | Subscription | Disposable | undefined | null>(sub: T): T;
}
export declare class StatefulSubscription implements Disposable {
    private readonly _unsubscribe;
    private _unsubscribed;
    constructor(_unsubscribe: () => void);
    readonly unsubscribe: Subscription;
    get unsubscribed(): boolean;
    [Symbol.dispose](): void;
}
export declare class StatefulAsyncSubscription implements AsyncDisposable {
    private readonly _unsubscribe;
    private _unsubscribed;
    constructor(_unsubscribe: () => Promise<any>);
    readonly unsubscribe: AsyncSubscription;
    get unsubscribed(): boolean;
    [Symbol.asyncDispose](): Promise<void>;
}
export declare class ReplaceableSubscription extends StatefulSubscription {
    private subscription?;
    constructor(subscription?: Subscription);
    update(subscription: Subscription, unsubscribePrevious?: boolean): void;
}
export declare class ReplaceableAsyncSubscription extends StatefulSubscription {
    private subscription?;
    constructor(subscription?: AsyncSubscription);
    update(subscription: AsyncSubscription, unsubscribePrevious?: boolean): void;
}