# ComputerUse (/docs/python-sdk/computer-use)

## ComputerUseService [#computeruseservice]

```python
class ComputerUseService()
```

Synchronous ComputerUseService.

#### ComputerUseService.\_\_init\_\_ [#computeruseservice__init__]

```python
def __init__(impl: AsyncComputerUseService, bridge: SyncBridge) -> None
```

#### ComputerUseService.service [#computeruseserviceservice]

```python
@property
def service() -> AddonProcessesService
```

#### ComputerUseService.mouse [#computeruseservicemouse]

```python
@property
def mouse() -> MouseService
```

#### ComputerUseService.keyboard [#computeruseservicekeyboard]

```python
@property
def keyboard() -> KeyboardService
```

#### ComputerUseService.screen [#computeruseservicescreen]

```python
@property
def screen() -> ScreenService
```

#### ComputerUseService.display [#computeruseservicedisplay]

```python
@property
def display() -> DisplayService
```

#### ComputerUseService.a11y [#computeruseservicea11y]

```python
@property
def a11y() -> A11yService
```

#### ComputerUseService.recording [#computeruseservicerecording]

```python
@property
def recording() -> RecordingService
```

#### ComputerUseService.restart [#computeruseservicerestart]

```python
def restart() -> ComputerUseRestartResponse
```

#### ComputerUseService.start [#computeruseservicestart]

```python
def start() -> ComputerUseLifecycleResult
```

#### ComputerUseService.status [#computeruseservicestatus]

```python
def status() -> ComputerUseStatusResponse
```

#### ComputerUseService.stop [#computeruseservicestop]

```python
def stop() -> ComputerUseLifecycleResult
```

## AsyncComputerUseService [#asynccomputeruseservice]

```python
class AsyncComputerUseService()
```

#### AsyncComputerUseService.\_\_init\_\_ [#asynccomputeruseservice__init__]

```python
def __init__(transport: AsyncTransport) -> None
```

#### AsyncComputerUseService.status [#asynccomputeruseservicestatus]

```python
async def status() -> ComputerUseStatusResponse
```

#### AsyncComputerUseService.start [#asynccomputeruseservicestart]

```python
async def start() -> ComputerUseLifecycleResult
```

#### AsyncComputerUseService.stop [#asynccomputeruseservicestop]

```python
async def stop() -> ComputerUseLifecycleResult
```

#### AsyncComputerUseService.restart [#asynccomputeruseservicerestart]

```python
async def restart() -> ComputerUseRestartResponse
```

## A11yService [#a11yservice]

```python
class A11yService()
```

Synchronous A11yService.

#### A11yService.\_\_init\_\_ [#a11yservice__init__]

```python
def __init__(impl: AsyncA11yService, bridge: SyncBridge) -> None
```

#### A11yService.find [#a11yservicefind]

```python
def find(*,
         scope: ComputerUseA11yScope,
         pid: int | None = None,
         role: str | None = None,
         name: str | None = None,
         name_match: ComputerUseA11yNameMatch | None = None,
         states: Sequence[str] | None = None,
         limit: int | None = None) -> ComputerUseA11yFindResult
```

#### A11yService.focus [#a11yservicefocus]

```python
def focus(*, id: str) -> None
```

#### A11yService.invoke [#a11yserviceinvoke]

```python
def invoke(*, id: str, action: str | None = None) -> None
```

#### A11yService.set\_value [#a11yserviceset_value]

```python
def set_value(*, id: str, value: str) -> None
```

#### A11yService.tree [#a11yservicetree]

```python
def tree(*,
         scope: ComputerUseA11yScope,
         pid: int | None = None,
         max_depth: int | None = None) -> ComputerUseA11yTree
```

## AsyncA11yService [#asynca11yservice]

```python
class AsyncA11yService()
```

#### AsyncA11yService.\_\_init\_\_ [#asynca11yservice__init__]

```python
def __init__(transport: AsyncTransport) -> None
```

#### AsyncA11yService.tree [#asynca11yservicetree]

```python
async def tree(*,
               scope: ComputerUseA11yScope,
               pid: int | None = None,
               max_depth: int | None = None) -> ComputerUseA11yTree
```

#### AsyncA11yService.find [#asynca11yservicefind]

