import type { FlowcoreEvent } from "../../contracts/event.js";
import type { Logger } from "../logger.js";
import type { PumpState } from "../pump/types.js";
import type { ClusterRole, PathwayClusterOptions } from "./types.js";
/**
 * ClusterManager handles distributed event processing via leader election and WS workers.
 *
 * Lifecycle: register → heartbeat loop → leader election loop
 * - Leader: opens WS connections to workers, distributes events round-robin
 * - Worker: accepts WS from leader, processes events, sends ack/fail
 * - Fallback: leader processes locally when no workers available
 */
export declare class ClusterManager {
    private readonly coordinator;
    private readonly transport;
    private readonly instanceId;
    private readonly advertisedAddress;
    private readonly port;
    private readonly leaseTtlMs;
    private readonly leaseRenewIntervalMs;
    private readonly heartbeatIntervalMs;
    private readonly staleThresholdMs;
    private readonly deliveryTimeoutMs;
    private readonly workerConcurrency;
    private readonly logger;
    private role;
    private running;
    private heartbeatTimer;
    private leaseTimer;
    private deliveryTimeoutTimer;
    private workerConnections;
    private pendingDeliveries;
    private workerAddresses;
    private roundRobinIndex;
    private wsServer;
    private leaderConnection;
    private eventHandler;
    private leadershipChangeHandler;
    private resetHandler;
    private pendingResets;
    constructor(options: PathwayClusterOptions, logger?: Logger);
    /**
     * Set the handler that processes events locally (used by both leader fallback and workers)
     */
    setEventHandler(handler: (pathway: string, event: FlowcoreEvent) => Promise<void>): void;
    /**
     * Set a callback that fires when this instance becomes or loses leadership.
     * Used by PathwaysBuilder to auto-start the pump when becoming leader.
     */
    onLeadershipChange(handler: (isLeader: boolean) => void): void;
    /**
     * Set a callback that handles pump reset requests on the leader.
     */
    onReset(handler: (position?: PumpState) => Promise<void>): void;
    /**
     * Request a pump reset. Routes to the leader automatically.
     * - If this instance is the leader: executes the reset directly.
     * - If this instance is a worker: forwards the request to the leader via WebSocket.
     */
    requestReset(position?: PumpState): Promise<void>;
    /**
     * Start the cluster: register instance, begin heartbeat, attempt leader election
     */
    start(): Promise<void>;
    /**
     * Stop the cluster: release lease, unregister, close connections
     */
    stop(): Promise<void>;
    /**
     * Process an event through the cluster.
     * - Leader: distribute to a worker or process locally if no workers
     * - Worker: should not call this directly (receives events via WS)
     */
    processEvent(pathway: string, event: FlowcoreEvent): Promise<void>;
    get isLeader(): boolean;
    get isWorker(): boolean;
    get currentRole(): ClusterRole;
    get isRunning(): boolean;
    get currentInstanceId(): string;
    private tryAcquireLease;
    private leaseLoop;
    private onBecomeLeader;
    private refreshWorkers;
    private cleanupLeaderState;
    private startWsServer;
    private handleWorkerMessage;
    private connectToWorker;
    private handleLeaderMessage;
    private getNextWorker;
    private distributeToWorker;
    private processLocally;
    private checkDeliveryTimeouts;
}
//# sourceMappingURL=cluster-manager.d.ts.map