import type { BrokerDB } from "./schema.js";
import type { BrokerMessage, MessageAdapter } from "./types.js";
export declare const DEFAULT_HEARTBEAT_TIMEOUT_MS = 15000;
export declare const DEFAULT_PRUNE_INTERVAL_MS = 5000;
export declare const DEFAULT_AUTH_TIMEOUT_MS = 2000;
export type ListenTarget = {
    type: "unix";
    path: string;
} | {
    type: "tcp";
    host: string;
    port: number;
};
export type AgentMessageCallback = (targetAgentId: string, msg: BrokerMessage, metadata: Record<string, unknown>) => void;
export type AgentStatusChangeCallback = (agentId: string, status: "working" | "idle") => void;
export type AgentRegistrationResolver = (input: {
    agentId: string;
    name: string;
    emoji: string;
    pid: number;
    stableId?: string;
    metadata?: Record<string, unknown>;
}) => {
    name: string;
    emoji: string;
    metadata?: Record<string, unknown>;
} | null;
export interface BrokerSocketServerOptions {
    heartbeatTimeoutMs?: number;
    pruneIntervalMs?: number;
    authTimeoutMs?: number;
    meshSecret?: string;
}
export declare class BrokerSocketServer {
    private server;
    private readonly target;
    private readonly db;
    private readonly router;
    private readonly connections;
    private readonly heartbeatTimeoutMs;
    private readonly pruneIntervalMs;
    private readonly authTimeoutMs;
    private readonly meshSecret;
    private pruneTimer;
    private assignedPort;
    private agentMessageCallback;
    private agentStatusChangeCallback;
    private outboundMessageAdapters;
    private agentRegistrationResolver;
    constructor(db: BrokerDB, target?: ListenTarget | string, options?: BrokerSocketServerOptions);
    start(): Promise<void>;
    stop(): Promise<void>;
    /**
     * Get connection info for clients. Returns the socket path (Unix)
     * or { host, port } (TCP).
     */
    getConnectInfo(): {
        type: "unix";
        path: string;
    } | {
        type: "tcp";
        host: string;
        port: number;
    };
    /**
     * Register a callback invoked whenever a worker sends an agent-to-agent
     * message via the socket server. The broker uses this to push messages
     * targeting itself into its in-memory inbox.
     */
    onAgentMessage(cb: AgentMessageCallback): void;
    /**
     * Register a callback invoked whenever a connected agent explicitly updates
     * its broker status. The broker uses idle transitions to kick maintenance so
     * backlog can be reassigned immediately.
     */
    onAgentStatusChange(cb: AgentStatusChangeCallback): void;
    setAgentRegistrationResolver(resolver: AgentRegistrationResolver | null): void;
    setOutboundMessageAdapters(adapters: ReadonlyArray<Pick<MessageAdapter, "name" | "send" | "invokeCapability">>): void;
    private startPruning;
    private stopPruning;
    private clearAuthTimer;
    private startAuthTimer;
    private disconnectDuplicateConnections;
    private findLiveStableIdConflict;
    private onConnection;
    private processBuffer;
    private dispatchRequest;
    private send;
    private handleRequest;
    private handleAuth;
    private handleRegister;
    private handleUnregister;
    private handleHeartbeat;
    private handleInboxPoll;
    private handleInboxRead;
    private handleInboxAck;
    private handleSend;
    private handleMessageSend;
    private handleThreadsList;
    private handleAgentsList;
    private handleAgentSessionsSearch;
    private handleThreadClaim;
    private handleResolveThread;
    private handleAgentMessage;
    private handleAgentBroadcast;
    private handleLaneList;
    private handleLaneUpsert;
    private handleLaneParticipant;
    private handlePortLeaseAcquire;
    private handlePortLeaseRenew;
    private handlePortLeaseRelease;
    private handlePortLeaseStatus;
    private handlePortLeaseList;
    private handlePortLeaseExpire;
    private handleScheduleCreate;
    private handleStatusUpdate;
    private handleAdapterCapability;
    private handleLegacySlackProxy;
    private dispatchAdapterCapability;
    private checkAdapterCapabilityThreadOwnership;
    private applyAdapterCapabilityEffects;
}