```python
async def find(*,
               scope: ComputerUseA11yScope,
               pid: int | None = None,
               role: str | None = None,
               name: str | None = None,
               name_match: ComputerUseA11yNameMatch | None = None,
               states: Sequence[str] | None = None,
               limit: int | None = None) -> ComputerUseA11yFindResult
```

#### AsyncA11yService.focus [#asynca11yservicefocus]

```python
async def focus(*, id: str) -> None
```

#### AsyncA11yService.invoke [#asynca11yserviceinvoke]

```python
async def invoke(*, id: str, action: str | None = None) -> None
```

#### AsyncA11yService.set\_value [#asynca11yserviceset_value]

```python
async def set_value(*, id: str, value: str) -> None
```

## AddonProcessesService [#addonprocessesservice]

```python
class AddonProcessesService()
```

Synchronous AddonProcessesService.

#### AddonProcessesService.\_\_init\_\_ [#addonprocessesservice__init__]

```python
def __init__(impl: AsyncAddonProcessesService, bridge: SyncBridge) -> None
```

#### AddonProcessesService.errors [#addonprocessesserviceerrors]

```python
def errors(name: str) -> ComputerUseProcessErrors
```

#### AddonProcessesService.logs [#addonprocessesservicelogs]

```python
def logs(name: str) -> ComputerUseProcessLogs
```

#### AddonProcessesService.restart [#addonprocessesservicerestart]

```python
def restart(name: str) -> ComputerUseProcessRestartResult
```

#### AddonProcessesService.status [#addonprocessesservicestatus]

```python
@overload
def status() -> dict[str, ComputerUseProcessStatus]
```

#### AddonProcessesService.status [#addonprocessesservicestatus-1]

```python
@overload
def status(name: str) -> ComputerUseProcessRunningStatus
```

## AsyncAddonProcessesService [#asyncaddonprocessesservice]

```python
class AsyncAddonProcessesService()
```

#### AsyncAddonProcessesService.\_\_init\_\_ [#asyncaddonprocessesservice__init__]

```python
def __init__(transport: AsyncTransport) -> None
```

#### AsyncAddonProcessesService.status [#asyncaddonprocessesservicestatus]

```python
@overload
async def status() -> dict[str, ComputerUseProcessStatus]
```

#### AsyncAddonProcessesService.status [#asyncaddonprocessesservicestatus-1]

```python
@overload
async def status(name: str) -> ComputerUseProcessRunningStatus
```

#### AsyncAddonProcessesService.restart [#asyncaddonprocessesservicerestart]

```python
async def restart(name: str) -> ComputerUseProcessRestartResult
```

#### AsyncAddonProcessesService.logs [#asyncaddonprocessesservicelogs]

```python
async def logs(name: str) -> ComputerUseProcessLogs
```

#### AsyncAddonProcessesService.errors [#asyncaddonprocessesserviceerrors]

```python
async def errors(name: str) -> ComputerUseProcessErrors
```

## DisplayService [#displayservice]

```python
class DisplayService()
```

Synchronous DisplayService.

#### DisplayService.\_\_init\_\_ [#displayservice__init__]

```python
def __init__(impl: AsyncDisplayService, bridge: SyncBridge) -> None
```

#### DisplayService.info [#displayserviceinfo]

```python
def info() -> ComputerUseDisplayInfo
```

#### DisplayService.windows [#displayservicewindows]

```python
def windows() -> ComputerUseDisplayWindows
```

## AsyncDisplayService [#asyncdisplayservice]

```python
class AsyncDisplayService()
```

#### AsyncDisplayService.\_\_init\_\_ [#asyncdisplayservice__init__]

```python
def __init__(transport: AsyncTransport) -> None
```

#### AsyncDisplayService.info [#asyncdisplayserviceinfo]

```python
async def info() -> ComputerUseDisplayInfo
```

#### AsyncDisplayService.windows [#asyncdisplayservicewindows]

```python
async def windows() -> ComputerUseDisplayWindows
```

## KeyboardService [#keyboardservice]

```python
class KeyboardService()
```

Synchronous KeyboardService.

#### KeyboardService.\_\_init\_\_ [#keyboardservice__init__]

```python
def __init__(impl: AsyncKeyboardService, bridge: SyncBridge) -> None
```

#### KeyboardService.hotkey [#keyboardservicehotkey]

```python
def hotkey(*, keys: str) -> None
```

#### KeyboardService.key [#keyboardservicekey]

