export declare const CLAUDE_CODE_SERVICE_PATH = "/services/claude-code";
/**
 * Message sent from backend to frontend requesting user approval for tool usage.
 */
export interface ToolApprovalRequestMessage {
    type: 'tool-approval-request';
    toolName: string;
    toolInput: unknown;
    requestId: string;
}
/**
 * Message sent from frontend to backend with user approval decision.
 */
export interface ToolApprovalResponseMessage {
    type: 'tool-approval-response';
    requestId: string;
    approved: boolean;
    message?: string;
    updatedInput?: unknown;
}
export declare namespace ToolApprovalRequestMessage {
    function is(obj: unknown): obj is ToolApprovalRequestMessage;
}
export declare namespace ToolApprovalResponseMessage {
    function is(obj: unknown): obj is ToolApprovalResponseMessage;
}
export type StreamMessage = SDKMessage | ToolApprovalRequestMessage;
export interface ClaudeCodeRequest {
    prompt: string;
    options?: Partial<ClaudeCodeOptions>;
}
export interface ClaudeCodeBackendRequest extends ClaudeCodeRequest {
    apiKey?: string;
    claudeCodePath?: string;
}
export declare const ClaudeCodeClient: unique symbol;
export interface ClaudeCodeClient {
    /**
     * @param token `undefined` signals end of stream.
     */
    sendToken(streamId: string, token?: StreamMessage): void;
    sendError(streamId: string, error: Error): void;
}
export declare const ClaudeCodeService: unique symbol;
export interface ClaudeCodeService {
    /**
     * Send a request to Claude Code.
     * @param request request parameters
     * @param streamId Pre-generated stream ID for tracking streaming responses
     */
    send(request: ClaudeCodeBackendRequest, streamId: string): Promise<void>;
    /**
     * Cancel a running request to Claude Code.
     * @param streamId Stream ID identifying the request
     */
    cancel(streamId: string): void;
    /**
     * Handle approval response from the frontend.
     * @param response approval response
     */
    handleApprovalResponse(response: ToolApprovalResponseMessage): void;
}
export type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
export interface NonNullableUsage {
    input_tokens: number;
    output_tokens: number;
    cache_creation_input_tokens?: number;
    cache_read_input_tokens?: number;
}
export interface Usage {
    input_tokens?: number;
    output_tokens?: number;
    cache_creation_input_tokens?: number;
    cache_read_input_tokens?: number;
}
export interface SDKMessageBase {
    uuid: string;
    session_id: string;
}
export type SDKUserMessage = SDKMessageBase & {
    type: 'user';
    message: {
        role: 'user';
        content: string | ContentBlock[];
    };
    parent_tool_use_id: string | null;
};
export interface TextBlock {
    type: 'text';
    text: string;
}
export interface ToolUseContentBlock {
    type: 'tool_use' | 'server_tool_use';
    id: string;
    name: string;
    input: Record<string, unknown>;
}
export interface ToolResultBlock {
    type: 'tool_result';
    tool_use_id: string;
    content: unknown;
    is_error?: boolean;
}
export interface ThinkingBlock {
    type: 'thinking';
    thinking: string;
    signature?: string;
}
export interface RedactedThinkingBlock {
    type: 'redacted_thinking';
    data: string;
}
export interface WebSearchToolResultBlock {
    type: 'web_search_tool_result';
    tool_use_id: string;
    content: Array<{
        title: string;
        url: string;
        [key: string]: unknown;
    }>;
}
export type ContentBlock = TextBlock | ToolUseContentBlock | ToolResultBlock | ThinkingBlock | RedactedThinkingBlock | WebSearchToolResultBlock;
export type SDKAssistantMessage = SDKMessageBase & {
    type: 'assistant';
    message: {
        id: string;
        type: 'message';
        role: 'assistant';
        content: ContentBlock[];
        model: string;
        stop_reason: string | null;
        stop_sequence: string | null;
        usage: Usage;
    };
    parent_tool_use_id: string | null;
};
export type SDKResultMessage = SDKMessageBase & {
    type: 'result';
    subtype: 'success' | 'error_max_turns' | 'error_during_execution';
    duration_ms: number;
    duration_api_ms: number;
    is_error: boolean;
    num_turns: number;
    total_cost_usd: number;
    usage: NonNullableUsage;
    permission_denials: Array<{
        tool_name: string;
        tool_use_id: string;
        tool_input: Record<string, unknown>;
    }>;
};
export type SDKSystemMessage = SDKMessageBase & {
    type: 'system';
    subtype: 'init';
    apiKeySource: string;
    cwd: string;
    tools: string[];
    mcp_servers: Array<{
        name: string;
        status: string;
    }>;
    model: string;
    permissionMode: PermissionMode;
    slash_commands: string[];
    output_style: string;
};
export type SDKMessage = SDKAssistantMessage | SDKUserMessage | SDKResultMessage | SDKSystemMessage;
export interface ClaudeCodeOptions {
    cwd?: string;
    abortController?: AbortController;
    additionalDirectories?: string[];
    allowedTools?: string[];
    appendSystemPrompt?: string;
    canUseTool?: (toolName: string, input: Record<string, unknown>, options: {
        signal: AbortController['signal'];
    }) => Promise<{
        behavior: 'allow' | 'deny';
        message?: string;
        updatedInput?: unknown;
    }>;
    continue?: boolean;
    systemPrompt?: string | {
        type: 'preset';
        preset: 'claude_code';
        append?: string;
    };
    disallowedTools?: string[];
    env?: Record<string, string>;
    executable?: 'bun' | 'deno' | 'node';
    executableArgs?: string[];
    extraArgs?: Record<string, string | null>;
    fallbackModel?: string;
    forkSession?: boolean;
    maxThinkingTokens?: number;
    maxTurns?: number;
    model?: string;
    pathToClaudeCodeExecutable?: string;
    permissionMode?: PermissionMode;
    permissionPromptToolName?: string;
    resume?: string;
    stderr?: (data: string) => void;
    strictMcpConfig?: boolean;
}
export interface TaskInput {
    description: string;
    prompt: string;
}
export interface EditInput {
    file_path: string;
    old_string: string;
    new_string: string;
}
export interface MultiEditInput {
    file_path: string;
    edits: Array<{
        old_string: string;
        new_string: string;
    }>;
}
export interface WriteInput {
    file_path: string;
    content: string;
}
export declare namespace TaskInput {
    function is(input: unknown): input is TaskInput;
}
export declare namespace EditInput {
    function is(input: unknown): input is EditInput;
}
export declare namespace MultiEditInput {
    function is(input: unknown): input is MultiEditInput;
}
export declare namespace WriteInput {
    function is(input: unknown): input is WriteInput;
}
export interface AskUserQuestionOption {
    label: string;
    description?: string;
}
export interface AskUserQuestionItem {
    question: string;
    header: string;
    options: AskUserQuestionOption[];
    multiSelect: boolean;
}
export interface AskUserQuestionInput {
    questions: AskUserQuestionItem[];
    answers?: Record<string, string>;
}
export declare namespace AskUserQuestionInput {
    function is(input: unknown): input is AskUserQuestionInput;
}
//# sourceMappingURL=claude-code-service.d.ts.map