import type { SandboxConfig, Sandbox, CreateSandboxOptions, ExecuteOptions, ExecuteResult, StreamCallbacks, FileWrite, ForkSandboxOptions, ForkSandboxResult, PromoteSandboxOptions, PromoteSandboxResult, RegistrationRequest, RegistrationResponse, ApiKey, CreateApiKeyOptions, CreateApiKeyResponse, UsageSummary, UsageHistoryResponse, UsageGranularity, SubscriptionResponse, Invoice, UpgradeOptions, Secret, CreateSecretOptions, InjectSecretsOptions, AgentSession, AgentEvent, CreateAgentSessionOptions, ListAgentSessionsOptions, ListAgentEventsOptions, AgentExecuteOptions, AgentContext, RegisterToolOptions, AgentRegisteredTool, InferenceOptions, InferenceResult, ReplSession, ReplExecuteResult, BenchmarkResult, BenchmarkHistoryResponse, BenchmarkSummary, EgressPolicy, EgressAuditEvent, ScreenshotOptions, ScreenshotResult, MouseOptions, KeyboardOptions, ScreenSize } from './types.js';
export declare class StateSetSandbox {
    private readonly transport;
    private readonly lifecycle;
    private readonly execution;
    private readonly billing;
    private readonly auth;
    private readonly secrets;
    private readonly agentSessions;
    private readonly webhooksService;
    private readonly templatesService;
    private readonly mcpService;
    private readonly monitoringService;
    private readonly checkpointsService;
    private readonly artifactsService;
    private readonly tunnelsService;
    private readonly auditService;
    private readonly replService;
    constructor(config: SandboxConfig);
    /**
     * Create a new sandbox
     */
    create(options?: CreateSandboxOptions): Promise<Sandbox>;
    /**
     * Get sandbox details
     */
    get(sandboxId: string): Promise<Sandbox>;
    /**
     * List all sandboxes for the organization
     */
    list(): Promise<{
        sandboxes: Sandbox[];
    }>;
    /**
     * Stop and delete a sandbox
     */
    stop(sandboxId: string): Promise<{
        success: boolean;
    }>;
    /**
     * Extend a sandbox lifetime by additional seconds
     */
    extend(sandboxId: string, additionalSeconds: number): Promise<Sandbox>;
    /**
     * Fork a sandbox into a new sandbox by checkpointing and restoring state.
     */
    fork(sandboxId: string, options?: ForkSandboxOptions): Promise<ForkSandboxResult>;
    /**
     * Promote a sandbox to a different isolation level.
     */
    promote(sandboxId: string, options: PromoteSandboxOptions): Promise<PromoteSandboxResult>;
    /**
     * Delete a sandbox (alias for stop)
     */
    delete(sandboxId: string): Promise<{
        success: boolean;
    }>;
    /**
     * Get sandbox status only (lightweight)
     */
    getStatus(sandboxId: string): Promise<{
        sandbox_id: string;
        status: string;
        expires_at: string;
        max_expires_at?: string;
        max_lifetime_seconds?: number;
        remaining_extend_seconds?: number;
        lifetime_used_seconds?: number;
        lifetime_used_percent?: number;
    }>;
    /**
     * Write files to the sandbox
     */
    writeFiles(sandboxId: string, files: FileWrite[]): Promise<{
        success: boolean;
        files_written: number;
    }>;
    /**
     * Write a single file to the sandbox
     */
    writeFile(sandboxId: string, path: string, content: string): Promise<void>;
    /**
     * Read a file from the sandbox (FR-3.3)
     */
    readFile(sandboxId: string, path: string): Promise<{
        path: string;
        content: string;
        size: number;
    }>;
    /**
     * Read a file and decode from base64
     */
    readFileContent(sandboxId: string, path: string): Promise<string>;
    /**
     * List files in a sandbox directory
     */
    listFiles(sandboxId: string, path?: string, options?: {
        recursive?: boolean;
    }): Promise<{
        files: Array<{
            name: string;
            path: string;
            type: 'file' | 'directory';
            size: number;
            modified_at: string;
        }>;
    }>;
    /**
     * Find files matching a glob pattern in the sandbox.
     */
    glob(sandboxId: string, pattern: string, path?: string): Promise<{
        files: Array<{
            name: string;
            path: string;
            type: 'file' | 'directory';
            size: number;
            modified_at: string;
        }>;
    }>;
    /**
     * Create a directory in the sandbox.
     */
    mkdir(sandboxId: string, path: string, recursive?: boolean): Promise<{
        success: boolean;
        path: string;
    }>;
    /**
     * Delete a file or directory from the sandbox.
     */
    deleteFile(sandboxId: string, path: string, recursive?: boolean): Promise<{
        success: boolean;
        path: string;
    }>;
    /**
     * Move or rename a file in the sandbox.
     */
    moveFile(sandboxId: string, source: string, destination: string): Promise<{
        success: boolean;
        source: string;
        destination: string;
    }>;
    /**
     * Copy a file or directory in the sandbox.
     */
    copyFile(sandboxId: string, source: string, destination: string, recursive?: boolean): Promise<{
        success: boolean;
        source: string;
        destination: string;
    }>;
    /**
     * Execute a command in the sandbox (non-streaming)
     */
    execute(sandboxId: string, options: Omit<ExecuteOptions, 'stream'>): Promise<ExecuteResult>;
    /**
     * Execute a command in the sandbox with streaming output
     */
    executeStream(sandboxId: string, options: Omit<ExecuteOptions, 'stream'>, callbacks: StreamCallbacks): Promise<void>;
    /**
     * Proxy an LLM inference request through the controller.
     *
     * The controller decrypts the org's API key secret and injects it
     * into the outbound request, so the API key never enters the sandbox.
     *
     * @example
     * ```ts
     * const result = await client.inference(sandboxId, {
     *   provider: 'anthropic',
     *   path: '/v1/messages',
     *   body: {
     *     model: 'claude-sonnet-4-5-20250929',
     *     messages: [{ role: 'user', content: 'Hello' }],
     *     max_tokens: 100,
     *   },
     * });
     * ```
     */
    inference(sandboxId: string, options: InferenceOptions): Promise<InferenceResult>;
    /**
     * List all API keys for the organization
     */
    listApiKeys(): Promise<{
        api_keys: ApiKey[];
    }>;
    /**
     * Create a new API key
     */
    createApiKey(options: CreateApiKeyOptions): Promise<CreateApiKeyResponse>;
    /**
     * Revoke an API key
     */
    revokeApiKey(keyId: string): Promise<{
        success: boolean;
    }>;
    /**
     * Get current billing period usage
     */
    getCurrentUsage(): Promise<UsageSummary>;
    /**
     * Get usage history
     */
    getUsageHistory(granularity?: UsageGranularity, options?: {
        start_date?: string;
        end_date?: string;
    }): Promise<UsageHistoryResponse>;
    /**
     * Get usage breakdown by sandbox
     */
    getUsageBySandbox(options?: {
        start_date?: string;
        end_date?: string;
    }): Promise<{
        start_date: string;
        end_date: string;
        sandboxes: Array<{
            sandbox_id: string;
            cpu_hours: number;
            memory_gb_hours: number;
            network_gb: number;
        }>;
    }>;
    /**
     * Get current subscription details
     */
    getSubscription(): Promise<SubscriptionResponse>;
    /**
     * Upgrade to a different plan
     * Returns a Stripe Checkout URL for payment
     */
    upgradePlan(options: UpgradeOptions): Promise<{
        url: string;
    }>;
    /**
     * Get Stripe billing portal URL
     */
    getBillingPortal(returnUrl: string): Promise<{
        url: string;
    }>;
    /**
     * List invoices
     */
    listInvoices(limit?: number): Promise<{
        invoices: Invoice[];
    }>;
    /**
     * List all secrets for the organization
     */
    listSecrets(): Promise<{
        secrets: Secret[];
    }>;
    /**
     * Create a new secret
     */
    createSecret(options: CreateSecretOptions): Promise<Secret>;
    /**
     * Update an existing secret
     */
    updateSecret(name: string, value: string): Promise<Secret>;
    /**
     * Delete a secret
     */
    deleteSecret(name: string): Promise<{
        success: boolean;
    }>;
    /**
     * Inject secrets into a sandbox
     */
    injectSecrets(sandboxId: string, options: InjectSecretsOptions): Promise<{
        success: boolean;
        secrets_injected: number;
    }>;
    /**
     * Create a new agent session
     *
     * Agent sessions enable autonomous AI coding loops that survive sandbox rotations.
     * The session manages sandbox lifecycle, checkpoints, and state persistence automatically.
     *
     * @example
     * ```ts
     * const { session } = await client.createAgentSession({
     *   name: 'refactor-auth',
     *   budget: { cost_cap_cents: 500, iteration_limit: 1000 },
     *   sandbox: { cpus: '2', memory: '4Gi', timeout_seconds: 3600 }
     * });
     * ```
     */
    createAgentSession(options?: CreateAgentSessionOptions): Promise<{
        session: AgentSession;
    }>;
    /**
     * Get an agent session by ID
     */
    getAgentSession(sessionId: string): Promise<{
        session: AgentSession;
    }>;
    /**
     * List agent sessions for the organization
     */
    listAgentSessions(options?: ListAgentSessionsOptions): Promise<{
        sessions: AgentSession[];
    }>;
    /**
     * Start an agent session (creates the initial sandbox)
     *
     * The session must be in 'pending' status to start.
     */
    startAgentSession(sessionId: string): Promise<{
        session: AgentSession;
    }>;
    /**
     * Pause an agent session
     *
     * Pausing stops the rotation timer but keeps the sandbox running.
     * The session can be resumed later.
     */
    pauseAgentSession(sessionId: string): Promise<{
        session: AgentSession;
    }>;
    /**
     * Resume a paused agent session
     */
    resumeAgentSession(sessionId: string): Promise<{
        session: AgentSession;
    }>;
    /**
     * Stop an agent session (graceful termination)
     *
     * This marks the session as completed and terminates the sandbox.
     */
    stopAgentSession(sessionId: string, reason?: string): Promise<{
        success: boolean;
    }>;
    /**
     * Cancel an agent session (force termination)
     *
     * This immediately terminates the session and sandbox.
     */
    cancelAgentSession(sessionId: string): Promise<{
        success: boolean;
    }>;
    /**
     * Execute a command in the agent session's current sandbox
     *
     * This is budget-checked and will fail if budget limits are exceeded.
     * Execution is automatically tracked in the event log.
     *
     * @example
     * ```ts
     * const result = await client.executeInAgentSession(sessionId, {
     *   command: ['python', 'analyze.py'],
     *   working_dir: '/workspace/src'
     * });
     * console.log(result.stdout);
     * ```
     */
    executeInAgentSession(sessionId: string, options: AgentExecuteOptions): Promise<ExecuteResult>;
    /**
     * Get events for an agent session
     *
     * Events are append-only and include all session activity:
     * executions, rotations, checkpoints, budget warnings, etc.
     *
     * @param sessionId - Session ID
     * @param options - Filter options
     */
    getAgentSessionEvents(sessionId: string, options?: ListAgentEventsOptions): Promise<{
        events: AgentEvent[];
        latestSequence?: number;
        latest_sequence?: number;
    }>;
    /**
     * Update the agent context
     *
     * Agent context persists across sandbox rotations and includes
     * working directory, environment variables, and custom state.
     */
    updateAgentContext(sessionId: string, context: Partial<AgentContext>): Promise<{
        context: AgentContext;
    }>;
    /**
     * Send heartbeat to keep session alive
     *
     * Returns success status.
     */
    agentSessionHeartbeat(sessionId: string): Promise<{
        success: boolean;
    }>;
    /**
     * Reattach to an existing session by client ID
     *
     * Useful for reconnecting after a disconnect. Returns the session
     * if found and still active, null otherwise.
     */
    reattachAgentSession(clientId: string): Promise<{
        session: AgentSession | null;
    }>;
    /**
     * Register a tool for the agent session
     *
     * Tools are persisted in the session's tool registry.
     */
    registerAgentTool(sessionId: string, options: RegisterToolOptions): Promise<{
        tool: AgentRegisteredTool;
    }>;
    /**
     * List registered tools for the session
     */
    listAgentTools(sessionId: string): Promise<{
        tools: AgentRegisteredTool[];
    }>;
    /**
     * Read a file from the agent session's sandbox
     */
    readAgentSessionFile(sessionId: string, path: string): Promise<{
        path: string;
        content: string;
        size?: number;
    }>;
    /**
     * Write files to the agent session's sandbox
     */
    writeAgentSessionFiles(sessionId: string, files: FileWrite[]): Promise<{
        success: boolean;
        files_written?: number;
        filesWritten?: number;
    }>;
    /**
     * Write a single file to the agent session's sandbox
     */
    writeAgentSessionFile(sessionId: string, path: string, content: string): Promise<void>;
    /**
     * Read file content (decoded from base64) from agent session
     */
    readAgentSessionFileContent(sessionId: string, path: string): Promise<string>;
    /**
     * Delete an agent session
     */
    deleteAgentSession(sessionId: string): Promise<{
        success: boolean;
    }>;
    /**
     * List files in an agent session's sandbox directory
     */
    listAgentSessionFiles(sessionId: string, path?: string): Promise<{
        path?: string;
        files: Array<Record<string, unknown>>;
    }>;
    /**
     * Create a tunnel for a sandbox port
     */
    createTunnel(sandboxId: string, options: {
        port: number;
        protocol?: 'http' | 'https';
        expires_in?: number;
        public?: boolean;
    }): Promise<{
        tunnel_id: string;
        sandbox_id: string;
        port: number;
        protocol: string;
        url: string;
        expires_at: string;
        token?: string;
    }>;
    /**
     * List active tunnels for a sandbox
     */
    listTunnels(sandboxId: string): Promise<{
        tunnels: Array<{
            tunnel_id: string;
            sandbox_id: string;
            port: number;
            protocol: string;
            url: string;
            expires_at: string;
        }>;
    }>;
    /**
     * Close an active tunnel
     */
    closeTunnel(tunnelId: string): Promise<{
        success: boolean;
    }>;
    /**
     * List available templates
     */
    listTemplates(filter?: {
        category?: string;
        search?: string;
    }): Promise<{
        templates: Array<{
            id: string;
            name: string;
            description: string;
            category: string;
            tags?: string[];
            config: {
                cpus: string;
                memory: string;
                timeout_seconds: number;
            };
        }>;
    }>;
    /**
     * Get a specific template with full details
     */
    getTemplate(templateId: string): Promise<{
        id: string;
        name: string;
        description: string;
        category: string;
        tags?: string[];
        config: {
            cpus: string;
            memory: string;
            timeout_seconds: number;
            env?: Record<string, string>;
            setup_commands?: string[];
        };
        files?: Array<{
            path: string;
            content: string;
        }>;
    }>;
    /**
     * Create a sandbox from a template
     */
    createFromTemplate(templateId: string, options?: {
        timeout_seconds?: number;
        env?: Record<string, string>;
        override_cpus?: string;
        override_memory?: string;
    }): Promise<Sandbox>;
    /**
     * Start an MCP server in the sandbox
     */
    startMCPServer(sandboxId: string, config: {
        name: string;
        command: string;
        args?: string[];
        env?: Record<string, string>;
        port?: number;
    }): Promise<{
        name: string;
        pid?: number;
        port: number;
        status: string;
    }>;
    /**
     * Stop an MCP server
     */
    stopMCPServer(sandboxId: string, name: string): Promise<void>;
    /**
     * List MCP servers in a sandbox
     */
    listMCPServers(sandboxId: string): Promise<{
        servers: Array<{
            name: string;
            pid?: number;
            port: number;
            status: string;
        }>;
    }>;
    /**
     * Get preset MCP server configurations
     */
    getMCPPresets(): Promise<{
        presets: Record<string, {
            name: string;
            command: string;
            args?: string[];
            env?: Record<string, string>;
        }>;
    }>;
    /**
     * Get current resource metrics for a sandbox
     */
    getMetrics(sandboxId: string): Promise<{
        metrics: {
            timestamp: string;
            cpu: {
                usage: number;
                limit: number;
                percentage: number;
            };
            memory: {
                usage: number;
                limit: number;
                percentage: number;
            };
            storage: {
                usage: number;
                limit: number;
            };
        } | null;
    }>;
    /**
     * Get metrics history
     */
    getMetricsHistory(sandboxId: string, limit?: number): Promise<{
        history: Array<{
            timestamp: string;
            cpu: {
                usage: number;
                limit: number;
                percentage: number;
            };
            memory: {
                usage: number;
                limit: number;
                percentage: number;
            };
        }>;
    }>;
    /**
     * Get aggregated metrics summary
     */
    getMetricsSummary(sandboxId: string): Promise<{
        summary: {
            avg: {
                cpu: number;
                memory: number;
            };
            max: {
                cpu: number;
                memory: number;
            };
            min: {
                cpu: number;
                memory: number;
            };
            duration: number;
        } | null;
    }>;
    /**
     * Create a checkpoint of sandbox state
     */
    createCheckpoint(sandboxId: string, options: {
        name: string;
        description?: string;
        include_paths?: string[];
        exclude_paths?: string[];
        include_env?: boolean;
    }): Promise<{
        id: string;
        sandbox_id: string;
        name: string;
        description?: string;
        size: number;
        file_count: number;
        checksum: string;
        created_at: string;
        metadata?: Record<string, unknown>;
    }>;
    /**
     * Restore a checkpoint to a sandbox
     */
    restoreCheckpoint(sandboxId: string, checkpointId: string, options?: {
        restore_files?: boolean;
        restore_env?: boolean;
        overwrite?: boolean;
    }): Promise<{
        success: boolean;
    }>;
    /**
     * List checkpoints
     */
    listCheckpoints(filter?: {
        sandbox_id?: string;
        name?: string;
    }): Promise<{
        checkpoints: Array<{
            id: string;
            sandbox_id: string;
            name: string;
            description?: string;
            size: number;
            file_count: number;
            checksum: string;
            created_at: string;
            metadata?: Record<string, unknown>;
        }>;
    }>;
    /**
     * Get checkpoint details
     */
    getCheckpoint(checkpointId: string): Promise<{
        id: string;
        sandbox_id: string;
        name: string;
        description?: string;
        created_at: string;
        size: number;
        file_count: number;
        checksum: string;
    }>;
    /**
     * Clone a checkpoint
     */
    cloneCheckpoint(checkpointId: string, name: string): Promise<{
        id: string;
        sandbox_id: string;
        name: string;
        description?: string;
        size: number;
        file_count: number;
        checksum: string;
        created_at: string;
        metadata?: Record<string, unknown>;
    }>;
    /**
     * Compare two checkpoints
     */
    compareCheckpoints(checkpointId1: string, checkpointId2: string): Promise<{
        checkpoint_1: {
            id: string;
            name: string;
        };
        checkpoint_2: {
            id: string;
            name: string;
        };
        diff: {
            added: string[];
            removed: string[];
            modified: string[];
        };
    }>;
    /**
     * Delete a checkpoint
     */
    deleteCheckpoint(checkpointId: string): Promise<{
        success: boolean;
    }>;
    /**
     * Upload a file from sandbox to artifact storage
     */
    uploadArtifact(sandboxId: string, options: {
        path: string;
        remote_path?: string;
        content_type?: string;
        expires_in?: number;
        metadata?: Record<string, string>;
    }): Promise<{
        id: string;
        sandbox_id: string;
        org_id?: string;
        path: string;
        remote_path?: string | null;
        size: number;
        checksum: string;
        content_type?: string | null;
        created_at: string;
        expires_at?: string | null;
        metadata?: Record<string, string> | null;
    }>;
    /**
     * Download an artifact to sandbox
     */
    downloadArtifact(sandboxId: string, artifactId: string, targetPath: string): Promise<{
        success: boolean;
    }>;
    /**
     * List artifacts
     */
    listArtifacts(sandboxId?: string): Promise<{
        artifacts: Array<{
            id: string;
            sandbox_id: string;
            org_id?: string;
            path: string;
            remote_path?: string | null;
            size: number;
            checksum: string;
            content_type?: string | null;
            created_at: string;
            expires_at?: string | null;
            metadata?: Record<string, string> | null;
        }>;
    }>;
    /**
     * Get artifact details
     */
    getArtifact(artifactId: string): Promise<{
        id: string;
        sandbox_id: string;
        org_id?: string;
        path: string;
        remote_path?: string | null;
        size: number;
        checksum: string;
        content_type?: string | null;
        created_at: string;
        expires_at?: string | null;
        metadata?: Record<string, string> | null;
    }>;
    /**
     * Get presigned URL for artifact download
     */
    getArtifactUrl(artifactId: string, expiresIn?: number): Promise<{
        url: string;
        expires_in: number;
    }>;
    /**
     * Delete an artifact
     */
    deleteArtifact(artifactId: string): Promise<{
        success: boolean;
    }>;
    /**
     * Register a webhook
     */
    registerWebhook(config: {
        url: string;
        events?: string[] | '*';
        secret?: string;
        headers?: Record<string, string>;
    }): Promise<{
        id: string;
        url: string;
        events: string[] | '*';
        enabled: boolean;
        created_at: string;
    }>;
    /**
     * List webhooks
     */
    listWebhooks(): Promise<{
        webhooks: Array<{
            id: string;
            url: string;
            events: string[] | '*';
            enabled: boolean;
        }>;
    }>;
    /**
     * Delete a webhook
     */
    deleteWebhook(webhookId: string): Promise<{
        success: boolean;
    }>;
    /**
     * Test a webhook
     */
    testWebhook(webhookId: string): Promise<{
        success: boolean;
        status?: number;
        error?: string;
    }>;
    /**
     * Get webhook delivery history
     */
    getWebhookDeliveries(webhookId: string, limit?: number): Promise<{
        deliveries: Array<{
            id: string;
            event: string;
            status: string;
            attempts: number;
            created_at: string;
        }>;
    }>;
    /**
     * Query audit events
     */
    queryAudit(filter?: {
        sandbox_id?: string;
        action?: string;
        start_time?: Date | string;
        end_time?: Date | string;
        outcome?: string;
        limit?: number;
        offset?: number;
    }): Promise<{
        events: Array<{
            id: string;
            timestamp: string;
            sandbox_id: string;
            action: string;
            resource: string;
            outcome: string;
        }>;
        total: number;
    }>;
    /**
     * Get audit summary for a sandbox
     */
    getAuditSummary(sandboxId: string): Promise<{
        total_events: number;
        commands_executed: number;
        files_written: number;
        files_read: number;
        secrets_accessed: number;
        errors: number;
    }>;
    /**
     * Create a new REPL session in a sandbox
     *
     * @param sandboxId - Sandbox ID
     * @param language - Language / kernel name (e.g. 'python3', 'node')
     */
    createReplSession(sandboxId: string, language?: string): Promise<ReplSession>;
    /**
     * List REPL sessions for a sandbox
     */
    listReplSessions(sandboxId: string): Promise<ReplSession[]>;
    /**
     * Get a specific REPL session
     */
    getReplSession(sandboxId: string, sessionId: string): Promise<ReplSession>;
    /**
     * Execute code in a REPL session
     *
     * @param sandboxId - Sandbox ID
     * @param sessionId - REPL session ID
     * @param code - Code to execute
     * @param timeoutMs - Optional execution timeout in milliseconds
     */
    executeReplCode(sandboxId: string, sessionId: string, code: string, timeoutMs?: number): Promise<ReplExecuteResult>;
    /**
     * Interrupt execution in a REPL session
     */
    interruptReplSession(sandboxId: string, sessionId: string): Promise<void>;
    /**
     * Delete a REPL session
     */
    deleteReplSession(sandboxId: string, sessionId: string): Promise<void>;
    /**
     * Run a benchmark to measure sandbox creation and execution latency
     *
     * @param runs - Number of benchmark runs (default determined by server)
     */
    runBenchmark(runs?: number): Promise<BenchmarkResult>;
    /**
     * Get benchmark history
     *
     * @param options - Filter options for history query
     */
    getBenchmarkHistory(options?: {
        limit?: number;
        offset?: number;
        days?: number;
        region?: string;
    }): Promise<BenchmarkHistoryResponse>;
    /**
     * Get benchmark summary statistics
     */
    getBenchmarkSummary(): Promise<BenchmarkSummary>;
    /**
     * Get the current egress policy for the organization
     */
    getEgressPolicy(): Promise<EgressPolicy>;
    /**
     * Set the egress policy for the organization
     *
     * @param policy - Egress policy configuration
     */
    setEgressPolicy(policy: EgressPolicy): Promise<EgressPolicy>;
    /**
     * Query egress audit events
     *
     * @param options - Filter options for the audit query
     */
    queryEgressAudit(options?: {
        sandbox_id?: string;
        host?: string;
        decision?: string;
        limit?: number;
        offset?: number;
    }): Promise<EgressAuditEvent[]>;
    /**
     * Capture a screenshot of the sandbox desktop
     *
     * Requires a desktop sandbox (computer-use image with DISPLAY env var).
     *
     * @example
     * ```ts
     * const result = await client.screenshot(sandboxId);
     * const imageBuffer = Buffer.from(result.image, 'base64');
     * ```
     */
    screenshot(sandboxId: string, options?: ScreenshotOptions): Promise<ScreenshotResult>;
    /**
     * Perform a mouse action in the sandbox desktop
     *
     * @example
     * ```ts
     * await client.mouse(sandboxId, { action: 'click', x: 100, y: 200 });
     * await client.mouse(sandboxId, { action: 'drag', x: 100, y: 200, endX: 300, endY: 400 });
     * ```
     */
    mouse(sandboxId: string, options: MouseOptions): Promise<{
        success: boolean;
    }>;
    /**
     * Perform a keyboard action in the sandbox desktop
     *
     * @example
     * ```ts
     * await client.keyboard(sandboxId, { action: 'type', text: 'Hello World' });
     * await client.keyboard(sandboxId, { action: 'key', key: 'Return' });
     * await client.keyboard(sandboxId, { action: 'hotkey', keys: ['ctrl', 'c'] });
     * ```
     */
    keyboard(sandboxId: string, options: KeyboardOptions): Promise<{
        success: boolean;
    }>;
    /**
     * Get the screen dimensions of the sandbox desktop
     */
    getScreenSize(sandboxId: string): Promise<ScreenSize>;
    /**
     * Get warm pool statistics
     */
    getPoolStats(): Promise<{
        total: number;
        ready: number;
        creating: number;
    }>;
    private request;
}
export interface RegisterOptions {
    /**
     * Request timeout in milliseconds
     * @default 30000
     */
    timeout?: number;
}
/**
 * Register a new organization and user
 * This is a static method that doesn't require authentication
 */
export declare function register(baseUrl: string, request: RegistrationRequest, options?: RegisterOptions): Promise<RegistrationResponse>;
//# sourceMappingURL=client.d.ts.map