```python
def key(*,
        key: str,
        modifiers: Sequence[ComputerUseKeyboardModifier] | None = None) -> None
```

#### KeyboardService.type [#keyboardservicetype]

```python
def type(*, text: str, delay: int | None = None) -> None
```

## AsyncKeyboardService [#asynckeyboardservice]

```python
class AsyncKeyboardService()
```

#### AsyncKeyboardService.\_\_init\_\_ [#asynckeyboardservice__init__]

```python
def __init__(transport: AsyncTransport) -> None
```

#### AsyncKeyboardService.type [#asynckeyboardservicetype]

```python
async def type(*, text: str, delay: int | None = None) -> None
```

#### AsyncKeyboardService.key [#asynckeyboardservicekey]

```python
async def key(*,
              key: str,
              modifiers: Sequence[ComputerUseKeyboardModifier] | None = None) -> None
```

#### AsyncKeyboardService.hotkey [#asynckeyboardservicehotkey]

```python
async def hotkey(*, keys: str) -> None
```

## MouseService [#mouseservice]

```python
class MouseService()
```

Synchronous MouseService.

#### MouseService.\_\_init\_\_ [#mouseservice__init__]

```python
def __init__(impl: AsyncMouseService, bridge: SyncBridge) -> None
```

#### MouseService.click [#mouseserviceclick]

```python
def click(*,
          x: int,
          y: int,
          button: ComputerUseMouseButton | None = None,
          double: bool | None = None) -> ComputerUsePoint
```

#### MouseService.drag [#mouseservicedrag]

```python
def drag(*,
         start_x: int,
         start_y: int,
         end_x: int,
         end_y: int,
         button: ComputerUseMouseButton | None = None) -> ComputerUsePoint
```

#### MouseService.move [#mouseservicemove]

```python
def move(*, x: int, y: int) -> ComputerUsePoint
```

#### MouseService.position [#mouseserviceposition]

```python
def position() -> ComputerUsePoint
```

#### MouseService.scroll [#mouseservicescroll]

```python
def scroll(*,
           x: int,
           y: int,
           direction: ComputerUseScrollDirection,
           amount: int | None = None) -> ComputerUseScrollResult
```

## AsyncMouseService [#asyncmouseservice]

```python
class AsyncMouseService()
```

#### AsyncMouseService.\_\_init\_\_ [#asyncmouseservice__init__]

```python
def __init__(transport: AsyncTransport) -> None
```

#### AsyncMouseService.position [#asyncmouseserviceposition]

```python
async def position() -> ComputerUsePoint
```

#### AsyncMouseService.move [#asyncmouseservicemove]

```python
async def move(*, x: int, y: int) -> ComputerUsePoint
```

#### AsyncMouseService.click [#asyncmouseserviceclick]

```python
async def click(*,
                x: int,
                y: int,
                button: ComputerUseMouseButton | None = None,
                double: bool | None = None) -> ComputerUsePoint
```

#### AsyncMouseService.drag [#asyncmouseservicedrag]

```python
async def drag(*,
               start_x: int,
               start_y: int,
               end_x: int,
               end_y: int,
               button: ComputerUseMouseButton | None = None) -> ComputerUsePoint
```

#### AsyncMouseService.scroll [#asyncmouseservicescroll]

```python
async def scroll(*,
                 x: int,
                 y: int,
                 direction: ComputerUseScrollDirection,
                 amount: int | None = None) -> ComputerUseScrollResult
```

## RecordingService [#recordingservice]

```python
class RecordingService()
```

Synchronous RecordingService.

#### RecordingService.\_\_init\_\_ [#recordingservice__init__]

```python
def __init__(impl: AsyncRecordingService, bridge: SyncBridge) -> None
```

#### RecordingService.delete [#recordingservicedelete]

```python
def delete(id: str) -> None
```

#### RecordingService.download [#recordingservicedownload]

```python
def download(id: str) -> bytes
```

#### RecordingService.get [#recordingserviceget]

```python
def get(id: str) -> ComputerUseRecording
```

#### RecordingService.list [#recordingservicelist]

```python
def list() -> ComputerUseRecordingList
```

#### RecordingService.start [#recordingservicestart]

```python
def start(*, label: str | None = None) -> ComputerUseRecording
```

#### RecordingService.stop [#recordingservicestop]

```python
def stop(*, id: str) -> ComputerUseRecording
```

