@daytonaio/sdk 0.175.0 → 0.178.0

package/esm/ComputerUse.js

@@ -2,623 +2,727 @@
  * Copyright Daytona Platforms Inc.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { __decorate, __metadata } from "tslib";
+import { __esDecorate, __runInitializers } from "tslib";
 import * as pathe from 'pathe';
 import { dynamicImport } from './utils/Import.js';
 import { WithInstrumentation } from './utils/otel.decorator.js';
 /**
  * Mouse operations for computer use functionality
  */
-export class Mouse {
-    apiClient;
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    /**
-     * Gets the current mouse cursor position
-     *
-     * @returns {Promise<MousePositionResponse>} Current mouse position with x and y coordinates
-     *
-     * @example
-     * ```typescript
-     * const position = await sandbox.computerUse.mouse.getPosition();
-     * console.log(`Mouse is at: ${position.x}, ${position.y}`);
-     * ```
-     */
-    async getPosition() {
-        const response = await this.apiClient.getMousePosition();
-        return response.data;
-    }
-    /**
-     * Moves the mouse cursor to the specified coordinates
-     *
-     * @param {number} x - The x coordinate to move to
-     * @param {number} y - The y coordinate to move to
-     * @returns {Promise<MousePositionResponse>} Position after move
-     *
-     * @example
-     * ```typescript
-     * const result = await sandbox.computerUse.mouse.move(100, 200);
-     * console.log(`Mouse moved to: ${result.x}, ${result.y}`);
-     * ```
-     */
-    async move(x, y) {
-        const request = { x, y };
-        const response = await this.apiClient.moveMouse(request);
-        return response.data;
-    }
-    /**
-     * Clicks the mouse at the specified coordinates
-     *
-     * @param {number} x - The x coordinate to click at
-     * @param {number} y - The y coordinate to click at
-     * @param {string} [button='left'] - The mouse button to click ('left', 'right', 'middle')
-     * @param {boolean} [double=false] - Whether to perform a double-click
-     * @returns {Promise<MouseClickResponse>} Click operation result
-     *
-     * @example
-     * ```typescript
-     * // Single left click
-     * const result = await sandbox.computerUse.mouse.click(100, 200);
-     *
-     * // Double click
-     * const doubleClick = await sandbox.computerUse.mouse.click(100, 200, 'left', true);
-     *
-     * // Right click
-     * const rightClick = await sandbox.computerUse.mouse.click(100, 200, 'right');
-     * ```
-     */
-    async click(x, y, button = 'left', double = false) {
-        const request = { x, y, button, double };
-        const response = await this.apiClient.click(request);
-        return response.data;
-    }
-    /**
-     * Drags the mouse from start coordinates to end coordinates
-     *
-     * @param {number} startX - The starting x coordinate
-     * @param {number} startY - The starting y coordinate
-     * @param {number} endX - The ending x coordinate
-     * @param {number} endY - The ending y coordinate
-     * @param {string} [button='left'] - The mouse button to use for dragging
-     * @returns {Promise<MouseDragResponse>} Drag operation result
-     *
-     * @example
-     * ```typescript
-     * const result = await sandbox.computerUse.mouse.drag(50, 50, 150, 150);
-     * console.log(`Drag ended at: ${result.x}, ${result.y}`);
-     * ```
-     */
-    async drag(startX, startY, endX, endY, button = 'left') {
-        const request = { startX, startY, endX, endY, button };
-        const response = await this.apiClient.drag(request);
-        return response.data;
-    }
-    /**
-     * Scrolls the mouse wheel at the specified coordinates
-     *
-     * @param {number} x - The x coordinate to scroll at
-     * @param {number} y - The y coordinate to scroll at
-     * @param {'up' | 'down'} direction - The direction to scroll
-     * @param {number} [amount=1] - The amount to scroll
-     * @returns {Promise<boolean>} Whether the scroll operation was successful
-     *
-     * @example
-     * ```typescript
-     * // Scroll up
-     * const scrollUp = await sandbox.computerUse.mouse.scroll(100, 200, 'up', 3);
-     *
-     * // Scroll down
-     * const scrollDown = await sandbox.computerUse.mouse.scroll(100, 200, 'down', 5);
-     * ```
-     */
-    async scroll(x, y, direction, amount = 1) {
-        const request = { x, y, direction, amount };
-        const response = await this.apiClient.scroll(request);
-        return response.data.success;
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Mouse.prototype, "getPosition", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Number]),
-    __metadata("design:returntype", Promise)
-], Mouse.prototype, "move", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Number, Object, Object]),
-    __metadata("design:returntype", Promise)
-], Mouse.prototype, "click", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Number, Number, Number, Object]),
-    __metadata("design:returntype", Promise)
-], Mouse.prototype, "drag", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number, Number, String, Object]),
-    __metadata("design:returntype", Promise)
-], Mouse.prototype, "scroll", null);
+let Mouse = (() => {
+    let _instanceExtraInitializers = [];
+    let _getPosition_decorators;
+    let _move_decorators;
+    let _click_decorators;
+    let _drag_decorators;
+    let _scroll_decorators;
+    return class Mouse {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getPosition_decorators = [WithInstrumentation()];
+            _move_decorators = [WithInstrumentation()];
+            _click_decorators = [WithInstrumentation()];
+            _drag_decorators = [WithInstrumentation()];
+            _scroll_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _getPosition_decorators, { kind: "method", name: "getPosition", static: false, private: false, access: { has: obj => "getPosition" in obj, get: obj => obj.getPosition }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _move_decorators, { kind: "method", name: "move", static: false, private: false, access: { has: obj => "move" in obj, get: obj => obj.move }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _click_decorators, { kind: "method", name: "click", static: false, private: false, access: { has: obj => "click" in obj, get: obj => obj.click }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _drag_decorators, { kind: "method", name: "drag", static: false, private: false, access: { has: obj => "drag" in obj, get: obj => obj.drag }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _scroll_decorators, { kind: "method", name: "scroll", static: false, private: false, access: { has: obj => "scroll" in obj, get: obj => obj.scroll }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        apiClient = __runInitializers(this, _instanceExtraInitializers);
+        constructor(apiClient) {
+            this.apiClient = apiClient;
+        }
+        /**
+         * Gets the current mouse cursor position
+         *
+         * @returns {Promise<MousePositionResponse>} Current mouse position with x and y coordinates
+         *
+         * @example
+         * ```typescript
+         * const position = await sandbox.computerUse.mouse.getPosition();
+         * console.log(`Mouse is at: ${position.x}, ${position.y}`);
+         * ```
+         */
+        async getPosition() {
+            const response = await this.apiClient.getMousePosition();
+            return response.data;
+        }
+        /**
+         * Moves the mouse cursor to the specified coordinates
+         *
+         * @param {number} x - The x coordinate to move to
+         * @param {number} y - The y coordinate to move to
+         * @returns {Promise<MousePositionResponse>} Position after move
+         *
+         * @example
+         * ```typescript
+         * const result = await sandbox.computerUse.mouse.move(100, 200);
+         * console.log(`Mouse moved to: ${result.x}, ${result.y}`);
+         * ```
+         */
+        async move(x, y) {
+            const request = { x, y };
+            const response = await this.apiClient.moveMouse(request);
+            return response.data;
+        }
+        /**
+         * Clicks the mouse at the specified coordinates
+         *
+         * @param {number} x - The x coordinate to click at
+         * @param {number} y - The y coordinate to click at
+         * @param {string} [button='left'] - The mouse button to click ('left', 'right', 'middle')
+         * @param {boolean} [double=false] - Whether to perform a double-click
+         * @returns {Promise<MouseClickResponse>} Click operation result
+         *
+         * @example
+         * ```typescript
+         * // Single left click
+         * const result = await sandbox.computerUse.mouse.click(100, 200);
+         *
+         * // Double click
+         * const doubleClick = await sandbox.computerUse.mouse.click(100, 200, 'left', true);
+         *
+         * // Right click
+         * const rightClick = await sandbox.computerUse.mouse.click(100, 200, 'right');
+         * ```
+         */
+        async click(x, y, button = 'left', double = false) {
+            const request = { x, y, button, double };
+            const response = await this.apiClient.click(request);
+            return response.data;
+        }
+        /**
+         * Drags the mouse from start coordinates to end coordinates
+         *
+         * @param {number} startX - The starting x coordinate
+         * @param {number} startY - The starting y coordinate
+         * @param {number} endX - The ending x coordinate
+         * @param {number} endY - The ending y coordinate
+         * @param {string} [button='left'] - The mouse button to use for dragging
+         * @returns {Promise<MouseDragResponse>} Drag operation result
+         *
+         * @example
+         * ```typescript
+         * const result = await sandbox.computerUse.mouse.drag(50, 50, 150, 150);
+         * console.log(`Drag ended at: ${result.x}, ${result.y}`);
+         * ```
+         */
+        async drag(startX, startY, endX, endY, button = 'left') {
+            const request = { startX, startY, endX, endY, button };
+            const response = await this.apiClient.drag(request);
+            return response.data;
+        }
+        /**
+         * Scrolls the mouse wheel at the specified coordinates
+         *
+         * @param {number} x - The x coordinate to scroll at
+         * @param {number} y - The y coordinate to scroll at
+         * @param {'up' | 'down'} direction - The direction to scroll
+         * @param {number} [amount=1] - The amount to scroll
+         * @returns {Promise<boolean>} Whether the scroll operation was successful
+         *
+         * @example
+         * ```typescript
+         * // Scroll up
+         * const scrollUp = await sandbox.computerUse.mouse.scroll(100, 200, 'up', 3);
+         *
+         * // Scroll down
+         * const scrollDown = await sandbox.computerUse.mouse.scroll(100, 200, 'down', 5);
+         * ```
+         */
+        async scroll(x, y, direction, amount = 1) {
+            const request = { x, y, direction, amount };
+            const response = await this.apiClient.scroll(request);
+            return response.data.success;
+        }
+    };
+})();
+export { Mouse };
 /**
  * Keyboard operations for computer use functionality
  */
-export class Keyboard {
-    apiClient;
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    /**
-     * Types the specified text
-     *
-     * @param {string} text - The text to type
-     * @param {number} [delay=0] - Delay between characters in milliseconds
-     * @throws {DaytonaError} If the type operation fails
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   await sandbox.computerUse.keyboard.type('Hello, World!');
-     *   console.log('Operation success');
-     * } catch (e) {
-     *   console.log('Operation failed:', e);
-     * }
-     *
-     * // With delay between characters
-     * try {
-     *   await sandbox.computerUse.keyboard.type('Slow typing', 100);
-     *   console.log('Operation success');
-     * } catch (e) {
-     *   console.log('Operation failed:', e);
-     * }
-     * ```
-     */
-    async type(text, delay) {
-        const request = { text, delay };
-        await this.apiClient.typeText(request);
-    }
-    /**
-     * Presses a key with optional modifiers
-     *
-     * @param {string} key - The key to press. Canonical names include 'enter', 'escape', 'tab', letters, digits, unshifted punctuation, function keys, and grammar-safe numpad names such as 'num_plus'. Named keys are case-insensitive, and common aliases such as 'Return' and 'Escape' are normalized.
-     * @param {string[]} [modifiers=[]] - Canonical modifier names are 'ctrl', 'alt', 'shift', and 'cmd'. Common aliases such as 'control', 'option', 'meta', and 'win' are normalized.
-     * @throws {DaytonaError} If the press operation fails
-     *
-     * @example
-     * ```typescript
-     * // Press Enter
-     * try {
-     *   await sandbox.computerUse.keyboard.press('enter');
-     *   console.log('Operation success');
-     * } catch (e) {
-     *   console.log('Operation failed:', e);
-     * }
-     *
-     * // Press Ctrl+C
-     * try {
-     *   await sandbox.computerUse.keyboard.press('c', ['ctrl']);
-     *   console.log('Operation success');
-     * } catch (e) {
-     *   console.log('Operation failed:', e);
-     * }
-     *
-     * // Press Ctrl+Shift+T
-     * try {
-     *   await sandbox.computerUse.keyboard.press('t', ['ctrl', 'shift']);
-     *   console.log('Operation success');
-     * } catch (e) {
-     *   console.log('Operation failed:', e);
-     * }
-     * ```
-     */
-    async press(key, modifiers = []) {
-        const request = { key, modifiers };
-        await this.apiClient.pressKey(request);
-    }
-    /**
-     * Presses a hotkey combination
-     *
-     * @param {string} keys - A single atomic hotkey chord (e.g., 'ctrl+c', 'alt+tab', 'cmd+shift+t', 'ctrl + c', 'shift'). Uses the same normalized key contract as `press()`.
-     * @throws {DaytonaError} If the hotkey operation fails
-     *
-     * @example
-     * ```typescript
-     * // Copy
-     * try {
-     *   await sandbox.computerUse.keyboard.hotkey('ctrl+c');
-     *   console.log('Operation success');
-     * } catch (e) {
-     *   console.log('Operation failed:', e);
-     * }
-     *
-     * // Paste
-     * try {
-     *   await sandbox.computerUse.keyboard.hotkey('ctrl+v');
-     *   console.log('Operation success');
-     * } catch (e) {
-     *   console.log('Operation failed:', e);
-     * }
-     *
-     * // Alt+Tab
-     * try {
-     *   await sandbox.computerUse.keyboard.hotkey('alt+tab');
-     *   console.log('Operation success');
-     * } catch (e) {
-     *   console.log('Operation failed:', e);
-     * }
-     * ```
-     */
-    async hotkey(keys) {
-        const request = { keys };
-        await this.apiClient.pressHotkey(request);
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Number]),
-    __metadata("design:returntype", Promise)
-], Keyboard.prototype, "type", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Array]),
-    __metadata("design:returntype", Promise)
-], Keyboard.prototype, "press", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], Keyboard.prototype, "hotkey", null);
+let Keyboard = (() => {
+    let _instanceExtraInitializers = [];
+    let _type_decorators;
+    let _press_decorators;
+    let _hotkey_decorators;
+    return class Keyboard {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _type_decorators = [WithInstrumentation()];
+            _press_decorators = [WithInstrumentation()];
+            _hotkey_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _type_decorators, { kind: "method", name: "type", static: false, private: false, access: { has: obj => "type" in obj, get: obj => obj.type }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _press_decorators, { kind: "method", name: "press", static: false, private: false, access: { has: obj => "press" in obj, get: obj => obj.press }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _hotkey_decorators, { kind: "method", name: "hotkey", static: false, private: false, access: { has: obj => "hotkey" in obj, get: obj => obj.hotkey }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        apiClient = __runInitializers(this, _instanceExtraInitializers);
+        constructor(apiClient) {
+            this.apiClient = apiClient;
+        }
+        /**
+         * Types the specified text
+         *
+         * @param {string} text - The text to type
+         * @param {number} [delay=0] - Delay between characters in milliseconds
+         * @throws {DaytonaError} If the type operation fails
+         *
+         * @example
+         * ```typescript
+         * try {
+         *   await sandbox.computerUse.keyboard.type('Hello, World!');
+         *   console.log('Operation success');
+         * } catch (e) {
+         *   console.log('Operation failed:', e);
+         * }
+         *
+         * // With delay between characters
+         * try {
+         *   await sandbox.computerUse.keyboard.type('Slow typing', 100);
+         *   console.log('Operation success');
+         * } catch (e) {
+         *   console.log('Operation failed:', e);
+         * }
+         * ```
+         */
+        async type(text, delay) {
+            const request = { text, delay };
+            await this.apiClient.typeText(request);
+        }
+        /**
+         * Presses a key with optional modifiers
+         *
+         * @param {string} key - The key to press. Canonical names include 'enter', 'escape', 'tab', letters, digits, unshifted punctuation, function keys, and grammar-safe numpad names such as 'num_plus'. Named keys are case-insensitive, and common aliases such as 'Return' and 'Escape' are normalized.
+         * @param {string[]} [modifiers=[]] - Canonical modifier names are 'ctrl', 'alt', 'shift', and 'cmd'. Common aliases such as 'control', 'option', 'meta', and 'win' are normalized.
+         * @throws {DaytonaError} If the press operation fails
+         *
+         * @example
+         * ```typescript
+         * // Press Enter
+         * try {
+         *   await sandbox.computerUse.keyboard.press('enter');
+         *   console.log('Operation success');
+         * } catch (e) {
+         *   console.log('Operation failed:', e);
+         * }
+         *
+         * // Press Ctrl+C
+         * try {
+         *   await sandbox.computerUse.keyboard.press('c', ['ctrl']);
+         *   console.log('Operation success');
+         * } catch (e) {
+         *   console.log('Operation failed:', e);
+         * }
+         *
+         * // Press Ctrl+Shift+T
+         * try {
+         *   await sandbox.computerUse.keyboard.press('t', ['ctrl', 'shift']);
+         *   console.log('Operation success');
+         * } catch (e) {
+         *   console.log('Operation failed:', e);
+         * }
+         * ```
+         */
+        async press(key, modifiers = []) {
+            const request = { key, modifiers };
+            await this.apiClient.pressKey(request);
+        }
+        /**
+         * Presses a hotkey combination
+         *
+         * @param {string} keys - A single atomic hotkey chord (e.g., 'ctrl+c', 'alt+tab', 'cmd+shift+t', 'ctrl + c', 'shift'). Uses the same normalized key contract as `press()`.
+         * @throws {DaytonaError} If the hotkey operation fails
+         *
+         * @example
+         * ```typescript
+         * // Copy
+         * try {
+         *   await sandbox.computerUse.keyboard.hotkey('ctrl+c');
+         *   console.log('Operation success');
+         * } catch (e) {
+         *   console.log('Operation failed:', e);
+         * }
+         *
+         * // Paste
+         * try {
+         *   await sandbox.computerUse.keyboard.hotkey('ctrl+v');
+         *   console.log('Operation success');
+         * } catch (e) {
+         *   console.log('Operation failed:', e);
+         * }
+         *
+         * // Alt+Tab
+         * try {
+         *   await sandbox.computerUse.keyboard.hotkey('alt+tab');
+         *   console.log('Operation success');
+         * } catch (e) {
+         *   console.log('Operation failed:', e);
+         * }
+         * ```
+         */
+        async hotkey(keys) {
+            const request = { keys };
+            await this.apiClient.pressHotkey(request);
+        }
+    };
+})();
+export { Keyboard };
 /**
  * Screenshot operations for computer use functionality
  */
-export class Screenshot {
-    apiClient;
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    /**
-     * Takes a screenshot of the entire screen
-     *
-     * @param {boolean} [showCursor=false] - Whether to show the cursor in the screenshot
-     * @returns {Promise<ScreenshotResponse>} Screenshot data with base64 encoded image
-     *
-     * @example
-     * ```typescript
-     * const screenshot = await sandbox.computerUse.screenshot.takeFullScreen();
-     * console.log(`Screenshot size: ${screenshot.width}x${screenshot.height}`);
-     *
-     * // With cursor visible
-     * const withCursor = await sandbox.computerUse.screenshot.takeFullScreen(true);
-     * ```
-     */
-    async takeFullScreen(showCursor = false) {
-        const response = await this.apiClient.takeScreenshot(showCursor);
-        return response.data;
-    }
-    /**
-     * Takes a screenshot of a specific region
-     *
-     * @param {ScreenshotRegion} region - The region to capture
-     * @param {boolean} [showCursor=false] - Whether to show the cursor in the screenshot
-     * @returns {Promise<RegionScreenshotResponse>} Screenshot data with base64 encoded image
-     *
-     * @example
-     * ```typescript
-     * const region = { x: 100, y: 100, width: 300, height: 200 };
-     * const screenshot = await sandbox.computerUse.screenshot.takeRegion(region);
-     * console.log(`Captured region: ${screenshot.region.width}x${screenshot.region.height}`);
-     * ```
-     */
-    async takeRegion(region, showCursor = false) {
-        const response = await this.apiClient.takeRegionScreenshot(region.height, region.width, region.y, region.x, showCursor);
-        return response.data;
-    }
-    /**
-     * Takes a compressed screenshot of the entire screen
-     *
-     * @param {ScreenshotOptions} [options={}] - Compression and display options
-     * @returns {Promise<CompressedScreenshotResponse>} Compressed screenshot data
-     *
-     * @example
-     * ```typescript
-     * // Default compression
-     * const screenshot = await sandbox.computerUse.screenshot.takeCompressed();
-     *
-     * // High quality JPEG
-     * const jpeg = await sandbox.computerUse.screenshot.takeCompressed({
-     *   format: 'jpeg',
-     *   quality: 95,
-     *   showCursor: true
-     * });
-     *
-     * // Scaled down PNG
-     * const scaled = await sandbox.computerUse.screenshot.takeCompressed({
-     *   format: 'png',
-     *   scale: 0.5
-     * });
-     * ```
-     */
-    async takeCompressed(options = {}) {
-        const response = await this.apiClient.takeCompressedScreenshot(options.showCursor, options.format, options.quality, options.scale);
-        return response.data;
-    }
-    /**
-     * Takes a compressed screenshot of a specific region
-     *
-     * @param {ScreenshotRegion} region - The region to capture
-     * @param {ScreenshotOptions} [options={}] - Compression and display options
-     * @returns {Promise<CompressedScreenshotResponse>} Compressed screenshot data
-     *
-     * @example
-     * ```typescript
-     * const region = { x: 0, y: 0, width: 800, height: 600 };
-     * const screenshot = await sandbox.computerUse.screenshot.takeCompressedRegion(region, {
-     *   format: 'webp',
-     *   quality: 80,
-     *   showCursor: true
-     * });
-     * console.log(`Compressed size: ${screenshot.size_bytes} bytes`);
-     * ```
-     */
-    async takeCompressedRegion(region, options = {}) {
-        const response = await this.apiClient.takeCompressedRegionScreenshot(region.x, region.y, region.width, region.height, options.showCursor, options.format, options.quality, options.scale);
-        return response.data;
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Screenshot.prototype, "takeFullScreen", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], Screenshot.prototype, "takeRegion", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Screenshot.prototype, "takeCompressed", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], Screenshot.prototype, "takeCompressedRegion", null);
+let Screenshot = (() => {
+    let _instanceExtraInitializers = [];
+    let _takeFullScreen_decorators;
+    let _takeRegion_decorators;
+    let _takeCompressed_decorators;
+    let _takeCompressedRegion_decorators;
+    return class Screenshot {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _takeFullScreen_decorators = [WithInstrumentation()];
+            _takeRegion_decorators = [WithInstrumentation()];
+            _takeCompressed_decorators = [WithInstrumentation()];
+            _takeCompressedRegion_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _takeFullScreen_decorators, { kind: "method", name: "takeFullScreen", static: false, private: false, access: { has: obj => "takeFullScreen" in obj, get: obj => obj.takeFullScreen }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _takeRegion_decorators, { kind: "method", name: "takeRegion", static: false, private: false, access: { has: obj => "takeRegion" in obj, get: obj => obj.takeRegion }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _takeCompressed_decorators, { kind: "method", name: "takeCompressed", static: false, private: false, access: { has: obj => "takeCompressed" in obj, get: obj => obj.takeCompressed }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _takeCompressedRegion_decorators, { kind: "method", name: "takeCompressedRegion", static: false, private: false, access: { has: obj => "takeCompressedRegion" in obj, get: obj => obj.takeCompressedRegion }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        apiClient = __runInitializers(this, _instanceExtraInitializers);
+        constructor(apiClient) {
+            this.apiClient = apiClient;
+        }
+        /**
+         * Takes a screenshot of the entire screen
+         *
+         * @param {boolean} [showCursor=false] - Whether to show the cursor in the screenshot
+         * @returns {Promise<ScreenshotResponse>} Screenshot data with base64 encoded image
+         *
+         * @example
+         * ```typescript
+         * const screenshot = await sandbox.computerUse.screenshot.takeFullScreen();
+         * console.log(`Screenshot size: ${screenshot.width}x${screenshot.height}`);
+         *
+         * // With cursor visible
+         * const withCursor = await sandbox.computerUse.screenshot.takeFullScreen(true);
+         * ```
+         */
+        async takeFullScreen(showCursor = false) {
+            const response = await this.apiClient.takeScreenshot(showCursor);
+            return response.data;
+        }
+        /**
+         * Takes a screenshot of a specific region
+         *
+         * @param {ScreenshotRegion} region - The region to capture
+         * @param {boolean} [showCursor=false] - Whether to show the cursor in the screenshot
+         * @returns {Promise<RegionScreenshotResponse>} Screenshot data with base64 encoded image
+         *
+         * @example
+         * ```typescript
+         * const region = { x: 100, y: 100, width: 300, height: 200 };
+         * const screenshot = await sandbox.computerUse.screenshot.takeRegion(region);
+         * console.log(`Captured region: ${screenshot.region.width}x${screenshot.region.height}`);
+         * ```
+         */
+        async takeRegion(region, showCursor = false) {
+            const response = await this.apiClient.takeRegionScreenshot(region.height, region.width, region.y, region.x, showCursor);
+            return response.data;
+        }
+        /**
+         * Takes a compressed screenshot of the entire screen
+         *
+         * @param {ScreenshotOptions} [options={}] - Compression and display options
+         * @returns {Promise<CompressedScreenshotResponse>} Compressed screenshot data
+         *
+         * @example
+         * ```typescript
+         * // Default compression
+         * const screenshot = await sandbox.computerUse.screenshot.takeCompressed();
+         *
+         * // High quality JPEG
+         * const jpeg = await sandbox.computerUse.screenshot.takeCompressed({
+         *   format: 'jpeg',
+         *   quality: 95,
+         *   showCursor: true
+         * });
+         *
+         * // Scaled down PNG
+         * const scaled = await sandbox.computerUse.screenshot.takeCompressed({
+         *   format: 'png',
+         *   scale: 0.5
+         * });
+         * ```
+         */
+        async takeCompressed(options = {}) {
+            const response = await this.apiClient.takeCompressedScreenshot(options.showCursor, options.format, options.quality, options.scale);
+            return response.data;
+        }
+        /**
+         * Takes a compressed screenshot of a specific region
+         *
+         * @param {ScreenshotRegion} region - The region to capture
+         * @param {ScreenshotOptions} [options={}] - Compression and display options
+         * @returns {Promise<CompressedScreenshotResponse>} Compressed screenshot data
+         *
+         * @example
+         * ```typescript
+         * const region = { x: 0, y: 0, width: 800, height: 600 };
+         * const screenshot = await sandbox.computerUse.screenshot.takeCompressedRegion(region, {
+         *   format: 'webp',
+         *   quality: 80,
+         *   showCursor: true
+         * });
+         * console.log(`Compressed size: ${screenshot.size_bytes} bytes`);
+         * ```
+         */
+        async takeCompressedRegion(region, options = {}) {
+            const response = await this.apiClient.takeCompressedRegionScreenshot(region.x, region.y, region.width, region.height, options.showCursor, options.format, options.quality, options.scale);
+            return response.data;
+        }
+    };
+})();
+export { Screenshot };
 /**
  * Display operations for computer use functionality
  */
-export class Display {
-    apiClient;
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    /**
-     * Gets information about the displays
-     *
-     * @returns {Promise<DisplayInfoResponse>} Display information including primary display and all available displays
-     *
-     * @example
-     * ```typescript
-     * const info = await sandbox.computerUse.display.getInfo();
-     * console.log(`Primary display: ${info.primary_display.width}x${info.primary_display.height}`);
-     * console.log(`Total displays: ${info.total_displays}`);
-     * info.displays.forEach((display, index) => {
-     *   console.log(`Display ${index}: ${display.width}x${display.height} at ${display.x},${display.y}`);
-     * });
-     * ```
-     */
-    async getInfo() {
-        const response = await this.apiClient.getDisplayInfo();
-        return response.data;
-    }
-    /**
-     * Gets the list of open windows
-     *
-     * @returns {Promise<WindowsResponse>} List of open windows with their IDs and titles
-     *
-     * @example
-     * ```typescript
-     * const windows = await sandbox.computerUse.display.getWindows();
-     * console.log(`Found ${windows.count} open windows:`);
-     * windows.windows.forEach(window => {
-     *   console.log(`- ${window.title} (ID: ${window.id})`);
-     * });
-     * ```
-     */
-    async getWindows() {
-        const response = await this.apiClient.getWindows();
-        return response.data;
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Display.prototype, "getInfo", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Display.prototype, "getWindows", null);
+let Display = (() => {
+    let _instanceExtraInitializers = [];
+    let _getInfo_decorators;
+    let _getWindows_decorators;
+    return class Display {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getInfo_decorators = [WithInstrumentation()];
+            _getWindows_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _getInfo_decorators, { kind: "method", name: "getInfo", static: false, private: false, access: { has: obj => "getInfo" in obj, get: obj => obj.getInfo }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getWindows_decorators, { kind: "method", name: "getWindows", static: false, private: false, access: { has: obj => "getWindows" in obj, get: obj => obj.getWindows }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        apiClient = __runInitializers(this, _instanceExtraInitializers);
+        constructor(apiClient) {
+            this.apiClient = apiClient;
+        }
+        /**
+         * Gets information about the displays
+         *
+         * @returns {Promise<DisplayInfoResponse>} Display information including primary display and all available displays
+         *
+         * @example
+         * ```typescript
+         * const info = await sandbox.computerUse.display.getInfo();
+         * console.log(`Primary display: ${info.primary_display.width}x${info.primary_display.height}`);
+         * console.log(`Total displays: ${info.total_displays}`);
+         * info.displays.forEach((display, index) => {
+         *   console.log(`Display ${index}: ${display.width}x${display.height} at ${display.x},${display.y}`);
+         * });
+         * ```
+         */
+        async getInfo() {
+            const response = await this.apiClient.getDisplayInfo();
+            return response.data;
+        }
+        /**
+         * Gets the list of open windows
+         *
+         * @returns {Promise<WindowsResponse>} List of open windows with their IDs and titles
+         *
+         * @example
+         * ```typescript
+         * const windows = await sandbox.computerUse.display.getWindows();
+         * console.log(`Found ${windows.count} open windows:`);
+         * windows.windows.forEach(window => {
+         *   console.log(`- ${window.title} (ID: ${window.id})`);
+         * });
+         * ```
+         */
+        async getWindows() {
+            const response = await this.apiClient.getWindows();
+            return response.data;
+        }
+    };
+})();
+export { Display };
 /**
  * Recording operations for computer use functionality.
  */
-export class RecordingService {
-    apiClient;
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-    }
-    /**
-     * Starts a new screen recording session
-     *
-     * @param {string} [label] - Optional custom label for the recording
-     * @returns {Promise<Recording>} Started recording details
-     *
-     * @example
-     * ```typescript
-     * // Start a recording with a label
-     * const recording = await sandbox.computerUse.recording.start('my-test-recording');
-     * console.log(`Recording started: ${recording.id}`);
-     * console.log(`File: ${recording.filePath}`);
-     * ```
-     */
-    async start(label) {
-        return (await this.apiClient.startRecording({ label })).data;
-    }
-    /**
-     * Stops an active screen recording session
-     *
-     * @param {string} id - The ID of the recording to stop
-     * @returns {Promise<Recording>} Stopped recording details
-     *
-     * @example
-     * ```typescript
-     * const result = await sandbox.computerUse.recording.stop(recording.id);
-     * console.log(`Recording stopped: ${result.durationSeconds} seconds`);
-     * console.log(`Saved to: ${result.filePath}`);
-     * ```
-     */
-    async stop(id) {
-        return (await this.apiClient.stopRecording({ id })).data;
-    }
-    /**
-     * Lists all recordings (active and completed)
-     *
-     * @returns {Promise<ListRecordingsResponse>} List of all recordings
-     *
-     * @example
-     * ```typescript
-     * const recordings = await sandbox.computerUse.recording.list();
-     * console.log(`Found ${recordings.recordings.length} recordings`);
-     * recordings.recordings.forEach(rec => {
-     *   console.log(`- ${rec.fileName}: ${rec.status}`);
-     * });
-     * ```
-     */
-    async list() {
-        return (await this.apiClient.listRecordings()).data;
-    }
-    /**
-     * Gets details of a specific recording by ID
-     *
-     * @param {string} id - The ID of the recording to retrieve
-     * @returns {Promise<Recording>} Recording details
-     *
-     * @example
-     * ```typescript
-     * const recording = await sandbox.computerUse.recording.get(recordingId);
-     * console.log(`Recording: ${recording.fileName}`);
-     * console.log(`Status: ${recording.status}`);
-     * console.log(`Duration: ${recording.durationSeconds} seconds`);
-     * ```
-     */
-    async get(id) {
-        return (await this.apiClient.getRecording(id)).data;
-    }
-    /**
-     * Deletes a recording by ID
-     *
-     * @param {string} id - The ID of the recording to delete
-     *
-     * @example
-     * ```typescript
-     * await sandbox.computerUse.recording.delete(recordingId);
-     * console.log('Recording deleted');
-     * ```
-     */
-    async delete(id) {
-        await this.apiClient.deleteRecording(id);
-    }
-    /**
-     * Downloads a recording file and saves it to a local path
-     *
-     * The file is streamed directly to disk without loading the entire content into memory.
-     *
-     * @param {string} id - The ID of the recording to download
-     * @param {string} localPath - Path to save the recording file locally
-     *
-     * @example
-     * ```typescript
-     * // Download recording to file
-     * await sandbox.computerUse.recording.download(recordingId, 'local_recording.mp4');
-     * console.log('Recording downloaded');
-     * ```
-     */
-    async download(id, localPath) {
-        const response = await this.apiClient.downloadRecording(id, { responseType: 'stream' });
-        const importErrPrefix = 'Recording download failed: ';
-        const fs = await dynamicImport('fs', importErrPrefix);
-        const stream = await dynamicImport('stream', importErrPrefix);
-        const util = await dynamicImport('util', importErrPrefix);
-        const pipeline = util.promisify(stream.pipeline);
-        // Create parent directory if it doesn't exist
-        const parentDir = pathe.dirname(localPath);
-        if (parentDir) {
-            await fs.promises.mkdir(parentDir, { recursive: true });
-        }
-        // Stream the download directly to file
-        const writer = fs.createWriteStream(localPath);
-        await pipeline(response.data, writer);
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], RecordingService.prototype, "start", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], RecordingService.prototype, "stop", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], RecordingService.prototype, "list", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], RecordingService.prototype, "get", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], RecordingService.prototype, "delete", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], RecordingService.prototype, "download", null);
+let RecordingService = (() => {
+    let _instanceExtraInitializers = [];
+    let _start_decorators;
+    let _stop_decorators;
+    let _list_decorators;
+    let _get_decorators;
+    let _delete_decorators;
+    let _download_decorators;
+    return class RecordingService {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _start_decorators = [WithInstrumentation()];
+            _stop_decorators = [WithInstrumentation()];
+            _list_decorators = [WithInstrumentation()];
+            _get_decorators = [WithInstrumentation()];
+            _delete_decorators = [WithInstrumentation()];
+            _download_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _start_decorators, { kind: "method", name: "start", static: false, private: false, access: { has: obj => "start" in obj, get: obj => obj.start }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: obj => "stop" in obj, get: obj => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _get_decorators, { kind: "method", name: "get", static: false, private: false, access: { has: obj => "get" in obj, get: obj => obj.get }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _delete_decorators, { kind: "method", name: "delete", static: false, private: false, access: { has: obj => "delete" in obj, get: obj => obj.delete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _download_decorators, { kind: "method", name: "download", static: false, private: false, access: { has: obj => "download" in obj, get: obj => obj.download }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        apiClient = __runInitializers(this, _instanceExtraInitializers);
+        constructor(apiClient) {
+            this.apiClient = apiClient;
+        }
+        /**
+         * Starts a new screen recording session
+         *
+         * @param {string} [label] - Optional custom label for the recording
+         * @returns {Promise<Recording>} Started recording details
+         *
+         * @example
+         * ```typescript
+         * // Start a recording with a label
+         * const recording = await sandbox.computerUse.recording.start('my-test-recording');
+         * console.log(`Recording started: ${recording.id}`);
+         * console.log(`File: ${recording.filePath}`);
+         * ```
+         */
+        async start(label) {
+            return (await this.apiClient.startRecording({ label })).data;
+        }
+        /**
+         * Stops an active screen recording session
+         *
+         * @param {string} id - The ID of the recording to stop
+         * @returns {Promise<Recording>} Stopped recording details
+         *
+         * @example
+         * ```typescript
+         * const result = await sandbox.computerUse.recording.stop(recording.id);
+         * console.log(`Recording stopped: ${result.durationSeconds} seconds`);
+         * console.log(`Saved to: ${result.filePath}`);
+         * ```
+         */
+        async stop(id) {
+            return (await this.apiClient.stopRecording({ id })).data;
+        }
+        /**
+         * Lists all recordings (active and completed)
+         *
+         * @returns {Promise<ListRecordingsResponse>} List of all recordings
+         *
+         * @example
+         * ```typescript
+         * const recordings = await sandbox.computerUse.recording.list();
+         * console.log(`Found ${recordings.recordings.length} recordings`);
+         * recordings.recordings.forEach(rec => {
+         *   console.log(`- ${rec.fileName}: ${rec.status}`);
+         * });
+         * ```
+         */
+        async list() {
+            return (await this.apiClient.listRecordings()).data;
+        }
+        /**
+         * Gets details of a specific recording by ID
+         *
+         * @param {string} id - The ID of the recording to retrieve
+         * @returns {Promise<Recording>} Recording details
+         *
+         * @example
+         * ```typescript
+         * const recording = await sandbox.computerUse.recording.get(recordingId);
+         * console.log(`Recording: ${recording.fileName}`);
+         * console.log(`Status: ${recording.status}`);
+         * console.log(`Duration: ${recording.durationSeconds} seconds`);
+         * ```
+         */
+        async get(id) {
+            return (await this.apiClient.getRecording(id)).data;
+        }
+        /**
+         * Deletes a recording by ID
+         *
+         * @param {string} id - The ID of the recording to delete
+         *
+         * @example
+         * ```typescript
+         * await sandbox.computerUse.recording.delete(recordingId);
+         * console.log('Recording deleted');
+         * ```
+         */
+        async delete(id) {
+            await this.apiClient.deleteRecording(id);
+        }
+        /**
+         * Downloads a recording file and saves it to a local path
+         *
+         * The file is streamed directly to disk without loading the entire content into memory.
+         *
+         * @param {string} id - The ID of the recording to download
+         * @param {string} localPath - Path to save the recording file locally
+         *
+         * @example
+         * ```typescript
+         * // Download recording to file
+         * await sandbox.computerUse.recording.download(recordingId, 'local_recording.mp4');
+         * console.log('Recording downloaded');
+         * ```
+         */
+        async download(id, localPath) {
+            const response = await this.apiClient.downloadRecording(id, { responseType: 'stream' });
+            const importErrPrefix = 'Recording download failed: ';
+            const fs = await dynamicImport('fs', importErrPrefix);
+            const stream = await dynamicImport('stream', importErrPrefix);
+            const util = await dynamicImport('util', importErrPrefix);
+            const pipeline = util.promisify(stream.pipeline);
+            // Create parent directory if it doesn't exist
+            const parentDir = pathe.dirname(localPath);
+            if (parentDir) {
+                await fs.promises.mkdir(parentDir, { recursive: true });
+            }
+            // Stream the download directly to file
+            const writer = fs.createWriteStream(localPath);
+            await pipeline(response.data, writer);
+        }
+    };
+})();
+export { RecordingService };
+/**
+ * Accessibility operations for computer use functionality.
+ */
+let Accessibility = (() => {
+    let _instanceExtraInitializers = [];
+    let _getTree_decorators;
+    let _findNodes_decorators;
+    let _focusNode_decorators;
+    let _invokeNode_decorators;
+    let _setNodeValue_decorators;
+    return class Accessibility {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getTree_decorators = [WithInstrumentation()];
+            _findNodes_decorators = [WithInstrumentation()];
+            _focusNode_decorators = [WithInstrumentation()];
+            _invokeNode_decorators = [WithInstrumentation()];
+            _setNodeValue_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _getTree_decorators, { kind: "method", name: "getTree", static: false, private: false, access: { has: obj => "getTree" in obj, get: obj => obj.getTree }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _findNodes_decorators, { kind: "method", name: "findNodes", static: false, private: false, access: { has: obj => "findNodes" in obj, get: obj => obj.findNodes }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _focusNode_decorators, { kind: "method", name: "focusNode", static: false, private: false, access: { has: obj => "focusNode" in obj, get: obj => obj.focusNode }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _invokeNode_decorators, { kind: "method", name: "invokeNode", static: false, private: false, access: { has: obj => "invokeNode" in obj, get: obj => obj.invokeNode }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setNodeValue_decorators, { kind: "method", name: "setNodeValue", static: false, private: false, access: { has: obj => "setNodeValue" in obj, get: obj => obj.setNodeValue }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        apiClient = __runInitializers(this, _instanceExtraInitializers);
+        constructor(apiClient) {
+            this.apiClient = apiClient;
+        }
+        /**
+         * Fetches the AT-SPI accessibility tree.
+         *
+         * @param {AccessibilityTreeOptions} [options] - Scope and depth options
+         * @returns {Promise<AccessibilityTreeResponse>} Accessibility tree response
+         *
+         * @example
+         * ```typescript
+         * const tree = await sandbox.computerUse.accessibility.getTree({ scope: 'all', maxDepth: 3 });
+         * console.log(tree.root?.name);
+         * ```
+         */
+        async getTree(options = {}) {
+            const response = await this.apiClient.getAccessibilityTree(options.scope, options.pid, options.maxDepth);
+            return response.data;
+        }
+        /**
+         * Finds AT-SPI accessibility nodes matching the provided filters.
+         *
+         * @param {AccessibilityFindOptions} [options] - Search scope, node filters, and result limit
+         * @returns {Promise<AccessibilityNodesResponse>} Matching accessibility nodes
+         *
+         * @example
+         * ```typescript
+         * const buttons = await sandbox.computerUse.accessibility.findNodes({
+         *   scope: 'all',
+         *   role: 'button',
+         *   name: 'Submit',
+         *   nameMatch: 'substring',
+         * });
+         * console.log(buttons.matches?.length);
+         * ```
+         */
+        async findNodes(options = {}) {
+            const response = await this.apiClient.findAccessibilityNodes(options);
+            return response.data;
+        }
+        /**
+         * Focuses an AT-SPI accessibility node.
+         *
+         * @param {string} id - Accessibility node ID returned by getTree or findNodes
+         *
+         * @example
+         * ```typescript
+         * const node = (await sandbox.computerUse.accessibility.findNodes({ scope: 'all', limit: 1 })).matches?.[0];
+         * if (node?.id) {
+         *   await sandbox.computerUse.accessibility.focusNode(node.id);
+         * }
+         * ```
+         */
+        async focusNode(id) {
+            const request = { id };
+            await this.apiClient.focusAccessibilityNode(request);
+        }
+        /**
+         * Invokes an AT-SPI accessibility node action.
+         *
+         * @param {string} id - Accessibility node ID returned by getTree or findNodes
+         * @param {string} [action] - Action name to invoke. If omitted, the API invokes the primary action
+         *
+         * @example
+         * ```typescript
+         * const button = (await sandbox.computerUse.accessibility.findNodes({ scope: 'all', role: 'button', limit: 1 }))
+         *   .matches?.[0];
+         * if (button?.id) {
+         *   await sandbox.computerUse.accessibility.invokeNode(button.id, 'click');
+         * }
+         * ```
+         */
+        async invokeNode(id, action) {
+            const request = { id, action };
+            await this.apiClient.invokeAccessibilityNode(request);
+        }
+        /**
+         * Sets an AT-SPI accessibility node value.
+         *
+         * @param {string} id - Accessibility node ID returned by getTree or findNodes
+         * @param {string} value - Value to write to the node
+         *
+         * @example
+         * ```typescript
+         * const field = (await sandbox.computerUse.accessibility.findNodes({ scope: 'all', role: 'entry', limit: 1 }))
+         *   .matches?.[0];
+         * if (field?.id) {
+         *   await sandbox.computerUse.accessibility.setNodeValue(field.id, 'hello');
+         * }
+         * ```
+         */
+        async setNodeValue(id, value) {
+            const request = { id, value };
+            await this.apiClient.setAccessibilityNodeValue(request);
+        }
+    };
+})();
+export { Accessibility };
 /**
  * Computer Use functionality for interacting with the desktop environment.
  *
- * Provides access to mouse, keyboard, screenshot, display, and recording operations
+ * Provides access to mouse, keyboard, screenshot, display, recording, and accessibility operations
  * for automating desktop interactions within a sandbox.
  *
  * @property {Mouse} mouse - Mouse operations interface
@@ -626,174 +730,164 @@ __decorate([
  * @property {Screenshot} screenshot - Screenshot operations interface
  * @property {Display} display - Display operations interface
  * @property {RecordingService} recording - Screen recording operations interface
+ * @property {Accessibility} accessibility - Accessibility operations interface
  *
  * @class
  */
-export class ComputerUse {
-    apiClient;
-    mouse;
-    keyboard;
-    screenshot;
-    display;
-    recording;
-    constructor(apiClient) {
-        this.apiClient = apiClient;
-        this.mouse = new Mouse(apiClient);
-        this.keyboard = new Keyboard(apiClient);
-        this.screenshot = new Screenshot(apiClient);
-        this.display = new Display(apiClient);
-        this.recording = new RecordingService(apiClient);
-    }
-    /**
-     * Starts all computer use processes (Xvfb, xfce4, x11vnc, novnc)
-     *
-     * @returns {Promise<ComputerUseStartResponse>} Computer use start response
-     *
-     * @example
-     * ```typescript
-     * const result = await sandbox.computerUse.start();
-     * console.log('Computer use processes started:', result.message);
-     * ```
-     */
-    async start() {
-        const response = await this.apiClient.startComputerUse();
-        return response.data;
-    }
-    /**
-     * Stops all computer use processes
-     *
-     * @returns {Promise<ComputerUseStopResponse>} Computer use stop response
-     *
-     * @example
-     * ```typescript
-     * const result = await sandbox.computerUse.stop();
-     * console.log('Computer use processes stopped:', result.message);
-     * ```
-     */
-    async stop() {
-        const response = await this.apiClient.stopComputerUse();
-        return response.data;
-    }
-    /**
-     * Gets the status of all computer use processes
-     *
-     * @returns {Promise<ComputerUseStatusResponse>} Status information about all VNC desktop processes
-     *
-     * @example
-     * ```typescript
-     * const status = await sandbox.computerUse.getStatus();
-     * console.log('Computer use status:', status.status);
-     * ```
-     */
-    async getStatus() {
-        const response = await this.apiClient.getComputerUseStatus();
-        return response.data;
-    }
-    /**
-     * Gets the status of a specific VNC process
-     *
-     * @param {string} processName - Name of the process to check
-     * @returns {Promise<ProcessStatusResponse>} Status information about the specific process
-     *
-     * @example
-     * ```typescript
-     * const xvfbStatus = await sandbox.computerUse.getProcessStatus('xvfb');
-     * const noVncStatus = await sandbox.computerUse.getProcessStatus('novnc');
-     * ```
-     */
-    async getProcessStatus(processName) {
-        const response = await this.apiClient.getProcessStatus(processName);
-        return response.data;
-    }
-    /**
-     * Restarts a specific VNC process
-     *
-     * @param {string} processName - Name of the process to restart
-     * @returns {Promise<ProcessRestartResponse>} Process restart response
-     *
-     * @example
-     * ```typescript
-     * const result = await sandbox.computerUse.restartProcess('xfce4');
-     * console.log('XFCE4 process restarted:', result.message);
-     * ```
-     */
-    async restartProcess(processName) {
-        const response = await this.apiClient.restartProcess(processName);
-        return response.data;
-    }
-    /**
-     * Gets logs for a specific VNC process
-     *
-     * @param {string} processName - Name of the process to get logs for
-     * @returns {Promise<ProcessLogsResponse>} Process logs
-     *
-     * @example
-     * ```typescript
-     * const logsResp = await sandbox.computerUse.getProcessLogs('novnc');
-     * console.log('NoVNC logs:', logsResp.logs);
-     * ```
-     */
-    async getProcessLogs(processName) {
-        const response = await this.apiClient.getProcessLogs(processName);
-        return response.data;
-    }
-    /**
-     * Gets error logs for a specific VNC process
-     *
-     * @param {string} processName - Name of the process to get error logs for
-     * @returns {Promise<ProcessErrorsResponse>} Process error logs
-     *
-     * @example
-     * ```typescript
-     * const errorsResp = await sandbox.computerUse.getProcessErrors('x11vnc');
-     * console.log('X11VNC errors:', errorsResp.errors);
-     * ```
-     */
-    async getProcessErrors(processName) {
-        const response = await this.apiClient.getProcessErrors(processName);
-        return response.data;
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], ComputerUse.prototype, "start", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], ComputerUse.prototype, "stop", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], ComputerUse.prototype, "getStatus", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], ComputerUse.prototype, "getProcessStatus", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], ComputerUse.prototype, "restartProcess", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], ComputerUse.prototype, "getProcessLogs", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], ComputerUse.prototype, "getProcessErrors", null);
+let ComputerUse = (() => {
+    let _instanceExtraInitializers = [];
+    let _start_decorators;
+    let _stop_decorators;
+    let _getStatus_decorators;
+    let _getProcessStatus_decorators;
+    let _restartProcess_decorators;
+    let _getProcessLogs_decorators;
+    let _getProcessErrors_decorators;
+    return class ComputerUse {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _start_decorators = [WithInstrumentation()];
+            _stop_decorators = [WithInstrumentation()];
+            _getStatus_decorators = [WithInstrumentation()];
+            _getProcessStatus_decorators = [WithInstrumentation()];
+            _restartProcess_decorators = [WithInstrumentation()];
+            _getProcessLogs_decorators = [WithInstrumentation()];
+            _getProcessErrors_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _start_decorators, { kind: "method", name: "start", static: false, private: false, access: { has: obj => "start" in obj, get: obj => obj.start }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: obj => "stop" in obj, get: obj => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getStatus_decorators, { kind: "method", name: "getStatus", static: false, private: false, access: { has: obj => "getStatus" in obj, get: obj => obj.getStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getProcessStatus_decorators, { kind: "method", name: "getProcessStatus", static: false, private: false, access: { has: obj => "getProcessStatus" in obj, get: obj => obj.getProcessStatus }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _restartProcess_decorators, { kind: "method", name: "restartProcess", static: false, private: false, access: { has: obj => "restartProcess" in obj, get: obj => obj.restartProcess }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getProcessLogs_decorators, { kind: "method", name: "getProcessLogs", static: false, private: false, access: { has: obj => "getProcessLogs" in obj, get: obj => obj.getProcessLogs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getProcessErrors_decorators, { kind: "method", name: "getProcessErrors", static: false, private: false, access: { has: obj => "getProcessErrors" in obj, get: obj => obj.getProcessErrors }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        apiClient = __runInitializers(this, _instanceExtraInitializers);
+        mouse;
+        keyboard;
+        screenshot;
+        display;
+        recording;
+        accessibility;
+        constructor(apiClient) {
+            this.apiClient = apiClient;
+            this.mouse = new Mouse(apiClient);
+            this.keyboard = new Keyboard(apiClient);
+            this.screenshot = new Screenshot(apiClient);
+            this.display = new Display(apiClient);
+            this.recording = new RecordingService(apiClient);
+            this.accessibility = new Accessibility(apiClient);
+        }
+        /**
+         * Starts all computer use processes (Xvfb, xfce4, x11vnc, novnc)
+         *
+         * @returns {Promise<ComputerUseStartResponse>} Computer use start response
+         *
+         * @example
+         * ```typescript
+         * const result = await sandbox.computerUse.start();
+         * console.log('Computer use processes started:', result.message);
+         * ```
+         */
+        async start() {
+            const response = await this.apiClient.startComputerUse();
+            return response.data;
+        }
+        /**
+         * Stops all computer use processes
+         *
+         * @returns {Promise<ComputerUseStopResponse>} Computer use stop response
+         *
+         * @example
+         * ```typescript
+         * const result = await sandbox.computerUse.stop();
+         * console.log('Computer use processes stopped:', result.message);
+         * ```
+         */
+        async stop() {
+            const response = await this.apiClient.stopComputerUse();
+            return response.data;
+        }
+        /**
+         * Gets the status of all computer use processes
+         *
+         * @returns {Promise<ComputerUseStatusResponse>} Status information about all VNC desktop processes
+         *
+         * @example
+         * ```typescript
+         * const status = await sandbox.computerUse.getStatus();
+         * console.log('Computer use status:', status.status);
+         * ```
+         */
+        async getStatus() {
+            const response = await this.apiClient.getComputerUseStatus();
+            return response.data;
+        }
+        /**
+         * Gets the status of a specific VNC process
+         *
+         * @param {string} processName - Name of the process to check
+         * @returns {Promise<ProcessStatusResponse>} Status information about the specific process
+         *
+         * @example
+         * ```typescript
+         * const xvfbStatus = await sandbox.computerUse.getProcessStatus('xvfb');
+         * const noVncStatus = await sandbox.computerUse.getProcessStatus('novnc');
+         * ```
+         */
+        async getProcessStatus(processName) {
+            const response = await this.apiClient.getProcessStatus(processName);
+            return response.data;
+        }
+        /**
+         * Restarts a specific VNC process
+         *
+         * @param {string} processName - Name of the process to restart
+         * @returns {Promise<ProcessRestartResponse>} Process restart response
+         *
+         * @example
+         * ```typescript
+         * const result = await sandbox.computerUse.restartProcess('xfce4');
+         * console.log('XFCE4 process restarted:', result.message);
+         * ```
+         */
+        async restartProcess(processName) {
+            const response = await this.apiClient.restartProcess(processName);
+            return response.data;
+        }
+        /**
+         * Gets logs for a specific VNC process
+         *
+         * @param {string} processName - Name of the process to get logs for
+         * @returns {Promise<ProcessLogsResponse>} Process logs
+         *
+         * @example
+         * ```typescript
+         * const logsResp = await sandbox.computerUse.getProcessLogs('novnc');
+         * console.log('NoVNC logs:', logsResp.logs);
+         * ```
+         */
+        async getProcessLogs(processName) {
+            const response = await this.apiClient.getProcessLogs(processName);
+            return response.data;
+        }
+        /**
+         * Gets error logs for a specific VNC process
+         *
+         * @param {string} processName - Name of the process to get error logs for
+         * @returns {Promise<ProcessErrorsResponse>} Process error logs
+         *
+         * @example
+         * ```typescript
+         * const errorsResp = await sandbox.computerUse.getProcessErrors('x11vnc');
+         * console.log('X11VNC errors:', errorsResp.errors);
+         * ```
+         */
+        async getProcessErrors(processName) {
+            const response = await this.apiClient.getProcessErrors(processName);
+            return response.data;
+        }
+    };
+})();
+export { ComputerUse };
 //# sourceMappingURL=ComputerUse.js.map