import type { MemoryStats } from "./memory-store.js";
import { StatusReporter } from "./status-reporter.js";
import type { AgentConfig, BridgeToolManifest, BrowserListenerEvent, DirectMessage, DmHistoryResponse, FetchUnreadMessagesOptions, FinishTaskRollbackArgs, GroupHistoryResponse, GroupRoomsResponse, HireBatchResult, HireColleagueArgs, MessageHandler, OnlineListResponse, PluginCatalogSnapshot, ProfileInfo, RegisterResult, ServerConfig, SendDmResult, SendMessageResult, StartTaskRollbackArgs, TaskInstanceCommentArgs, UnreadMessagesResult } from "./types.js";
export type ProfileHandler = (profile: ProfileInfo) => void;
export type AgentConfigHandler = (data: Record<string, unknown>) => void;
export type SystemNotifyHandler = (data: Record<string, unknown>) => void;

export declare class PollLongPollTimeoutError extends Error {
    constructor(message: string);
}
export declare class AgentClient {
    private wsClient;
    private httpClient;
    private agentConfig;
    private serverConfig;
    private agentId;
    private displayName;
    private projectId;
    private isRunning;
    private isDegradedMode;
    private messageHandler;
    private profileHandler;
    private configHandler;
    private systemNotifyHandler;
    private pollTimer;
    private statusReporter;
    private newCharacterHandler;
    
    private runtimeTokenRefreshTimer;
    
    private pendingLaunchBindingClaim;
    
    private cachedProfile;
    constructor();
    initialize(): Promise<void>;
    private applyLaunchBinding;
    
    private retryPendingLaunchBindingClaim;
    private setupWebSocketListeners;
    
    register(): Promise<RegisterResult>;
    private hasPresetAgentId;
    
    private registerWithExistingAgentId;
    
    private registerAsNewAgent;
    
    unregister(): Promise<void>;
    
    discoverColleagues(): Promise<OnlineListResponse>;
    
    discoverGroupRooms(): Promise<GroupRoomsResponse>;
    
    hireColleague(args: HireColleagueArgs): Promise<HireBatchResult>;
    
    callAgentScopedTool<T = unknown>(toolName: string, args: Record<string, unknown>): Promise<T>;
    
    reportMemoryStats(memoryStats: MemoryStats): Promise<void>;
    
    sendGroupMessage(content: string, projectId?: string, roomId?: string, card?: {
        type: "pencil" | "draw";
        docId: string;
        title?: string;
        description?: string;
    }): Promise<SendMessageResult>;
    
    sendDirectMessage(targetId: string, content: string, waitReply?: boolean, replyToCallId?: string, timeoutMs?: number, card?: {
        type: "pencil" | "draw";
        docId: string;
        title?: string;
        description?: string;
    }): Promise<SendDmResult>;
    
    sendCallAndWaitReply(targetId: string, content: string, timeoutMs?: number): Promise<DirectMessage>;
    
    replyToCall(callId: string, targetId: string, content: string): Promise<SendDmResult>;
    
    getDmHistory(targetUserId?: string, limit?: number, since?: string): Promise<DmHistoryResponse>;
    
    getGroupHistory(limit?: number, roomId?: string, since?: string): Promise<GroupHistoryResponse>;
    
    fetchUnreadMessages(options?: FetchUnreadMessagesOptions): Promise<UnreadMessagesResult>;
    
    markDmRead(msgIds: string[]): Promise<Set<string>>;
    
    markGroupRead(roomId: string, msgIds: number[]): Promise<Set<number>>;
    
    markNotificationRead(msgIds: string[]): Promise<void>;
    
    markMeetingRead(msgIds: Array<string | number>): Promise<void>;
    
    fetchBrowserListenerEvents(): Promise<BrowserListenerEvent[]>;
    
    fetchPluginEvents(): Promise<{
        revision: number;
        events: DirectMessage[];
        catalog: PluginCatalogSnapshot | null;
        
        compactionSeq: number;
    }>;
    
    notifyBridgeForceMessage(): Promise<void>;
    
    setBridgeCapabilityTools(capability: string, action: "expand" | "collapse"): Promise<{
        ok: boolean;
        sessions?: number;
        tools?: number;
        manifests?: BridgeToolManifest[];
        error?: string;
    }>;
    
    callBridgeCapabilityTool(capability: string, toolName: string, args: unknown): Promise<{
        ok: boolean;
        result?: unknown;
        error?: string;
    }>;
    
    private fetchDirectMessagesWithRecovery;
    
    private isRecoverableLongPollError;
    
    private normalizeGroupMessages;
    
    private collectRoomIds;
    
    getProfile(): Promise<ProfileInfo>;
    private getProfileByAgentId;
    
    getMyTasks(): Promise<unknown[]>;
    
    createTaskInstanceComment(args: TaskInstanceCommentArgs): Promise<unknown>;
    
    submitTaskResult(nodeId: string, outputPayload: string, changeLog?: unknown[]): Promise<unknown>;
    
    startTaskRollback(args: StartTaskRollbackArgs): Promise<unknown>;
    
    finishTaskRollback(args: FinishTaskRollbackArgs): Promise<unknown>;
    
    rejectTask(nodeId: string, reason: string): Promise<unknown>;
    
    terminateTask(taskInstanceId: string, reason: string): Promise<unknown>;
    
    getDebugLogConfig(): Promise<unknown>;
    
    queryDebugLogs(args: Record<string, unknown>): Promise<unknown>;
    
    queryFileChangesHistory(args: Record<string, unknown>): Promise<unknown>;
    
    getRuntimeFeatures(): Promise<Record<string, unknown>>;
    
    listLaunchConfigs(): Promise<unknown>;
    
    createLaunchConfig(args: Record<string, unknown>): Promise<unknown>;
    
    updateLaunchConfig(args: Record<string, unknown>): Promise<unknown>;
    
    deleteLaunchConfig(configId: string): Promise<unknown>;
    
    startLaunchConfig(args: Record<string, unknown>): Promise<unknown>;
    
    restartLaunchConfig(args: Record<string, unknown>): Promise<unknown>;
    
    stopLaunchConfig(configId: string): Promise<unknown>;
    
    getLaunchLogs(args: Record<string, unknown>): Promise<unknown>;
    
    listLaunchRuns(): Promise<unknown>;
    
    start(handler: MessageHandler, options?: {
        pollMode?: boolean;
        profileHandler?: ProfileHandler;
        configHandler?: AgentConfigHandler;
        systemNotifyHandler?: SystemNotifyHandler;
    }): void;
    
    stop(): void;
    private messageLoop;
    private handleIncomingDm;
    private handleIncomingGroup;
    private handleIncomingMeeting;
    
    private handleProfileInfo;
    private processMessage;
    private ensureRegistered;
    private delay;
    
    onNewCharacter(handler: () => void): void;
    getState(): {
        agentId: string | null;
        displayName: string | null;
        projectId: string | null;
        isConnected: boolean;
        isRunning: boolean;
    };
    getAgentConfig(): AgentConfig;
    getServerConfig(): ServerConfig;
    reloadConfig(): void;
    
    enterDegradedMode(): void;
    
    exitDegradedMode(): void;
    
    isInDegradedMode(): boolean;
    
    retryRegistrationInBackground(retryIntervalMs: number, maxRetries: number): Promise<void>;
    
    private initializeStatusReporter;
    
    private startRuntimeTokenRefresh;
    private stopRuntimeTokenRefresh;
    
    private reportMcpNodeLog;
    
    getStatusReporter(): StatusReporter | null;
}