## AsyncRecordingService [#asyncrecordingservice]

```python
class AsyncRecordingService()
```

#### AsyncRecordingService.\_\_init\_\_ [#asyncrecordingservice__init__]

```python
def __init__(transport: AsyncTransport) -> None
```

#### AsyncRecordingService.start [#asyncrecordingservicestart]

```python
async def start(*, label: str | None = None) -> ComputerUseRecording
```

#### AsyncRecordingService.stop [#asyncrecordingservicestop]

```python
async def stop(*, id: str) -> ComputerUseRecording
```

#### AsyncRecordingService.list [#asyncrecordingservicelist]

```python
async def list() -> ComputerUseRecordingList
```

#### AsyncRecordingService.get [#asyncrecordingserviceget]

```python
async def get(id: str) -> ComputerUseRecording
```

#### AsyncRecordingService.download [#asyncrecordingservicedownload]

```python
async def download(id: str) -> bytes
```

#### AsyncRecordingService.delete [#asyncrecordingservicedelete]

```python
async def delete(id: str) -> None
```

## ScreenService [#screenservice]

```python
class ScreenService()
```

Synchronous ScreenService.

#### ScreenService.\_\_init\_\_ [#screenservice__init__]

```python
def __init__(impl: AsyncScreenService, bridge: SyncBridge) -> None
```

#### ScreenService.capture [#screenservicecapture]

```python
def capture(*, show_cursor: bool | None = None) -> ComputerUseScreenshot
```

#### ScreenService.capture\_compressed [#screenservicecapture_compressed]

```python
def capture_compressed(*,
                       format: ComputerUseScreenshotFormat | None = None,
                       quality: int | None = None,
                       scale: float | None = None,
                       show_cursor: bool | None = None) -> ComputerUseScreenshot
```

#### ScreenService.region [#screenserviceregion]

```python
def region(*,
           x: int,
           y: int,
           width: int,
           height: int,
           show_cursor: bool | None = None) -> ComputerUseScreenshot
```

#### ScreenService.region\_compressed [#screenserviceregion_compressed]

```python
def region_compressed(*,
                      x: int,
                      y: int,
                      width: int,
                      height: int,
                      format: ComputerUseScreenshotFormat | None = None,
                      quality: int | None = None,
                      scale: float | None = None,
                      show_cursor: bool | None = None) -> ComputerUseScreenshot
```

## AsyncScreenService [#asyncscreenservice]

```python
class AsyncScreenService()
```

#### AsyncScreenService.\_\_init\_\_ [#asyncscreenservice__init__]

```python
def __init__(transport: AsyncTransport) -> None
```

#### AsyncScreenService.capture [#asyncscreenservicecapture]

```python
async def capture(*, show_cursor: bool | None = None) -> ComputerUseScreenshot
```

#### AsyncScreenService.region [#asyncscreenserviceregion]

```python
async def region(*,
                 x: int,
                 y: int,
                 width: int,
                 height: int,
                 show_cursor: bool | None = None) -> ComputerUseScreenshot
```

#### AsyncScreenService.capture\_compressed [#asyncscreenservicecapture_compressed]

```python
async def capture_compressed(*,
                             format: ComputerUseScreenshotFormat | None = None,
                             quality: int | None = None,
                             scale: float | None = None,
                             show_cursor: bool | None = None) -> ComputerUseScreenshot
```

#### AsyncScreenService.region\_compressed [#asyncscreenserviceregion_compressed]

```python
async def region_compressed(*,
                            x: int,
                            y: int,
                            width: int,
                            height: int,
                            format: ComputerUseScreenshotFormat | None = None,
                            quality: int | None = None,
                            scale: float | None = None,
                            show_cursor: bool | None = None) -> ComputerUseScreenshot
```

## ComputerUseDesktopFailure [#computerusedesktopfailure]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseDesktopFailure()
```

**Attributes**:

- `code` _ComputerUseDesktopFailureCode_
- `message` _str_
- `extra_fields` _Optional\[Dict\[str, JsonValue\]\] = None_
- `raw_code` _Optional\[str\] = None_

## ComputerUseNotStartedStatus [#computerusenotstartedstatus]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseNotStartedStatus()
```

**Attributes**:

