import type { PinetReadOptions, PinetReadResult } from "@pinet/pinet-core/pinet-read-formatting";
import type { AgentSessionSearchInfo, AgentSessionSearchOptions, ClientAgentInfo, NormalizedMessageContent, OutboundAttachmentFile, PortLeaseAcquireInput, PortLeaseInfo, PortLeaseListOptions, PortLeaseReleaseInput, PortLeaseRenewInput, PinetLaneInfo, PinetLaneListOptions, PinetLaneParticipantInfo, PinetLaneParticipantUpsertInput, PinetLaneUpsertInput } from "./types.js";
export interface InboxItem {
    inboxId: number;
    message: {
        id: number;
        threadId: string;
        source: string;
        direction: string;
        sender: string;
        body: string;
        metadata: Record<string, unknown> | null;
        createdAt: string;
    };
}
export type { PinetReadMessage, PinetReadOptions, PinetReadResult, PinetUnreadThreadSummary, } from "@pinet/pinet-core/pinet-read-formatting";
export interface ThreadInfo {
    threadId: string;
    source: string;
    channel: string;
    ownerAgent: string | null;
    ownerBinding?: "explicit" | null;
    metadata?: Record<string, unknown> | null;
    createdAt: string;
    updatedAt: string;
}
export type AgentInfo = ClientAgentInfo;
export type { AgentSessionSearchInfo, AgentSessionSearchOptions };
export interface ScheduledWakeupInfo {
    id: number;
    threadId: string;
    fireAt: string;
}
export type { PortLeaseAcquireInput, PortLeaseInfo, PortLeaseListOptions, PortLeaseReleaseInput, PortLeaseRenewInput, PinetLaneInfo, PinetLaneListOptions, PinetLaneParticipantInfo, PinetLaneParticipantUpsertInput, PinetLaneUpsertInput, };
export declare const DEFAULT_SOCKET_PATH: string;
export declare const REQUEST_TIMEOUT_MS = 5000;
export declare const RECONNECT_DELAY_MS = 3000;
export declare const INITIAL_RECONNECT_DELAY_MS = 1000;
export declare const MAX_RECONNECT_DELAY_MS = 30000;
export declare const HEARTBEAT_INTERVAL_MS = 5000;
export declare const HEARTBEAT_METADATA_PROVIDER_TIMEOUT_MS = 2500;
/** Compute reconnect delay with exponential backoff and jitter. */
export declare function computeReconnectDelay(attempt: number, random?: number): number;
export interface AgentBroadcastResult {
    channel: string;
    messageIds: number[];
    recipients: Array<{
        id: string;
        name: string;
    }>;
}
export type BrokerConnectOpts = {
    path: string;
} | {
    host: string;
    port: number;
};
export interface BrokerClientAuthOptions {
    meshSecret?: string;
    meshSecretPath?: string;
}
export declare class BrokerClient {
    private readonly connectOpts;
    private readonly meshSecret;
    private readonly meshSecretPath;
    private socket;
    private connected;
    private shuttingDown;
    private reconnectTimer;
    private heartbeatTimer;
    private disconnectHandler;
    private reconnectHandler;
    private reconnectFailedHandler;
    private reconnectAttempt;
    private registrationSnapshot;
    private registeredIdentity;
    private heartbeatMetadataProvider;
    private heartbeatMetadataInFlight;
    private nextId;
    private readonly pending;
    private buffer;
    constructor(opts?: string | (BrokerConnectOpts & BrokerClientAuthOptions));
    connect(): Promise<void>;
    disconnect(): void;
    disconnectGracefully(): Promise<void>;
    isConnected(): boolean;
    private resolveMeshSecret;
    private authenticateIfNeeded;
    register(name: string, emoji: string, metadata?: Record<string, unknown>, stableId?: string): Promise<{
        agentId: string;
        name: string;
        emoji: string;
        metadata?: Record<string, unknown> | null;
    }>;
    unregister(): Promise<void>;
    heartbeat(metadata?: Record<string, unknown> | null): Promise<void>;
    setHeartbeatMetadataProvider(provider: (() => Promise<Record<string, unknown> | null | undefined>) | null): void;
    pollInbox(): Promise<InboxItem[]>;
    readInbox(options?: PinetReadOptions): Promise<PinetReadResult>;
    ackMessages(ids: number[]): Promise<void>;
    send(threadId: string, text: string, metadata?: Record<string, unknown>): Promise<void>;
    sendMessage(input: {
        threadId: string;
        body: string;
        source?: string;
        channel?: string;
        content?: NormalizedMessageContent;
        blocks?: ReadonlyArray<Record<string, unknown>>;
        files?: ReadonlyArray<OutboundAttachmentFile>;
        agentName?: string;
        agentEmoji?: string;
        agentOwnerToken?: string;
        metadata?: Record<string, unknown>;
    }): Promise<{
        adapter: string;
        messageId: number;
        threadId: string;
        channel: string;
        source: string;
    }>;
    claimThread(threadId: string, channel?: string, source?: string): Promise<{
        claimed: boolean;
    }>;
    resolveThread(threadTs: string): Promise<string | null>;
    updateStatus(status: "working" | "idle"): Promise<void>;
    sendAgentMessage(target: string, body: string, metadata?: Record<string, unknown>): Promise<number>;
    sendAgentBroadcast(channel: string, body: string): Promise<AgentBroadcastResult>;
    scheduleWakeup(fireAt: string, body: string): Promise<ScheduledWakeupInfo>;
    listLanes(options?: PinetLaneListOptions): Promise<PinetLaneInfo[]>;
    upsertLane(input: PinetLaneUpsertInput): Promise<PinetLaneInfo>;
    setLaneParticipant(input: PinetLaneParticipantUpsertInput): Promise<PinetLaneParticipantInfo>;
    acquirePortLease(input: PortLeaseAcquireInput): Promise<PortLeaseInfo>;
    renewPortLease(input: PortLeaseRenewInput): Promise<PortLeaseInfo>;
    releasePortLease(input: PortLeaseReleaseInput): Promise<PortLeaseInfo>;
    getPortLease(leaseId: string): Promise<PortLeaseInfo | null>;
    listPortLeases(options?: PortLeaseListOptions): Promise<PortLeaseInfo[]>;
    expirePortLeases(): Promise<PortLeaseInfo[]>;
    listThreads(): Promise<ThreadInfo[]>;
    listAgents(includeDisconnected?: boolean): Promise<AgentInfo[]>;
    searchAgentSessions(options?: AgentSessionSearchOptions): Promise<AgentSessionSearchInfo[]>;
    invokeAdapterCapability(adapter: string, capability: string, params?: Record<string, unknown>): Promise<Record<string, unknown>>;
    /**
     * Compatibility wrapper for callers that still need direct Slack API access.
     * The broker RPC boundary remains adapter-neutral; Slack-specific payloads are
     * interpreted inside the Slack adapter's api.call capability.
     */
    slackProxy(method: string, params: Record<string, unknown>): Promise<Record<string, unknown>>;
    onDisconnect(handler: () => void): void;
    onReconnect(handler: () => void): void;
    onReconnectFailed(handler: (error: Error) => void): void;
    getReconnectAttempt(): number;
    getRegisteredIdentity(): {
        agentId: string;
        name: string;
        emoji: string;
        metadata?: Record<string, unknown> | null;
    } | null;
    private request;
    private onData;
    private handleResponse;
    private scheduleReconnect;
    private connectSocket;
    private performRegister;
    private reconnectOnce;
    private startHeartbeat;
    private readHeartbeatMetadata;
    private runHeartbeatTick;
    private stopHeartbeat;
    private rejectAllPending;
}