import { APIResource } from "../../core/resource.js";
import { APIPromise } from "../../core/api-promise.js";
import { RequestOptions } from "../../internal/request-options.js";
/**
 * Control mouse, keyboard, and screen on the browser instance.
 */
export declare class Computer extends APIResource {
    /**
     * Send an array of computer actions to execute in order on the browser instance.
     * Execution stops on the first error. This reduces network latency compared to
     * sending individual action requests.
     *
     * @example
     * ```ts
     * await client.browsers.computer.batch('id', {
     *   actions: [{ type: 'click_mouse' }],
     * });
     * ```
     */
    batch(id: string, body: ComputerBatchParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Capture a screenshot of the browser instance
     *
     * @example
     * ```ts
     * const response =
     *   await client.browsers.computer.captureScreenshot('id');
     *
     * const content = await response.blob();
     * console.log(content);
     * ```
     */
    captureScreenshot(id: string, body?: ComputerCaptureScreenshotParams | null | undefined, options?: RequestOptions): APIPromise<Response>;
    /**
     * Simulate a mouse click action on the browser instance
     *
     * @example
     * ```ts
     * await client.browsers.computer.clickMouse('id', {
     *   x: 0,
     *   y: 0,
     * });
     * ```
     */
    clickMouse(id: string, body: ComputerClickMouseParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Drag the mouse along a path
     *
     * @example
     * ```ts
     * await client.browsers.computer.dragMouse('id', {
     *   path: [
     *     [0, 0],
     *     [0, 0],
     *   ],
     * });
     * ```
     */
    dragMouse(id: string, body: ComputerDragMouseParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Get the current mouse cursor position on the browser instance
     *
     * @example
     * ```ts
     * const response =
     *   await client.browsers.computer.getMousePosition('id');
     * ```
     */
    getMousePosition(id: string, options?: RequestOptions): APIPromise<ComputerGetMousePositionResponse>;
    /**
     * Move the mouse cursor to the specified coordinates on the browser instance
     *
     * @example
     * ```ts
     * await client.browsers.computer.moveMouse('id', {
     *   x: 0,
     *   y: 0,
     * });
     * ```
     */
    moveMouse(id: string, body: ComputerMoveMouseParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Press one or more keys on the host computer
     *
     * @example
     * ```ts
     * await client.browsers.computer.pressKey('id', {
     *   keys: ['string'],
     * });
     * ```
     */
    pressKey(id: string, body: ComputerPressKeyParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Read text from the clipboard on the browser instance
     *
     * @example
     * ```ts
     * const response =
     *   await client.browsers.computer.readClipboard('id');
     * ```
     */
    readClipboard(id: string, options?: RequestOptions): APIPromise<ComputerReadClipboardResponse>;
    /**
     * Scroll the mouse wheel at a position on the host computer
     *
     * @example
     * ```ts
     * await client.browsers.computer.scroll('id', { x: 0, y: 0 });
     * ```
     */
    scroll(id: string, body: ComputerScrollParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Set cursor visibility
     *
     * @example
     * ```ts
     * const response =
     *   await client.browsers.computer.setCursorVisibility('id', {
     *     hidden: true,
     *   });
     * ```
     */
    setCursorVisibility(id: string, body: ComputerSetCursorVisibilityParams, options?: RequestOptions): APIPromise<ComputerSetCursorVisibilityResponse>;
    /**
     * Type text on the browser instance
     *
     * @example
     * ```ts
     * await client.browsers.computer.typeText('id', {
     *   text: 'text',
     * });
     * ```
     */
    typeText(id: string, body: ComputerTypeTextParams, options?: RequestOptions): APIPromise<void>;
    /**
     * Write text to the clipboard on the browser instance
     *
     * @example
     * ```ts
     * await client.browsers.computer.writeClipboard('id', {
     *   text: 'text',
     * });
     * ```
     */
    writeClipboard(id: string, body: ComputerWriteClipboardParams, options?: RequestOptions): APIPromise<void>;
}
export interface ComputerGetMousePositionResponse {
    /**
     * X coordinate of the cursor
     */
    x: number;
    /**
     * Y coordinate of the cursor
     */
    y: number;
}
export interface ComputerReadClipboardResponse {
    /**
     * Current clipboard text content
     */
    text: string;
}
/**
 * Generic OK response.
 */
export interface ComputerSetCursorVisibilityResponse {
    /**
     * Indicates success.
     */
    ok: boolean;
}
export interface ComputerBatchParams {
    /**
     * Ordered list of actions to execute. Execution stops on the first error.
     */
    actions: Array<ComputerBatchParams.Action>;
}
export declare namespace ComputerBatchParams {
    /**
     * A single computer action to execute as part of a batch. The `type` field selects
     * which action to perform, and the corresponding field contains the action
     * parameters. Exactly one action field matching the type must be provided.
     */
    interface Action {
        /**
         * The type of action to perform.
         */
        type: 'click_mouse' | 'move_mouse' | 'type_text' | 'press_key' | 'scroll' | 'drag_mouse' | 'set_cursor' | 'sleep';
        click_mouse?: Action.ClickMouse;
        drag_mouse?: Action.DragMouse;
        move_mouse?: Action.MoveMouse;
        press_key?: Action.PressKey;
        scroll?: Action.Scroll;
        set_cursor?: Action.SetCursor;
        /**
         * Pause execution for a specified duration.
         */
        sleep?: Action.Sleep;
        type_text?: Action.TypeText;
    }
    namespace Action {
        interface ClickMouse {
            /**
             * X coordinate of the click position
             */
            x: number;
            /**
             * Y coordinate of the click position
             */
            y: number;
            /**
             * Mouse button to interact with
             */
            button?: 'left' | 'right' | 'middle' | 'back' | 'forward';
            /**
             * Type of click action
             */
            click_type?: 'down' | 'up' | 'click';
            /**
             * Modifier keys to hold during the click
             */
            hold_keys?: Array<string>;
            /**
             * Number of times to repeat the click
             */
            num_clicks?: number;
        }
        interface DragMouse {
            /**
             * Ordered list of [x, y] coordinate pairs to move through while dragging. Must
             * contain at least 2 points.
             */
            path: Array<Array<number>>;
            /**
             * Mouse button to drag with
             */
            button?: 'left' | 'middle' | 'right';
            /**
             * Delay in milliseconds between button down and starting to move along the path.
             */
            delay?: number;
            /**
             * Target total duration in milliseconds for the entire drag movement when
             * smooth=true. Omit for automatic timing based on total path length.
             */
            duration_ms?: number;
            /**
             * Modifier keys to hold during the drag
             */
            hold_keys?: Array<string>;
            /**
             * Use human-like Bezier curves between path waypoints instead of linear
             * interpolation. When true, steps_per_segment and step_delay_ms are ignored.
             */
            smooth?: boolean;
            /**
             * Delay in milliseconds between relative steps while dragging (not the initial
             * delay).
             */
            step_delay_ms?: number;
            /**
             * Number of relative move steps per segment in the path. Minimum 1.
             */
            steps_per_segment?: number;
        }
        interface MoveMouse {
            /**
             * X coordinate to move the cursor to
             */
            x: number;
            /**
             * Y coordinate to move the cursor to
             */
            y: number;
            /**
             * Target total duration in milliseconds for the mouse movement when smooth=true.
             * Omit for automatic timing based on distance.
             */
            duration_ms?: number;
            /**
             * Modifier keys to hold during the move
             */
            hold_keys?: Array<string>;
            /**
             * Use human-like Bezier curve path instead of instant mouse movement.
             */
            smooth?: boolean;
        }
        interface PressKey {
            /**
             * List of key symbols to press. Each item should be a key symbol supported by
             * xdotool (see X11 keysym definitions). Examples include "Return", "Shift",
             * "Ctrl", "Alt", "F5". Items in this list could also be combinations, e.g.
             * "Ctrl+t" or "Ctrl+Shift+Tab".
             */
            keys: Array<string>;
            /**
             * Duration to hold the keys down in milliseconds. If omitted or 0, keys are
             * tapped.
             */
            duration?: number;
            /**
             * Optional modifier keys to hold during the key press sequence.
             */
            hold_keys?: Array<string>;
        }
        interface Scroll {
            /**
             * X coordinate at which to perform the scroll
             */
            x: number;
            /**
             * Y coordinate at which to perform the scroll
             */
            y: number;
            /**
             * Horizontal scroll amount in xdotool "wheel units." Positive scrolls right,
             * negative scrolls left.
             */
            delta_x?: number;
            /**
             * Vertical scroll amount in xdotool "wheel units." Positive scrolls down, negative
             * scrolls up.
             */
            delta_y?: number;
            /**
             * Modifier keys to hold during the scroll
             */
            hold_keys?: Array<string>;
        }
        interface SetCursor {
            /**
             * Whether the cursor should be hidden or visible
             */
            hidden: boolean;
        }
        /**
         * Pause execution for a specified duration.
         */
        interface Sleep {
            /**
             * Duration to sleep in milliseconds.
             */
            duration_ms: number;
        }
        interface TypeText {
            /**
             * Text to type on the browser instance
             */
            text: string;
            /**
             * Delay in milliseconds between keystrokes
             */
            delay?: number;
        }
    }
}
export interface ComputerCaptureScreenshotParams {
    region?: ComputerCaptureScreenshotParams.Region;
}
export declare namespace ComputerCaptureScreenshotParams {
    interface Region {
        /**
         * Height of the region in pixels
         */
        height: number;
        /**
         * Width of the region in pixels
         */
        width: number;
        /**
         * X coordinate of the region's top-left corner
         */
        x: number;
        /**
         * Y coordinate of the region's top-left corner
         */
        y: number;
    }
}
export interface ComputerClickMouseParams {
    /**
     * X coordinate of the click position
     */
    x: number;
    /**
     * Y coordinate of the click position
     */
    y: number;
    /**
     * Mouse button to interact with
     */
    button?: 'left' | 'right' | 'middle' | 'back' | 'forward';
    /**
     * Type of click action
     */
    click_type?: 'down' | 'up' | 'click';
    /**
     * Modifier keys to hold during the click
     */
    hold_keys?: Array<string>;
    /**
     * Number of times to repeat the click
     */
    num_clicks?: number;
}
export interface ComputerDragMouseParams {
    /**
     * Ordered list of [x, y] coordinate pairs to move through while dragging. Must
     * contain at least 2 points.
     */
    path: Array<Array<number>>;
    /**
     * Mouse button to drag with
     */
    button?: 'left' | 'middle' | 'right';
    /**
     * Delay in milliseconds between button down and starting to move along the path.
     */
    delay?: number;
    /**
     * Target total duration in milliseconds for the entire drag movement when
     * smooth=true. Omit for automatic timing based on total path length.
     */
    duration_ms?: number;
    /**
     * Modifier keys to hold during the drag
     */
    hold_keys?: Array<string>;
    /**
     * Use human-like Bezier curves between path waypoints instead of linear
     * interpolation. When true, steps_per_segment and step_delay_ms are ignored.
     */
    smooth?: boolean;
    /**
     * Delay in milliseconds between relative steps while dragging (not the initial
     * delay).
     */
    step_delay_ms?: number;
    /**
     * Number of relative move steps per segment in the path. Minimum 1.
     */
    steps_per_segment?: number;
}
export interface ComputerMoveMouseParams {
    /**
     * X coordinate to move the cursor to
     */
    x: number;
    /**
     * Y coordinate to move the cursor to
     */
    y: number;
    /**
     * Target total duration in milliseconds for the mouse movement when smooth=true.
     * Omit for automatic timing based on distance.
     */
    duration_ms?: number;
    /**
     * Modifier keys to hold during the move
     */
    hold_keys?: Array<string>;
    /**
     * Use human-like Bezier curve path instead of instant mouse movement.
     */
    smooth?: boolean;
}
export interface ComputerPressKeyParams {
    /**
     * List of key symbols to press. Each item should be a key symbol supported by
     * xdotool (see X11 keysym definitions). Examples include "Return", "Shift",
     * "Ctrl", "Alt", "F5". Items in this list could also be combinations, e.g.
     * "Ctrl+t" or "Ctrl+Shift+Tab".
     */
    keys: Array<string>;
    /**
     * Duration to hold the keys down in milliseconds. If omitted or 0, keys are
     * tapped.
     */
    duration?: number;
    /**
     * Optional modifier keys to hold during the key press sequence.
     */
    hold_keys?: Array<string>;
}
export interface ComputerScrollParams {
    /**
     * X coordinate at which to perform the scroll
     */
    x: number;
    /**
     * Y coordinate at which to perform the scroll
     */
    y: number;
    /**
     * Horizontal scroll amount in xdotool "wheel units." Positive scrolls right,
     * negative scrolls left.
     */
    delta_x?: number;
    /**
     * Vertical scroll amount in xdotool "wheel units." Positive scrolls down, negative
     * scrolls up.
     */
    delta_y?: number;
    /**
     * Modifier keys to hold during the scroll
     */
    hold_keys?: Array<string>;
}
export interface ComputerSetCursorVisibilityParams {
    /**
     * Whether the cursor should be hidden or visible
     */
    hidden: boolean;
}
export interface ComputerTypeTextParams {
    /**
     * Text to type on the browser instance
     */
    text: string;
    /**
     * Delay in milliseconds between keystrokes
     */
    delay?: number;
}
export interface ComputerWriteClipboardParams {
    /**
     * Text to write to the system clipboard
     */
    text: string;
}
export declare namespace Computer {
    export { type ComputerGetMousePositionResponse as ComputerGetMousePositionResponse, type ComputerReadClipboardResponse as ComputerReadClipboardResponse, type ComputerSetCursorVisibilityResponse as ComputerSetCursorVisibilityResponse, type ComputerBatchParams as ComputerBatchParams, type ComputerCaptureScreenshotParams as ComputerCaptureScreenshotParams, type ComputerClickMouseParams as ComputerClickMouseParams, type ComputerDragMouseParams as ComputerDragMouseParams, type ComputerMoveMouseParams as ComputerMoveMouseParams, type ComputerPressKeyParams as ComputerPressKeyParams, type ComputerScrollParams as ComputerScrollParams, type ComputerSetCursorVisibilityParams as ComputerSetCursorVisibilityParams, type ComputerTypeTextParams as ComputerTypeTextParams, type ComputerWriteClipboardParams as ComputerWriteClipboardParams, };
}
//# sourceMappingURL=computer.d.ts.map