- `status` _Literal\['inactive'\] = 'inactive'_
- `desktop` _Literal\['not_started'\] = 'not_started'_
- `cause` _None = None_
- `extra_fields` _Optional\[Dict\[str, JsonValue\]\] = None_

## ComputerUseStartingStatus [#computerusestartingstatus]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseStartingStatus()
```

**Attributes**:

- `status` _Literal\['inactive'\] = 'inactive'_
- `desktop` _Literal\['starting'\] = 'starting'_
- `cause` _None = None_
- `extra_fields` _Optional\[Dict\[str, JsonValue\]\] = None_

## ComputerUseReadyStatus [#computerusereadystatus]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseReadyStatus()
```

**Attributes**:

- `status` _Literal\['active'\] = 'active'_
- `desktop` _Literal\['ready'\] = 'ready'_
- `cause` _None = None_
- `extra_fields` _Optional\[Dict\[str, JsonValue\]\] = None_

## ComputerUseFailedStatus [#computerusefailedstatus]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseFailedStatus()
```

**Attributes**:

- `cause` _ComputerUseDesktopFailure_
- `status` _Literal\['inactive'\] = 'inactive'_
- `desktop` _Literal\['failed'\] = 'failed'_
- `extra_fields` _Optional\[Dict\[str, JsonValue\]\] = None_

## ComputerUseUnknownStatus [#computeruseunknownstatus]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseUnknownStatus()
```

A (status, desktop) pair this SDK release does not recognize, because a
newer daemon added a value or a combination. raw_status / raw_desktop carry
what the daemon sent; the recognized variants need no raw sibling, since
their typed values are the wire values. cause is the failure the daemon
attached to the unrecognized state, when it sent one.

**Attributes**:

- `raw_status` _str_
- `raw_desktop` _str_
- `status` _Literal\['unknown'\] = 'unknown'_
- `desktop` _Literal\['unknown'\] = 'unknown'_
- `cause` _Optional\[ComputerUseDesktopFailure\] = None_
- `extra_fields` _Optional\[Dict\[str, JsonValue\]\] = None_

## ComputerUseRestartResponse [#computeruserestartresponse]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseRestartResponse()
```

**Attributes**:

- `message` _str_
- `status` _Literal\['active'\] = 'active'_
- `desktop` _Literal\['ready'\] = 'ready'_
- `extra_fields` _Optional\[Dict\[str, JsonValue\]\] = None_

## ComputerUseProcessStatus [#computeruseprocessstatus]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseProcessStatus()
```

**Attributes**:

- `running` _Optional\[bool\] = None_
- `priority` _Optional\[int\] = None_
- `auto_restart` _Optional\[bool\] = None_
- `pid` _Optional\[int\] = None_
- `failed` _Optional\[bool\] = None_
- `restart_attempts` _Optional\[int\] = None_
- `restart_backoff_ms` _Optional\[int\] = None_
- `status` _Optional\[str\] = None_
- `extra_fields` _Optional\[Dict\[str, JsonValue\]\] = None_

## ComputerUseProcessRunningStatus [#computeruseprocessrunningstatus]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseProcessRunningStatus()
```

**Attributes**:

- `process_name` _str_
- `running` _bool_

## ComputerUsePoint [#computerusepoint]

```python
@dataclass(frozen=True, slots=True)
class ComputerUsePoint()
```

**Attributes**:

- `x` _int_
- `y` _int_

## ComputerUseDisplay [#computerusedisplay]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseDisplay()
```

**Attributes**:

- `id` _int_
- `x` _int_
- `y` _int_
- `width` _int_
- `height` _int_
- `is_active` _bool_

## ComputerUseWindow [#computerusewindow]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseWindow()
```

**Attributes**:

- `id` _int_
- `title` _str_
- `x` _int_
- `y` _int_
- `width` _int_
- `height` _int_
- `is_active` _bool_

## ComputerUseAccessibilityBounds [#computeruseaccessibilitybounds]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseAccessibilityBounds()
```

**Attributes**:

- `x` _int_
- `y` _int_
- `width` _int_
- `height` _int_

