import { type Blocks } from "@peerbit/blocks-interface";
import type { Identity } from "@peerbit/crypto";
import type { Address } from "./address.js";
export declare const logger: import("@libp2p/interface").Logger;
type ProgramMergeStrategy = "replace" | "reject" | "reuse";
export type TerminalOperation = "close" | "drop";
export type TerminalBaseCommit = {
    epoch: number;
    version: number;
    type: TerminalOperation;
    from?: Manageable<any>;
    result: boolean;
    releasedParentReferences: number;
};
export declare const TERMINAL_BASE_CHECKPOINT: unique symbol;
export declare const TERMINAL_BASE_COMMIT: unique symbol;
export declare const TERMINAL_BASE_RETRY: unique symbol;
export declare const TERMINAL_OUTER_CLEANUP_RETAIN: unique symbol;
export declare const TERMINAL_OUTER_CLEANUP_RELEASE: unique symbol;
declare const TERMINAL_OPERATION_NOT_STARTED: unique symbol;
/**
 * A terminal-operation precondition rejected the call before any lifecycle or
 * resource mutation began. Handler leaves the program retryable instead of
 * retaining this as partially completed cleanup.
 */
export declare class TerminalOperationNotStartedError extends Error {
    readonly [TERMINAL_OPERATION_NOT_STARTED] = true;
    constructor(message: string);
    static [Symbol.hasInstance](instance: unknown): boolean;
}
export type ExtractArgs<T> = T extends CanOpen<infer Args> ? Args : never;
export type EventOptions = {
    onBeforeOpen?: (program: Manageable<any>) => Promise<void> | void;
    onOpen?: (program: Manageable<any>) => Promise<void> | void;
    onDrop?: (program: Manageable<any>) => Promise<void> | void;
    onClose?: (program: Manageable<any>) => Promise<void> | void;
};
export type OpenOptions<T extends Manageable<ExtractArgs<T>>> = {
    timeout?: number;
    existing?: ProgramMergeStrategy;
    mode?: "auto" | "local" | "canonical";
} & ProgramInitializationOptions<ExtractArgs<T>, T>;
export type WithArgs<Args> = {
    args?: Args;
};
export type WithParent<T> = {
    parent?: T;
};
export type Closeable = {
    closed: boolean;
    close(): Promise<boolean>;
};
type WithNode = {
    node: {
        identity: Identity;
    };
};
export type Addressable = {
    address: Address;
};
export interface Saveable {
    save(store: Blocks, options?: {
        format?: string;
        timeout?: number;
        skipOnAddress?: boolean;
        save?: (address: string) => boolean | Promise<boolean>;
    }): Promise<Address>;
    delete(): Promise<void>;
}
export type CanEmit = {
    emitEvent: (event: CustomEvent) => void;
};
export type CanOpen<Args> = {
    beforeOpen: (client: any, options?: EventOptions) => Promise<void>;
    open(args?: Args): Promise<void>;
    afterOpen: () => Promise<void>;
};
export type Manageable<Args> = Closeable & Addressable & CanOpen<Args> & Saveable & CanEmit & {
    children: Manageable<any>[];
    parents: (Manageable<any> | undefined)[];
    /**
     * Programs with terminal work that must happen before `Program.end()` can
     * fence parent reuse while that work is in progress.
     */
    readonly acceptsParentAttachments?: boolean;
    /** Base terminal tail/deletion that must be resumed with this operation. */
    readonly pendingTerminalOperation?: TerminalOperation;
    /** A lifecycle callback must not recursively wait for Handler.stop(). */
    readonly terminalLifecycleCallbackRunning?: boolean;
    [TERMINAL_BASE_CHECKPOINT]?: () => number;
    [TERMINAL_BASE_COMMIT]?: (afterVersion: number, type: TerminalOperation, from?: Manageable<any>) => TerminalBaseCommit | undefined;
    [TERMINAL_BASE_RETRY]?: (commit: TerminalBaseCommit, operation: () => Promise<boolean>) => Promise<boolean>;
    [TERMINAL_OUTER_CLEANUP_RETAIN]?: () => object;
    [TERMINAL_OUTER_CLEANUP_RELEASE]?: (lease: object) => void;
} & WithNode;
export type ProgramInitializationOptions<Args, T extends Manageable<Args>> = {} & WithArgs<Args> & WithParent<T> & EventOptions;
export declare const addParent: (child: Manageable<any>, parent?: Manageable<any>) => void;
/**
 * Owns lifecycle state for one client. Handler instances do not share address
 * reservations, so a client must use a single Handler for a program graph.
 */
