/**
 * Claude Code Remote Session — high-level WebSocket session manager.
 *
 * Manages the full lifecycle:
 *  1. Build WS URL: wss://{host}/v1/sessions/ws/{sessionId}/subscribe?organization_uuid={orgUuid}
 *  2. Connect WebSocket transport
 *  3. Send auth message on open
 *  4. Keep-alive every 50s
 *  5. Send/receive newline-delimited JSON messages
 *  6. Handle control requests (tool permissions, hooks, MCP, etc.)
 *  7. Automatic reconnect with exponential backoff (up to 5 retries)
 *  8. Idle timeout after 5 minutes of inactivity
 */
import { ClaudeApi } from "./api";
import type { ClaudeRemoteOptions, WsResultMessage, WsAssistantMessage, ToolPermissionResponse } from "./types";
export type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting" | "error";
export type ToolPermissionHandler = (toolName: string, input: Record<string, unknown>, meta: {
    toolUseID: string;
    signal: AbortSignal;
    suggestions?: unknown[];
}) => Promise<ToolPermissionResponse>;
export type HookCallbackHandler = (callbackId: string, input: unknown, toolUseId: string, signal: AbortSignal) => Promise<unknown>;
export interface SessionManagerOptions extends ClaudeRemoteOptions {
    sessionId: string;
    /** Whether to replay missed messages on connect */
    replay?: boolean;
    /** Handle tool permission requests. If not set, all tools are auto-allowed. */
    onToolPermission?: ToolPermissionHandler;
    /** Handle hook callbacks */
    onHookCallback?: HookCallbackHandler;
    /** Called for every assistant message from the server (streaming, may fire multiple times per msg_id) */
    onAssistantMessage?: (message: WsAssistantMessage) => void;
    /** Called when an agent turn completes with execution summary */
    onResult?: (message: WsResultMessage) => void;
    /** Called when connection state changes */
    onStateChange?: (state: ConnectionState) => void;
    /** Called on any error */
    onError?: (error: Error) => void;
    /** Maximum reconnect attempts (default: 5) */
    maxRetries?: number;
    /** Idle timeout in ms (default: 300000 = 5min) */
    idleTimeout?: number;
}
export declare class SessionManager {
    private transport;
    private abortController;
    private _state;
    private retryCount;
    private reconnectTimer;
    private idleTimer;
    private lastMessageTime;
    private pendingResponses;
    private cancelControllers;
    private initialized;
    private initResponse;
    readonly api: ClaudeApi;
    readonly options: SessionManagerOptions;
    get state(): ConnectionState;
    constructor(options: SessionManagerOptions);
    /**
     * Build the WebSocket URL.
     */
    private buildWsUrl;
    /**
     * Connect to the session WebSocket.
     */
    connect(): Promise<void>;
    /**
     * Disconnect from the session.
     */
    disconnect(reason?: string): void;
    /**
     * Send a user message.
     */
    sendMessage(content: string, fileAttachments?: unknown[]): Promise<void>;
    /**
     * Send an interrupt signal.
     */
    interrupt(): Promise<void>;
    /**
     * Set the model for this session.
     */
    setModel(model: string): Promise<void>;
    /**
     * Set the permission mode.
     */
    setPermissionMode(mode: string): Promise<void>;
    /**
     * Set max thinking tokens.
     */
    setMaxThinkingTokens(tokens: number): Promise<void>;
    /**
     * Get supported slash commands.
     */
    supportedCommands(): Promise<unknown>;
    /**
     * Get MCP server status.
     */
    mcpServerStatus(): Promise<unknown>;
    private setState;
    private resetIdleTimer;
    private readLoop;
    private handleControlRequest;
    private processControlRequest;
    private sendControlRequest;
    private maybeReconnect;
}
//# sourceMappingURL=session.d.ts.map