## ComputerUseAccessibilityNode [#computeruseaccessibilitynode]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseAccessibilityNode()
```

**Attributes**:

- `id` _str_
- `role` _str_
- `name` _str_
- `bounds` _ComputerUseAccessibilityBounds_
- `states` _List\[str\]_
- `description` _Optional\[str\] = None_
- `actions` _Optional\[List\[str\]\] = None_
- `children` _Optional\[List\[ComputerUseAccessibilityNode\]\] = None_
- `value` _Optional\[str\] = None_
- `value_truncated` _bool = False_

## ComputerUseRecording [#computeruserecording]

```python
@dataclass(frozen=True, slots=True)
class ComputerUseRecording()
```

**Attributes**:

- `id` _str_
- `file_name` _str_
- `file_path` _str_
- `start_time` _str_
- `status` _str_
- `end_time` _Optional\[str\] = None_
- `duration_seconds` _Optional\[float\] = None_
- `size_bytes` _Optional\[int\] = None_

## ComputerUseMouseButton [#computerusemousebutton]

```python
ComputerUseMouseButton = Literal['left', 'right', 'middle']
```

## ComputerUseScrollDirection [#computerusescrolldirection]

```python
ComputerUseScrollDirection = Literal['up', 'down']
```

## ComputerUseScreenshotFormat [#computerusescreenshotformat]

```python
ComputerUseScreenshotFormat = Literal['png', 'jpeg']
```

## ComputerUseKeyboardModifier [#computerusekeyboardmodifier]

```python
ComputerUseKeyboardModifier = Literal['ctrl', 'alt', 'shift', 'cmd']
```

## ComputerUseA11yScope [#computerusea11yscope]

```python
ComputerUseA11yScope = Literal['focused', 'pid', 'all']
```

## ComputerUseA11yNameMatch [#computerusea11ynamematch]

```python
ComputerUseA11yNameMatch = Literal['exact', 'substring', 'regex']
```

## ComputerUseActivityStatus [#computeruseactivitystatus]

```python
ComputerUseActivityStatus = Literal['active', 'inactive', 'unknown']
```

## ComputerUseDesktopState [#computerusedesktopstate]

```python
ComputerUseDesktopState = Literal['not_started', 'starting', 'ready', 'failed', 'unknown']
```

## ComputerUseDesktopFailureCode [#computerusedesktopfailurecode]

```python
ComputerUseDesktopFailureCode = Literal['desktop_exited', 'addon_crashed', 'start_failed', 'start_interrupted', 'session_ended', 'session_replaced', 'state_corrupt', 'state_persistence_failed', 'unknown']
```

## ComputerUseStatusResponse [#computerusestatusresponse]

```python
ComputerUseStatusResponse = Union[ComputerUseNotStartedStatus, ComputerUseStartingStatus, ComputerUseReadyStatus, ComputerUseFailedStatus, ComputerUseUnknownStatus]
```

## ComputerUseLifecycleResponse [#computeruselifecycleresponse]

```python
ComputerUseLifecycleResponse = ComputerUseLifecycleResult
```

## ComputerUseProcessRestartResponse [#computeruseprocessrestartresponse]

```python
ComputerUseProcessRestartResponse = ComputerUseProcessRestartResult
```

## ComputerUseProcessLogsResponse [#computeruseprocesslogsresponse]

```python
ComputerUseProcessLogsResponse = ComputerUseProcessLogs
```

## ComputerUseProcessErrorsResponse [#computeruseprocesserrorsresponse]

```python
ComputerUseProcessErrorsResponse = ComputerUseProcessErrors
```

## ComputerUseScreenshotResponse [#computerusescreenshotresponse]

```python
ComputerUseScreenshotResponse = ComputerUseScreenshot
```

## ComputerUseScrollResponse [#computerusescrollresponse]

```python
ComputerUseScrollResponse = ComputerUseScrollResult
```

## ComputerUseDisplayInfoResponse [#computerusedisplayinforesponse]

```python
ComputerUseDisplayInfoResponse = ComputerUseDisplayInfo
```

## ComputerUseDisplayWindowsResponse [#computerusedisplaywindowsresponse]

```python
ComputerUseDisplayWindowsResponse = ComputerUseDisplayWindows
```

## ComputerUseA11yTreeResponse [#computerusea11ytreeresponse]

```python
ComputerUseA11yTreeResponse = ComputerUseA11yTree
```

## ComputerUseA11yFindResponse [#computerusea11yfindresponse]

```python
ComputerUseA11yFindResponse = ComputerUseA11yFindResult
```

## ComputerUseRecordingsResponse [#computeruserecordingsresponse]

```python
ComputerUseRecordingsResponse = ComputerUseRecordingList
```