/**
 * AUTO-GENERATED FILE - DO NOT EDIT
 * Generated from: api.schema.json
 */
import type { MessageConnection } from "vscode-jsonrpc/node.js";
export interface PingResult {
    /**
     * Echoed message (or default greeting)
     */
    message: string;
    /**
     * Server timestamp in milliseconds
     */
    timestamp: number;
    /**
     * Server protocol version number
     */
    protocolVersion: number;
}
export interface PingParams {
    /**
     * Optional message to echo back
     */
    message?: string;
}
export interface ModelsListResult {
    /**
     * List of available models with full metadata
     */
    models: {
        /**
         * Model identifier (e.g., "claude-sonnet-4.5")
         */
        id: string;
        /**
         * Display name
         */
        name: string;
        /**
         * Model capabilities and limits
         */
        capabilities: {
            /**
             * Feature flags indicating what the model supports
             */
            supports: {
                /**
                 * Whether this model supports vision/image input
                 */
                vision?: boolean;
                /**
                 * Whether this model supports reasoning effort configuration
                 */
                reasoningEffort?: boolean;
            };
            /**
             * Token limits for prompts, outputs, and context window
             */
            limits: {
                /**
                 * Maximum number of prompt/input tokens
                 */
                max_prompt_tokens?: number;
                /**
                 * Maximum number of output/completion tokens
                 */
                max_output_tokens?: number;
                /**
                 * Maximum total context window size in tokens
                 */
                max_context_window_tokens: number;
            };
        };
        /**
         * Policy state (if applicable)
         */
        policy?: {
            /**
             * Current policy state for this model
             */
            state: string;
            /**
             * Usage terms or conditions for this model
             */
            terms: string;
        };
        /**
         * Billing information
         */
        billing?: {
            /**
             * Billing cost multiplier relative to the base rate
             */
            multiplier: number;
        };
        /**
         * Supported reasoning effort levels (only present if model supports reasoning effort)
         */
        supportedReasoningEfforts?: string[];
        /**
         * Default reasoning effort level (only present if model supports reasoning effort)
         */
        defaultReasoningEffort?: string;
    }[];
}
export interface ToolsListResult {
    /**
     * List of available built-in tools with metadata
     */
    tools: {
        /**
         * Tool identifier (e.g., "bash", "grep", "str_replace_editor")
         */
        name: string;
        /**
         * Optional namespaced name for declarative filtering (e.g., "playwright/navigate" for MCP tools)
         */
        namespacedName?: string;
        /**
         * Description of what the tool does
         */
        description: string;
        /**
         * JSON Schema for the tool's input parameters
         */
        parameters?: {
            [k: string]: unknown;
        };
        /**
         * Optional instructions for how to use this tool effectively
         */
        instructions?: string;
    }[];
}
export interface ToolsListParams {
    /**
     * Optional model ID — when provided, the returned tool list reflects model-specific overrides
     */
    model?: string;
}
export interface AccountGetQuotaResult {
    /**
     * Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)
     */
    quotaSnapshots: {
        [k: string]: {
            /**
             * Number of requests included in the entitlement
             */
            entitlementRequests: number;
            /**
             * Number of requests used so far this period
             */
            usedRequests: number;
            /**
             * Percentage of entitlement remaining
             */
            remainingPercentage: number;
            /**
             * Number of overage requests made this period
             */
            overage: number;
            /**
             * Whether pay-per-request usage is allowed when quota is exhausted
             */
            overageAllowedWithExhaustedQuota: boolean;
            /**
             * Date when the quota resets (ISO 8601)
             */
            resetDate?: string;
        };
    };
}
export interface SessionModelGetCurrentResult {
    /**
     * Currently active model identifier
     */
    modelId?: string;
}
export interface SessionModelGetCurrentParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionModelSwitchToResult {
    /**
     * Currently active model identifier after the switch
     */
    modelId?: string;
}
export interface SessionModelSwitchToParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * Model identifier to switch to
     */
    modelId: string;
    /**
     * Reasoning effort level to use for the model
     */
    reasoningEffort?: string;
}
export interface SessionModeGetResult {
    /**
     * The current agent mode.
     */
    mode: "interactive" | "plan" | "autopilot";
}
export interface SessionModeGetParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionModeSetResult {
    /**
     * The agent mode after switching.
     */
    mode: "interactive" | "plan" | "autopilot";
}
export interface SessionModeSetParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * The mode to switch to. Valid values: "interactive", "plan", "autopilot".
     */
    mode: "interactive" | "plan" | "autopilot";
}
export interface SessionPlanReadResult {
    /**
     * Whether the plan file exists in the workspace
     */
    exists: boolean;
    /**
     * The content of the plan file, or null if it does not exist
     */
    content: string | null;
    /**
     * Absolute file path of the plan file, or null if workspace is not enabled
     */
    path: string | null;
}
export interface SessionPlanReadParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionPlanUpdateResult {
}
export interface SessionPlanUpdateParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * The new content for the plan file
     */
    content: string;
}
export interface SessionPlanDeleteResult {
}
export interface SessionPlanDeleteParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionWorkspaceListFilesResult {
    /**
     * Relative file paths in the workspace files directory
     */
    files: string[];
}
export interface SessionWorkspaceListFilesParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionWorkspaceReadFileResult {
    /**
     * File content as a UTF-8 string
     */
    content: string;
}
export interface SessionWorkspaceReadFileParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * Relative path within the workspace files directory
     */
    path: string;
}
export interface SessionWorkspaceCreateFileResult {
}
export interface SessionWorkspaceCreateFileParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * Relative path within the workspace files directory
     */
    path: string;
    /**
     * File content to write as a UTF-8 string
     */
    content: string;
}
export interface SessionFleetStartResult {
    /**
     * Whether fleet mode was successfully activated
     */
    started: boolean;
}
export interface SessionFleetStartParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * Optional user prompt to combine with fleet instructions
     */
    prompt?: string;
}
export interface SessionAgentListResult {
    /**
     * Available custom agents
     */
    agents: {
        /**
         * Unique identifier of the custom agent
         */
        name: string;
        /**
         * Human-readable display name
         */
        displayName: string;
        /**
         * Description of the agent's purpose
         */
        description: string;
    }[];
}
export interface SessionAgentListParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionAgentGetCurrentResult {
    /**
     * Currently selected custom agent, or null if using the default agent
     */
    agent: {
        /**
         * Unique identifier of the custom agent
         */
        name: string;
        /**
         * Human-readable display name
         */
        displayName: string;
        /**
         * Description of the agent's purpose
         */
        description: string;
    } | null;
}
export interface SessionAgentGetCurrentParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionAgentSelectResult {
    /**
     * The newly selected custom agent
     */
    agent: {
        /**
         * Unique identifier of the custom agent
         */
        name: string;
        /**
         * Human-readable display name
         */
        displayName: string;
        /**
         * Description of the agent's purpose
         */
        description: string;
    };
}
export interface SessionAgentSelectParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * Name of the custom agent to select
     */
    name: string;
}
export interface SessionAgentDeselectResult {
}
export interface SessionAgentDeselectParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionCompactionCompactResult {
    /**
     * Whether compaction completed successfully
     */
    success: boolean;
    /**
     * Number of tokens freed by compaction
     */
    tokensRemoved: number;
    /**
     * Number of messages removed during compaction
     */
    messagesRemoved: number;
}
export interface SessionCompactionCompactParams {
    /**
     * Target session identifier
     */
    sessionId: string;
}
export interface SessionToolsHandlePendingToolCallResult {
    /**
     * Whether the tool call result was handled successfully
     */
    success: boolean;
}
export interface SessionToolsHandlePendingToolCallParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    requestId: string;
    result?: string | {
        textResultForLlm: string;
        resultType?: string;
        error?: string;
        toolTelemetry?: {
            [k: string]: unknown;
        };
    };
    error?: string;
}
export interface SessionPermissionsHandlePendingPermissionRequestResult {
    /**
     * Whether the permission request was handled successfully
     */
    success: boolean;
}
export interface SessionPermissionsHandlePendingPermissionRequestParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    requestId: string;
    result: {
        kind: "approved";
    } | {
        kind: "denied-by-rules";
        rules: unknown[];
    } | {
        kind: "denied-no-approval-rule-and-could-not-request-from-user";
    } | {
        kind: "denied-interactively-by-user";
        feedback?: string;
    } | {
        kind: "denied-by-content-exclusion-policy";
        path: string;
        message: string;
    };
}
export interface SessionLogResult {
    /**
     * The unique identifier of the emitted session event
     */
    eventId: string;
}
export interface SessionLogParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * Human-readable message
     */
    message: string;
    /**
     * Log severity level. Determines how the message is displayed in the timeline. Defaults to "info".
     */
    level?: "info" | "warning" | "error";
    /**
     * When true, the message is transient and not persisted to the session event log on disk
     */
    ephemeral?: boolean;
}
export interface SessionShellExecResult {
    /**
     * Unique identifier for tracking streamed output
     */
    processId: string;
}
export interface SessionShellExecParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * Shell command to execute
     */
    command: string;
    /**
     * Working directory (defaults to session working directory)
     */
    cwd?: string;
    /**
     * Timeout in milliseconds (default: 30000)
     */
    timeout?: number;
}
export interface SessionShellKillResult {
    /**
     * Whether the signal was sent successfully
     */
    killed: boolean;
}
export interface SessionShellKillParams {
    /**
     * Target session identifier
     */
    sessionId: string;
    /**
     * Process identifier returned by shell.exec
     */
    processId: string;
    /**
     * Signal to send (default: SIGTERM)
     */
    signal?: "SIGTERM" | "SIGKILL" | "SIGINT";
}
/** Create typed server-scoped RPC methods (no session required). */
export declare function createServerRpc(connection: MessageConnection): {
    ping: (params: PingParams) => Promise<PingResult>;
    models: {
        list: () => Promise<ModelsListResult>;
    };
    tools: {
        list: (params: ToolsListParams) => Promise<ToolsListResult>;
    };
    account: {
        getQuota: () => Promise<AccountGetQuotaResult>;
    };
};
/** Create typed session-scoped RPC methods. */
export declare function createSessionRpc(connection: MessageConnection, sessionId: string): {
    model: {
        getCurrent: () => Promise<SessionModelGetCurrentResult>;
        switchTo: (params: Omit<SessionModelSwitchToParams, "sessionId">) => Promise<SessionModelSwitchToResult>;
    };
    mode: {
        get: () => Promise<SessionModeGetResult>;
        set: (params: Omit<SessionModeSetParams, "sessionId">) => Promise<SessionModeSetResult>;
    };
    plan: {
        read: () => Promise<SessionPlanReadResult>;
        update: (params: Omit<SessionPlanUpdateParams, "sessionId">) => Promise<SessionPlanUpdateResult>;
        delete: () => Promise<SessionPlanDeleteResult>;
    };
    workspace: {
        listFiles: () => Promise<SessionWorkspaceListFilesResult>;
        readFile: (params: Omit<SessionWorkspaceReadFileParams, "sessionId">) => Promise<SessionWorkspaceReadFileResult>;
        createFile: (params: Omit<SessionWorkspaceCreateFileParams, "sessionId">) => Promise<SessionWorkspaceCreateFileResult>;
    };
    fleet: {
        start: (params: Omit<SessionFleetStartParams, "sessionId">) => Promise<SessionFleetStartResult>;
    };
    agent: {
        list: () => Promise<SessionAgentListResult>;
        getCurrent: () => Promise<SessionAgentGetCurrentResult>;
        select: (params: Omit<SessionAgentSelectParams, "sessionId">) => Promise<SessionAgentSelectResult>;
        deselect: () => Promise<SessionAgentDeselectResult>;
    };
    compaction: {
        compact: () => Promise<SessionCompactionCompactResult>;
    };
    tools: {
        handlePendingToolCall: (params: Omit<SessionToolsHandlePendingToolCallParams, "sessionId">) => Promise<SessionToolsHandlePendingToolCallResult>;
    };
    permissions: {
        handlePendingPermissionRequest: (params: Omit<SessionPermissionsHandlePendingPermissionRequestParams, "sessionId">) => Promise<SessionPermissionsHandlePendingPermissionRequestResult>;
    };
    log: (params: Omit<SessionLogParams, "sessionId">) => Promise<SessionLogResult>;
    shell: {
        exec: (params: Omit<SessionShellExecParams, "sessionId">) => Promise<SessionShellExecResult>;
        kill: (params: Omit<SessionShellKillParams, "sessionId">) => Promise<SessionShellKillResult>;
    };
};