/**
 * Lifecycle management for resources that need acquisition and cleanup.
 *
 * Inspired by distage's Lifecycle feature, this provides automatic resource
 * management with guaranteed cleanup.
 *
 * Example:
 *   const dbLifecycle = Lifecycle.make(
 *     () => connectToDatabase(), // acquire
 *     (db) => db.disconnect()     // release
 *   );
 */
/**
 * A resource that needs to be acquired and released/cleaned up.
 *
 * The Lifecycle type ensures that resources are properly cleaned up
 * even if errors occur during usage.
 */
export declare class Lifecycle<T> {
    private readonly acquireFn;
    private readonly releaseFn;
    constructor(acquireFn: () => T | Promise<T>, releaseFn: (resource: T) => void | Promise<void>);
    /**
     * Create a Lifecycle from acquire and release functions
     */
    static make<T>(acquire: () => T | Promise<T>, release: (resource: T) => void | Promise<void>): Lifecycle<T>;
    /**
     * Create a Lifecycle from an object with a close() method
     * (like file handles, database connections, etc.)
     */
    static fromAutoCloseable<T extends {
        close(): void | Promise<void>;
    }>(acquire: () => T | Promise<T>): Lifecycle<T>;
    /**
     * Create a Lifecycle that just wraps a value (no cleanup needed)
     */
    static pure<T>(value: T): Lifecycle<T>;
    /**
     * Acquire the resource
     */
    acquire(): Promise<T>;
    /**
     * Release/cleanup the resource
     */
    release(resource: T): Promise<void>;
    /**
     * Use the resource and automatically clean it up afterwards
     *
     * This is the recommended way to use a Lifecycle - it guarantees
     * cleanup even if an error occurs.
     */
    use<R>(fn: (resource: T) => R | Promise<R>): Promise<R>;
    /**
     * Map the resource to a different type
     */
    map<R>(fn: (resource: T) => R | Promise<R>): Lifecycle<R>;
    /**
     * Chain two lifecycles together
     */
    flatMap<R>(fn: (resource: T) => Lifecycle<R>): Lifecycle<R>;
}
/**
 * Manages multiple Lifecycle resources and ensures they're all released
 * in reverse order of acquisition (LIFO - Last In, First Out).
 */
export declare class LifecycleManager {
    private resources;
    /**
     * Acquire a resource and track it for cleanup
     */
    acquire<T>(lifecycle: Lifecycle<T>): Promise<T>;
    /**
     * Release all acquired resources in reverse order (LIFO)
     */
    releaseAll(): Promise<void>;
    /**
     * Use multiple resources and automatically clean them all up
     */
    use<R>(fn: () => R | Promise<R>): Promise<R>;
}
/**
 * Error that aggregates multiple cleanup errors
 */
export declare class AggregateLifecycleError extends Error {
    readonly errors: Error[];
    constructor(errors: Error[]);
}
//# sourceMappingURL=Lifecycle.d.ts.map