/**
 * Server Registry
 *
 * Manages registration of peer servers in a Nebula cluster.
 * Peer servers can register with a main server to enable
 * cross-server kernel access.
 */
import type { ServerResources } from '../resources/resource-service';
export interface PeerServer {
    id: string;
    host: string;
    port: number;
    name?: string;
    url: string;
    registeredAt: number;
    lastHeartbeat: number;
    status: 'online' | 'offline' | 'unknown';
    kernelspecs?: string[];
    resources?: ServerResources;
    allocationToken?: string;
    allocationId?: string;
}
export interface RegisterRequest {
    host: string;
    port: number;
    name?: string;
    secret?: string;
    resources?: ServerResources;
    allocationToken?: string;
}
declare class ServerRegistry {
    private servers;
    private clusterSecret;
    private cleanupInterval;
    private localServerId;
    constructor();
    /**
     * Set the local server's ID (called on startup)
     */
    setLocalServerId(id: string): void;
    /**
     * Get the local server's ID
     */
    getLocalServerId(): string;
    /**
     * Validate registration secret
     */
    private getClusterSecret;
    private validateSecret;
    /**
     * Generate server ID from host and port
     */
    private generateServerId;
    /**
     * Register a peer server
     */
    register(request: RegisterRequest): {
        success: boolean;
        serverId?: string;
        error?: string;
    };
    /**
     * Unregister a peer server
     */
    unregister(serverId: string): boolean;
    /**
     * Record heartbeat from a peer server
     */
    heartbeat(serverId: string, resources?: ServerResources): boolean;
    /**
     * Get a specific peer server
     */
    getServer(serverId: string): PeerServer | undefined;
    /**
     * Get all registered peer servers
     */
    getAllServers(): PeerServer[];
    /**
     * Find a registered server by its scheduler allocation token.
     * Used by the allocation service to correlate a job's registration.
     */
    getServerByAllocationToken(token: string): PeerServer | undefined;
    /**
     * Get all online peer servers
     */
    getOnlineServers(): PeerServer[];
    private lostListeners;
    onServerLost(cb: (server: PeerServer) => void): void;
    private notifyLost;
    /**
     * A request proxied to this server just failed at the connection level
     * (refused/reset/timeout). Don't mark it offline on one failure — that's
     * the heartbeat's job — but do tell listeners so they can verify fast.
     */
    reportUnreachable(serverId: string): void;
    /**
     * Check server health and update status
     */
    private checkServerHealth;
    /**
     * Start the cleanup interval
     */
    private startCleanupInterval;
    /**
     * Stop the cleanup interval (for shutdown)
     */
    shutdown(): void;
    /**
     * Get cluster info for API response
     */
    getClusterInfo(localResources?: ServerResources): {
        localServerId: string;
        peerCount: number;
        onlineCount: number;
        servers: Array<{
            id: string;
            name?: string;
            url: string;
            status: string;
            isLocal: boolean;
            resources?: ServerResources;
        }>;
    };
}
export declare const serverRegistry: ServerRegistry;
export {};