export declare class Handler<T extends Manageable<any>> {
    readonly properties: {
        client: {
            services: {
                blocks: Blocks;
            };
            stop: () => Promise<void>;
        };
        load: (address: Address, blocks: Blocks, options?: {
            timeout?: number;
        }) => Promise<T | undefined>;
        shouldMonitor: (thing: any) => boolean;
        identity: Identity;
        getDependencies?: (program: T) => Manageable<any>[];
    };
    items: Map<string, T>;
    private _openQueue;
    private _openingPromises;
    private _openingReservations;
    private _openingReservationsByPromise;
    private _openingReservationsByAddress;
    private _parentAttachmentReservations;
    private _openAdmissions;
    private _openLifecycleCallbacks;
    private _terminalLifecycleCallbacks;
    private _lifecycleMethodInvocations;
    private _acceptingOpens;
    private _stopPromise?;
    private _lifecycleState;
    private _failedInitializations;
    private _cleanupResiduals;
    private _terminalOperationsByProgram;
    private _terminalOperationsByAddress;
    private _initializationRollbacks;
    private _replacementClosures;
    constructor(properties: {
        client: {
            services: {
                blocks: Blocks;
            };
            stop: () => Promise<void>;
        };
        load: (address: Address, blocks: Blocks, options?: {
            timeout?: number;
        }) => Promise<T | undefined>;
        shouldMonitor: (thing: any) => boolean;
        identity: Identity;
        getDependencies?: (program: T) => Manageable<any>[];
    });
    /**
     * Re-open admissions after the owning client has finished starting all of the
     * services programs depend on. This is an internal client lifecycle hook, not
     * a substitute for starting the client itself.
     *
     * This is called by the owning client after its services have started.
     */
    start(): void;
    /** Validate restart eligibility without opening admissions. */
    assertCanStart(): void;
    /**
     * Stop the handler after admitted lifecycle work drains.
     *
     * Lifecycle overrides and callbacks must not await their own handler/client
     * stop. Immediate reentry is rejected. After user code has yielded, portable
     * JavaScript runtimes provide no reliable async-call provenance with which to
     * distinguish self-reentry from an unrelated external stop; schedule stop from
     * the lifecycle owner instead. A conservatively rejected external stop remains
     * retryable after the active callback finishes.
     */
    stop(): Promise<void>;
    /**
     * Async methods execute synchronously until their first await. Fence that
     * invocation window so a lifecycle override cannot make stop wait on the very
     * operation that is awaiting stop. Awaited user callbacks have their own wider
     * callback fences below.
     */
    private invokeLifecycleMethod;
    /**
     * Program.end() can only observe the base implementation's lifetime. A
     * subclass is still free to do asynchronous cleanup after `super.close()` or
     * `super.drop()` has returned. Wrap the public, dynamically-dispatched method
     * on every managed instance so Handler state covers that full outer promise.
     */
    private monitorTerminalOperations;
    private refreshTerminalOperationWrappers;
    private runTerminalOperation;
    private finishOuterTerminalCall;
    private sameTerminalArgs;
    private sameParents;
    private terminalCheckpoint;
    private terminalCommit;
    private retryCommittedTerminalCall;
    private addCleanupResidual;
    private reserveCleanupResidual;
    private acquireCleanupReservation;
    private releaseCleanupReservation;
    private releaseCleanupResidual;
    private releaseRetainedTerminalIdentity;
    private retryCleanupResidual;
    private finishTerminalOperation;
    private restoreTerminalOperations;
    private findMonitoredPrograms;
    private findMonitoredProgram;
    private attachExistingProgram;
    private assertNoTerminalOperation;
    private assertTerminalGraphCanStart;
    private waitForTerminalOperations;
    private closeCompletely;
    private removeReleasedParentChildReferences;
    private assertNoFailedInitialization;
    private stopOnce;
    private _onProgamClose;
    private closeForReplacement;
    private checkProcessExisting;
    private processParentExisting;
    private rollbackFailedInitialization;
    private dependencyGraph;
    private resolveDependencyAddresses;
    private cleanupFailedOpeningMonitoring;
    private releaseOpeningReservation;
    private reservationContains;
    private contributeOpeningParticipant;
    private mergeOpeningReservationGroups;
    private canShareOpeningReservation;
    private canOpenAlongsideReservation;
    private adoptOpeningReservation;
    private waitForOpeningConflictChange;
    private assertParentCanOwnOpen;
    private retainParentAttachment;
    private releaseParentAttachment;
    private isReservedNestedUse;
    private waitForOpeningReservations;
    private prepareOpeningGraph;
    private trackOpening;
    open<S extends T>(storeOrAddress: S | Address | string, options?: OpenOptions<S>): Promise<S>;
    private openAdmitted;
}
export {};
//# sourceMappingURL=handler.d.ts.map