@distilled.cloud/daytona 0.0.0-placeholder → 1.0.0-rc.13

package/src/services/computer_use.ts

@@ -0,0 +1,1496 @@
+// AUTO-GENERATED by scripts/generate.ts from .generated-specs (specs/spec-mirror-daytona/specs/{openapi,toolbox-openapi,analytics-openapi}.json). Do not edit.
+import * as S from "@distilled.cloud/core/schema";
+import * as API from "@distilled.cloud/core/api";
+import * as T from "../traits.ts";
+import {
+  DaytonaProtocol,
+  type DaytonaOpError,
+  type DaytonaOpContext,
+} from "../protocol.ts";
+import { UnknownDaytonaError } from "../errors.ts";
+import * as Retry from "../retry.ts";
+
+export type { DaytonaOpError, DaytonaOpContext };
+
+export interface ClickRequest {
+  /** left, right, middle */
+  button?: string;
+  double?: boolean;
+  x?: number;
+  y?: number;
+}
+export const ClickRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    button: S.optional(S.String),
+    double: S.optional(S.Boolean),
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/mouse/click", code: 200 }),
+  ),
+).annotate({ identifier: "ClickRequest" }) as any as S.Schema<ClickRequest>;
+
+export interface MouseClickResponse {
+  x?: number;
+  y?: number;
+}
+export const MouseClickResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "MouseClickResponse",
+}) as any as S.Schema<MouseClickResponse>;
+
+export interface DeleteRecordingRequest {
+  /** Recording ID */
+  id: string;
+}
+export const DeleteRecordingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "DELETE",
+      uri: "/computeruse/recordings/{id}",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DeleteRecordingRequest",
+}) as any as S.Schema<DeleteRecordingRequest>;
+
+export interface DeleteRecordingResponse {}
+export const DeleteRecordingResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}),
+).annotate({
+  identifier: "DeleteRecordingResponse",
+}) as any as S.Schema<DeleteRecordingResponse>;
+
+export interface DownloadRecordingRequest {
+  /** Recording ID */
+  id: string;
+}
+export const DownloadRecordingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/computeruse/recordings/{id}/download",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "DownloadRecordingRequest",
+}) as any as S.Schema<DownloadRecordingRequest>;
+
+export type DownloadRecordingResponse = unknown;
+export const DownloadRecordingResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "DownloadRecordingResponse",
+}) as any as S.Schema<DownloadRecordingResponse>;
+
+export interface DragRequest {
+  button?: string;
+  endX?: number;
+  endY?: number;
+  startX?: number;
+  startY?: number;
+}
+export const DragRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    button: S.optional(S.String),
+    endX: S.optional(S.Number),
+    endY: S.optional(S.Number),
+    startX: S.optional(S.Number),
+    startY: S.optional(S.Number),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/mouse/drag", code: 200 }),
+  ),
+).annotate({ identifier: "DragRequest" }) as any as S.Schema<DragRequest>;
+
+export interface MouseDragResponse {
+  x?: number;
+  y?: number;
+}
+export const MouseDragResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "MouseDragResponse",
+}) as any as S.Schema<MouseDragResponse>;
+
+export type FindAccessibilityNodesRequestStatesList = Array<string>;
+export const FindAccessibilityNodesRequestStatesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<FindAccessibilityNodesRequestStatesList>;
+
+export interface FindAccessibilityNodesRequest {
+  limit?: number;
+  name?: string;
+  /** "exact" | "substring" | "regex" */
+  nameMatch?: string;
+  pid?: number;
+  role?: string;
+  scope?: string;
+  states?: FindAccessibilityNodesRequestStatesList;
+}
+export const FindAccessibilityNodesRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    limit: S.optional(S.Number),
+    name: S.optional(S.String),
+    nameMatch: S.optional(S.String),
+    pid: S.optional(S.Number),
+    role: S.optional(S.String),
+    scope: S.optional(S.String),
+    states: S.optional(FindAccessibilityNodesRequestStatesList),
+  }).pipe(T.Http({ method: "POST", uri: "/computeruse/a11y/find", code: 200 })),
+).annotate({
+  identifier: "FindAccessibilityNodesRequest",
+}) as any as S.Schema<FindAccessibilityNodesRequest>;
+
+export type ComputeruseAccessibilityNodeActionsList = Array<string>;
+export const ComputeruseAccessibilityNodeActionsList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ComputeruseAccessibilityNodeActionsList>;
+
+export interface AccessibilityBounds {
+  height?: number;
+  width?: number;
+  x?: number;
+  y?: number;
+}
+export const AccessibilityBounds = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    height: S.optional(S.Number),
+    width: S.optional(S.Number),
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "AccessibilityBounds",
+}) as any as S.Schema<AccessibilityBounds>;
+
+export type ComputeruseAccessibilityNodeChildrenList =
+  Array<ComputeruseAccessibilityNode>;
+export const ComputeruseAccessibilityNodeChildrenList = /*@__PURE__*/ S.Array(
+  S.suspend(() => ComputeruseAccessibilityNode),
+) as any as S.Schema<ComputeruseAccessibilityNodeChildrenList>;
+
+export type ComputeruseAccessibilityNodeStatesList = Array<string>;
+export const ComputeruseAccessibilityNodeStatesList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<ComputeruseAccessibilityNodeStatesList>;
+
+export interface ComputeruseAccessibilityNode {
+  actions?: ComputeruseAccessibilityNodeActionsList;
+  bounds?: AccessibilityBounds;
+  children?: ComputeruseAccessibilityNodeChildrenList;
+  description?: string;
+  id?: string;
+  name?: string;
+  role?: string;
+  states?: ComputeruseAccessibilityNodeStatesList;
+}
+export const ComputeruseAccessibilityNode = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    actions: S.optional(ComputeruseAccessibilityNodeActionsList),
+    bounds: S.optional(AccessibilityBounds),
+    children: S.optional(ComputeruseAccessibilityNodeChildrenList),
+    description: S.optional(S.String),
+    id: S.optional(S.String),
+    name: S.optional(S.String),
+    role: S.optional(S.String),
+    states: S.optional(ComputeruseAccessibilityNodeStatesList),
+  }),
+).annotate({
+  identifier: "ComputeruseAccessibilityNode",
+}) as any as S.Schema<ComputeruseAccessibilityNode>;
+
+export type AccessibilityNodesResponseMatchesList =
+  Array<ComputeruseAccessibilityNode>;
+export const AccessibilityNodesResponseMatchesList = /*@__PURE__*/ S.Array(
+  ComputeruseAccessibilityNode,
+) as any as S.Schema<AccessibilityNodesResponseMatchesList>;
+
+export interface AccessibilityNodesResponse {
+  matches?: AccessibilityNodesResponseMatchesList;
+  truncated?: boolean;
+}
+export const AccessibilityNodesResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    matches: S.optional(AccessibilityNodesResponseMatchesList),
+    truncated: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "AccessibilityNodesResponse",
+}) as any as S.Schema<AccessibilityNodesResponse>;
+
+export interface FocusAccessibilityNodeRequest {
+  id: string;
+}
+export const FocusAccessibilityNodeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/a11y/node/focus", code: 200 }),
+  ),
+).annotate({
+  identifier: "FocusAccessibilityNodeRequest",
+}) as any as S.Schema<FocusAccessibilityNodeRequest>;
+
+export type FocusAccessibilityNodeResponse = unknown;
+export const FocusAccessibilityNodeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "FocusAccessibilityNodeResponse",
+}) as any as S.Schema<FocusAccessibilityNodeResponse>;
+
+export interface GetAccessibilityTreeRequest {
+  /** Scope: focused | pid | all (default: focused) */
+  scope?: string;
+  /** Process ID when scope=pid */
+  pid?: number;
+  /** Max tree depth (-1 unbounded, 0 root only; default -1) */
+  maxDepth?: number;
+}
+export const GetAccessibilityTreeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    scope: S.optional(S.String.pipe(T.Query())),
+    pid: S.optional(S.Number.pipe(T.Query())),
+    maxDepth: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/computeruse/a11y/tree", code: 200 })),
+).annotate({
+  identifier: "GetAccessibilityTreeRequest",
+}) as any as S.Schema<GetAccessibilityTreeRequest>;
+
+export interface AccessibilityTreeResponse {
+  root?: ComputeruseAccessibilityNode;
+  truncated?: boolean;
+}
+export const AccessibilityTreeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    root: S.optional(ComputeruseAccessibilityNode),
+    truncated: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "AccessibilityTreeResponse",
+}) as any as S.Schema<AccessibilityTreeResponse>;
+
+export interface GetComputerUseStatusRequest {}
+export const GetComputerUseStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/computeruse/process-status", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetComputerUseStatusRequest",
+}) as any as S.Schema<GetComputerUseStatusRequest>;
+
+export interface ComputerUseStatusResponse {
+  status?: string;
+}
+export const ComputerUseStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    status: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ComputerUseStatusResponse",
+}) as any as S.Schema<ComputerUseStatusResponse>;
+
+export interface GetComputerUseSystemStatusRequest {}
+export const GetComputerUseSystemStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/computeruse/status", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetComputerUseSystemStatusRequest",
+}) as any as S.Schema<GetComputerUseSystemStatusRequest>;
+
+export interface GetDisplayInfoRequest {}
+export const GetDisplayInfoRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/computeruse/display/info", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetDisplayInfoRequest",
+}) as any as S.Schema<GetDisplayInfoRequest>;
+
+export interface DisplayInfo {
+  height?: number;
+  id?: number;
+  isActive?: boolean;
+  width?: number;
+  x?: number;
+  y?: number;
+}
+export const DisplayInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    height: S.optional(S.Number),
+    id: S.optional(S.Number),
+    isActive: S.optional(S.Boolean),
+    width: S.optional(S.Number),
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }),
+).annotate({ identifier: "DisplayInfo" }) as any as S.Schema<DisplayInfo>;
+
+export type DisplayInfoResponseDisplaysList = Array<DisplayInfo>;
+export const DisplayInfoResponseDisplaysList = /*@__PURE__*/ S.Array(
+  DisplayInfo,
+) as any as S.Schema<DisplayInfoResponseDisplaysList>;
+
+export interface DisplayInfoResponse {
+  displays?: DisplayInfoResponseDisplaysList;
+}
+export const DisplayInfoResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    displays: S.optional(DisplayInfoResponseDisplaysList),
+  }),
+).annotate({
+  identifier: "DisplayInfoResponse",
+}) as any as S.Schema<DisplayInfoResponse>;
+
+export interface GetMousePositionRequest {}
+export const GetMousePositionRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/computeruse/mouse/position", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetMousePositionRequest",
+}) as any as S.Schema<GetMousePositionRequest>;
+
+export interface MousePositionResponse {
+  x?: number;
+  y?: number;
+}
+export const MousePositionResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "MousePositionResponse",
+}) as any as S.Schema<MousePositionResponse>;
+
+export interface GetProcessErrorsRequest {
+  /** Process name to get errors for */
+  processName: string;
+}
+export const GetProcessErrorsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    processName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/computeruse/process/{processName}/errors",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetProcessErrorsRequest",
+}) as any as S.Schema<GetProcessErrorsRequest>;
+
+export interface ProcessErrorsResponse {
+  errors?: string;
+  processName?: string;
+}
+export const ProcessErrorsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    errors: S.optional(S.String),
+    processName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ProcessErrorsResponse",
+}) as any as S.Schema<ProcessErrorsResponse>;
+
+export interface GetProcessLogsRequest {
+  /** Process name to get logs for */
+  processName: string;
+}
+export const GetProcessLogsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    processName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/computeruse/process/{processName}/logs",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetProcessLogsRequest",
+}) as any as S.Schema<GetProcessLogsRequest>;
+
+export interface ProcessLogsResponse {
+  logs?: string;
+  processName?: string;
+}
+export const ProcessLogsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    logs: S.optional(S.String),
+    processName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ProcessLogsResponse",
+}) as any as S.Schema<ProcessLogsResponse>;
+
+export interface GetProcessStatusRequest {
+  /** Process name to check */
+  processName: string;
+}
+export const GetProcessStatusRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    processName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/computeruse/process/{processName}/status",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "GetProcessStatusRequest",
+}) as any as S.Schema<GetProcessStatusRequest>;
+
+export interface ProcessStatusResponse {
+  processName?: string;
+  running?: boolean;
+}
+export const ProcessStatusResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    processName: S.optional(S.String),
+    running: S.optional(S.Boolean),
+  }),
+).annotate({
+  identifier: "ProcessStatusResponse",
+}) as any as S.Schema<ProcessStatusResponse>;
+
+export interface GetRecordingRequest {
+  /** Recording ID */
+  id: string;
+}
+export const GetRecordingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/computeruse/recordings/{id}", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetRecordingRequest",
+}) as any as S.Schema<GetRecordingRequest>;
+
+export interface Recording {
+  durationSeconds?: number;
+  endTime?: string;
+  fileName: string;
+  filePath: string;
+  id: string;
+  sizeBytes?: number;
+  startTime: string;
+  status: string;
+}
+export const Recording = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    durationSeconds: S.optional(S.Number),
+    endTime: S.optional(S.String),
+    fileName: S.String,
+    filePath: S.String,
+    id: S.String,
+    sizeBytes: S.optional(S.Number),
+    startTime: S.String,
+    status: S.String,
+  }),
+).annotate({ identifier: "Recording" }) as any as S.Schema<Recording>;
+
+export interface GetWindowsRequest {}
+export const GetWindowsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/computeruse/display/windows", code: 200 }),
+  ),
+).annotate({
+  identifier: "GetWindowsRequest",
+}) as any as S.Schema<GetWindowsRequest>;
+
+export interface WindowInfo {
+  height?: number;
+  id?: number;
+  isActive?: boolean;
+  title?: string;
+  width?: number;
+  x?: number;
+  y?: number;
+}
+export const WindowInfo = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    height: S.optional(S.Number),
+    id: S.optional(S.Number),
+    isActive: S.optional(S.Boolean),
+    title: S.optional(S.String),
+    width: S.optional(S.Number),
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }),
+).annotate({ identifier: "WindowInfo" }) as any as S.Schema<WindowInfo>;
+
+export type WindowsResponseWindowsList = Array<WindowInfo>;
+export const WindowsResponseWindowsList = /*@__PURE__*/ S.Array(
+  WindowInfo,
+) as any as S.Schema<WindowsResponseWindowsList>;
+
+export interface WindowsResponse {
+  windows?: WindowsResponseWindowsList;
+}
+export const WindowsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    windows: S.optional(WindowsResponseWindowsList),
+  }),
+).annotate({
+  identifier: "WindowsResponse",
+}) as any as S.Schema<WindowsResponse>;
+
+export interface InvokeAccessibilityNodeRequest {
+  action?: string;
+  id: string;
+}
+export const InvokeAccessibilityNodeRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    action: S.optional(S.String),
+    id: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/a11y/node/invoke", code: 200 }),
+  ),
+).annotate({
+  identifier: "InvokeAccessibilityNodeRequest",
+}) as any as S.Schema<InvokeAccessibilityNodeRequest>;
+
+export type InvokeAccessibilityNodeResponse = unknown;
+export const InvokeAccessibilityNodeResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "InvokeAccessibilityNodeResponse",
+}) as any as S.Schema<InvokeAccessibilityNodeResponse>;
+
+export interface ListRecordingsRequest {}
+export const ListRecordingsRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "GET", uri: "/computeruse/recordings", code: 200 }),
+  ),
+).annotate({
+  identifier: "ListRecordingsRequest",
+}) as any as S.Schema<ListRecordingsRequest>;
+
+export type ListRecordingsResponseRecordingsList = Array<Recording>;
+export const ListRecordingsResponseRecordingsList = /*@__PURE__*/ S.Array(
+  Recording,
+) as any as S.Schema<ListRecordingsResponseRecordingsList>;
+
+export interface ListRecordingsResponse {
+  recordings: ListRecordingsResponseRecordingsList;
+}
+export const ListRecordingsResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    recordings: ListRecordingsResponseRecordingsList,
+  }),
+).annotate({
+  identifier: "ListRecordingsResponse",
+}) as any as S.Schema<ListRecordingsResponse>;
+
+export interface MoveMouseRequest {
+  x?: number;
+  y?: number;
+}
+export const MoveMouseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/mouse/move", code: 200 }),
+  ),
+).annotate({
+  identifier: "MoveMouseRequest",
+}) as any as S.Schema<MoveMouseRequest>;
+
+export interface PressHotkeyRequest {
+  /** e.g., "ctrl+c", "cmd+v" */
+  keys?: string;
+}
+export const PressHotkeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    keys: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/keyboard/hotkey", code: 200 }),
+  ),
+).annotate({
+  identifier: "PressHotkeyRequest",
+}) as any as S.Schema<PressHotkeyRequest>;
+
+export type PressHotkeyResponse = unknown;
+export const PressHotkeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PressHotkeyResponse",
+}) as any as S.Schema<PressHotkeyResponse>;
+
+/** ctrl, alt, shift, cmd */
+export type PressKeyRequestModifiersList = Array<string>;
+export const PressKeyRequestModifiersList = /*@__PURE__*/ S.Array(
+  S.String,
+) as any as S.Schema<PressKeyRequestModifiersList>;
+
+export interface PressKeyRequest {
+  key?: string;
+  /** ctrl, alt, shift, cmd */
+  modifiers?: PressKeyRequestModifiersList;
+}
+export const PressKeyRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    key: S.optional(S.String),
+    modifiers: S.optional(PressKeyRequestModifiersList),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/keyboard/key", code: 200 }),
+  ),
+).annotate({
+  identifier: "PressKeyRequest",
+}) as any as S.Schema<PressKeyRequest>;
+
+export type PressKeyResponse = unknown;
+export const PressKeyResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "PressKeyResponse",
+}) as any as S.Schema<PressKeyResponse>;
+
+export interface RestartProcessRequest {
+  /** Process name to restart */
+  processName: string;
+}
+export const RestartProcessRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    processName: S.String.pipe(T.Label()),
+  }).pipe(
+    T.Http({
+      method: "POST",
+      uri: "/computeruse/process/{processName}/restart",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "RestartProcessRequest",
+}) as any as S.Schema<RestartProcessRequest>;
+
+export interface ProcessRestartResponse {
+  message?: string;
+  processName?: string;
+}
+export const ProcessRestartResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    message: S.optional(S.String),
+    processName: S.optional(S.String),
+  }),
+).annotate({
+  identifier: "ProcessRestartResponse",
+}) as any as S.Schema<ProcessRestartResponse>;
+
+export interface ScrollRequest {
+  amount?: number;
+  /** up, down */
+  direction?: string;
+  x?: number;
+  y?: number;
+}
+export const ScrollRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    amount: S.optional(S.Number),
+    direction: S.optional(S.String),
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/mouse/scroll", code: 200 }),
+  ),
+).annotate({ identifier: "ScrollRequest" }) as any as S.Schema<ScrollRequest>;
+
+export interface ScrollResponse {
+  success?: boolean;
+}
+export const ScrollResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    success: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "ScrollResponse" }) as any as S.Schema<ScrollResponse>;
+
+export interface SetAccessibilityNodeValueRequest {
+  id: string;
+  value?: string;
+}
+export const SetAccessibilityNodeValueRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+    value: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/a11y/node/value", code: 200 }),
+  ),
+).annotate({
+  identifier: "SetAccessibilityNodeValueRequest",
+}) as any as S.Schema<SetAccessibilityNodeValueRequest>;
+
+export type SetAccessibilityNodeValueResponse = unknown;
+export const SetAccessibilityNodeValueResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "SetAccessibilityNodeValueResponse",
+}) as any as S.Schema<SetAccessibilityNodeValueResponse>;
+
+export interface StartComputerUseRequest {}
+export const StartComputerUseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/start", code: 200 }),
+  ),
+).annotate({
+  identifier: "StartComputerUseRequest",
+}) as any as S.Schema<StartComputerUseRequest>;
+
+export interface ProcessStatus {
+  autoRestart?: boolean;
+  pid?: number;
+  priority?: number;
+  running?: boolean;
+}
+export const ProcessStatus = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    autoRestart: S.optional(S.Boolean),
+    pid: S.optional(S.Number),
+    priority: S.optional(S.Number),
+    running: S.optional(S.Boolean),
+  }),
+).annotate({ identifier: "ProcessStatus" }) as any as S.Schema<ProcessStatus>;
+
+export type ComputerUseStartResponseStatusMap = {
+  [key: string]: ProcessStatus | undefined;
+};
+export const ComputerUseStartResponseStatusMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ProcessStatus,
+) as any as S.Schema<ComputerUseStartResponseStatusMap>;
+
+export interface ComputerUseStartResponse {
+  message?: string;
+  status?: ComputerUseStartResponseStatusMap;
+}
+export const ComputerUseStartResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    message: S.optional(S.String),
+    status: S.optional(ComputerUseStartResponseStatusMap),
+  }),
+).annotate({
+  identifier: "ComputerUseStartResponse",
+}) as any as S.Schema<ComputerUseStartResponse>;
+
+export interface StartRecordingRequest {
+  label?: string;
+}
+export const StartRecordingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    label: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/recordings/start", code: 200 }),
+  ),
+).annotate({
+  identifier: "StartRecordingRequest",
+}) as any as S.Schema<StartRecordingRequest>;
+
+export interface StopComputerUseRequest {}
+export const StopComputerUseRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({}).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/stop", code: 200 }),
+  ),
+).annotate({
+  identifier: "StopComputerUseRequest",
+}) as any as S.Schema<StopComputerUseRequest>;
+
+export type ComputerUseStopResponseStatusMap = {
+  [key: string]: ProcessStatus | undefined;
+};
+export const ComputerUseStopResponseStatusMap = /*@__PURE__*/ S.Record(
+  S.String,
+  ProcessStatus,
+) as any as S.Schema<ComputerUseStopResponseStatusMap>;
+
+export interface ComputerUseStopResponse {
+  message?: string;
+  status?: ComputerUseStopResponseStatusMap;
+}
+export const ComputerUseStopResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    message: S.optional(S.String),
+    status: S.optional(ComputerUseStopResponseStatusMap),
+  }),
+).annotate({
+  identifier: "ComputerUseStopResponse",
+}) as any as S.Schema<ComputerUseStopResponse>;
+
+export interface StopRecordingRequest {
+  id: string;
+}
+export const StopRecordingRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    id: S.String,
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/recordings/stop", code: 200 }),
+  ),
+).annotate({
+  identifier: "StopRecordingRequest",
+}) as any as S.Schema<StopRecordingRequest>;
+
+export interface TakeCompressedRegionScreenshotRequest {
+  /** X coordinate of the region */
+  x: number;
+  /** Y coordinate of the region */
+  y: number;
+  /** Width of the region */
+  width: number;
+  /** Height of the region */
+  height: number;
+  /** Whether to show cursor in screenshot */
+  showCursor?: boolean;
+  /** Image format (png or jpeg) */
+  format?: string;
+  /** JPEG quality (1-100) */
+  quality?: number;
+  /** Scale factor (0.1-1.0) */
+  scale?: number;
+}
+export const TakeCompressedRegionScreenshotRequest = /*@__PURE__*/ S.suspend(
+  () =>
+    S.Struct({
+      x: S.Number.pipe(T.Query()),
+      y: S.Number.pipe(T.Query()),
+      width: S.Number.pipe(T.Query()),
+      height: S.Number.pipe(T.Query()),
+      showCursor: S.optional(S.Boolean.pipe(T.Query())),
+      format: S.optional(S.String.pipe(T.Query())),
+      quality: S.optional(S.Number.pipe(T.Query())),
+      scale: S.optional(S.Number.pipe(T.Query())),
+    }).pipe(
+      T.Http({
+        method: "GET",
+        uri: "/computeruse/screenshot/region/compressed",
+        code: 200,
+      }),
+    ),
+).annotate({
+  identifier: "TakeCompressedRegionScreenshotRequest",
+}) as any as S.Schema<TakeCompressedRegionScreenshotRequest>;
+
+export interface Position {
+  x?: number;
+  y?: number;
+}
+export const Position = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    x: S.optional(S.Number),
+    y: S.optional(S.Number),
+  }),
+).annotate({ identifier: "Position" }) as any as S.Schema<Position>;
+
+export interface ScreenshotResponse {
+  cursorPosition?: Position;
+  screenshot?: string;
+  sizeBytes?: number;
+}
+export const ScreenshotResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    cursorPosition: S.optional(Position),
+    screenshot: S.optional(S.String),
+    sizeBytes: S.optional(S.Number),
+  }),
+).annotate({
+  identifier: "ScreenshotResponse",
+}) as any as S.Schema<ScreenshotResponse>;
+
+export interface TakeCompressedScreenshotRequest {
+  /** Whether to show cursor in screenshot */
+  showCursor?: boolean;
+  /** Image format (png or jpeg) */
+  format?: string;
+  /** JPEG quality (1-100) */
+  quality?: number;
+  /** Scale factor (0.1-1.0) */
+  scale?: number;
+}
+export const TakeCompressedScreenshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    showCursor: S.optional(S.Boolean.pipe(T.Query())),
+    format: S.optional(S.String.pipe(T.Query())),
+    quality: S.optional(S.Number.pipe(T.Query())),
+    scale: S.optional(S.Number.pipe(T.Query())),
+  }).pipe(
+    T.Http({
+      method: "GET",
+      uri: "/computeruse/screenshot/compressed",
+      code: 200,
+    }),
+  ),
+).annotate({
+  identifier: "TakeCompressedScreenshotRequest",
+}) as any as S.Schema<TakeCompressedScreenshotRequest>;
+
+export interface TakeRegionScreenshotRequest {
+  /** X coordinate of the region */
+  x: number;
+  /** Y coordinate of the region */
+  y: number;
+  /** Width of the region */
+  width: number;
+  /** Height of the region */
+  height: number;
+  /** Whether to show cursor in screenshot */
+  showCursor?: boolean;
+}
+export const TakeRegionScreenshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    x: S.Number.pipe(T.Query()),
+    y: S.Number.pipe(T.Query()),
+    width: S.Number.pipe(T.Query()),
+    height: S.Number.pipe(T.Query()),
+    showCursor: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(
+    T.Http({ method: "GET", uri: "/computeruse/screenshot/region", code: 200 }),
+  ),
+).annotate({
+  identifier: "TakeRegionScreenshotRequest",
+}) as any as S.Schema<TakeRegionScreenshotRequest>;
+
+export interface TakeScreenshotRequest {
+  /** Whether to show cursor in screenshot */
+  showCursor?: boolean;
+}
+export const TakeScreenshotRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    showCursor: S.optional(S.Boolean.pipe(T.Query())),
+  }).pipe(T.Http({ method: "GET", uri: "/computeruse/screenshot", code: 200 })),
+).annotate({
+  identifier: "TakeScreenshotRequest",
+}) as any as S.Schema<TakeScreenshotRequest>;
+
+export interface TypeTextRequest {
+  /** milliseconds between keystrokes */
+  delay?: number;
+  text?: string;
+}
+export const TypeTextRequest = /*@__PURE__*/ S.suspend(() =>
+  S.Struct({
+    delay: S.optional(S.Number),
+    text: S.optional(S.String),
+  }).pipe(
+    T.Http({ method: "POST", uri: "/computeruse/keyboard/type", code: 200 }),
+  ),
+).annotate({
+  identifier: "TypeTextRequest",
+}) as any as S.Schema<TypeTextRequest>;
+
+export type TypeTextResponse = unknown;
+export const TypeTextResponse = /*@__PURE__*/ S.suspend(() =>
+  S.Unknown.pipe(T.RawResponseRoot()),
+).annotate({
+  identifier: "TypeTextResponse",
+}) as any as S.Schema<TypeTextResponse>;
+
+export type ClickError = DaytonaOpError;
+/** Click mouse button Click the mouse button at the specified coordinates */
+export const click: API.OperationMethod<
+  ClickRequest,
+  MouseClickResponse,
+  ClickError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ClickRequest,
+  output: MouseClickResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DeleteRecordingError = DaytonaOpError;
+/** Delete a recording Delete a recording file by ID */
+export const deleteRecording: API.OperationMethod<
+  DeleteRecordingRequest,
+  DeleteRecordingResponse,
+  DeleteRecordingError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DeleteRecordingRequest,
+  output: DeleteRecordingResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DownloadRecordingError = DaytonaOpError;
+/** Download a recording Download a recording by providing its ID */
+export const downloadRecording: API.OperationMethod<
+  DownloadRecordingRequest,
+  DownloadRecordingResponse,
+  DownloadRecordingError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DownloadRecordingRequest,
+  output: DownloadRecordingResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type DragError = DaytonaOpError;
+/** Drag mouse Drag the mouse from start to end coordinates */
+export const drag: API.OperationMethod<
+  DragRequest,
+  MouseDragResponse,
+  DragError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: DragRequest,
+  output: MouseDragResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type FindAccessibilityNodesError = DaytonaOpError;
+/** Find accessibility nodes Search the AT-SPI tree for nodes matching a role/name/state filter and return a flat list. */
+export const findAccessibilityNodes: API.OperationMethod<
+  FindAccessibilityNodesRequest,
+  AccessibilityNodesResponse,
+  FindAccessibilityNodesError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: FindAccessibilityNodesRequest,
+  output: AccessibilityNodesResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type FocusAccessibilityNodeError = DaytonaOpError;
+/** Focus an accessibility node Move keyboard focus to the AT-SPI node identified by id (bus-name:object-path). */
+export const focusAccessibilityNode: API.OperationMethod<
+  FocusAccessibilityNodeRequest,
+  FocusAccessibilityNodeResponse,
+  FocusAccessibilityNodeError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: FocusAccessibilityNodeRequest,
+  output: FocusAccessibilityNodeResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetAccessibilityTreeError = DaytonaOpError;
+/** Get accessibility tree Fetch the AT-SPI accessibility tree for the focused application, a specific PID, or all registered applications. */
+export const getAccessibilityTree: API.OperationMethod<
+  GetAccessibilityTreeRequest,
+  AccessibilityTreeResponse,
+  GetAccessibilityTreeError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetAccessibilityTreeRequest,
+  output: AccessibilityTreeResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetComputerUseStatusError = DaytonaOpError;
+/** Get computer use process status Get the status of all computer use processes */
+export const getComputerUseStatus: API.OperationMethod<
+  GetComputerUseStatusRequest,
+  ComputerUseStatusResponse,
+  GetComputerUseStatusError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetComputerUseStatusRequest,
+  output: ComputerUseStatusResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetComputerUseSystemStatusError = DaytonaOpError;
+/** Get computer use status Get the current status of the computer use system */
+export const getComputerUseSystemStatus: API.OperationMethod<
+  GetComputerUseSystemStatusRequest,
+  ComputerUseStatusResponse,
+  GetComputerUseSystemStatusError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetComputerUseSystemStatusRequest,
+  output: ComputerUseStatusResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetDisplayInfoError = DaytonaOpError;
+/** Get display information Get information about all available displays */
+export const getDisplayInfo: API.OperationMethod<
+  GetDisplayInfoRequest,
+  DisplayInfoResponse,
+  GetDisplayInfoError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetDisplayInfoRequest,
+  output: DisplayInfoResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetMousePositionError = DaytonaOpError;
+/** Get mouse position Get the current mouse cursor position */
+export const getMousePosition: API.OperationMethod<
+  GetMousePositionRequest,
+  MousePositionResponse,
+  GetMousePositionError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetMousePositionRequest,
+  output: MousePositionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetProcessErrorsError = DaytonaOpError;
+/** Get process errors Get errors for a specific computer use process */
+export const getProcessErrors: API.OperationMethod<
+  GetProcessErrorsRequest,
+  ProcessErrorsResponse,
+  GetProcessErrorsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetProcessErrorsRequest,
+  output: ProcessErrorsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetProcessLogsError = DaytonaOpError;
+/** Get process logs Get logs for a specific computer use process */
+export const getProcessLogs: API.OperationMethod<
+  GetProcessLogsRequest,
+  ProcessLogsResponse,
+  GetProcessLogsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetProcessLogsRequest,
+  output: ProcessLogsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetProcessStatusError = DaytonaOpError;
+/** Get specific process status Check if a specific computer use process is running */
+export const getProcessStatus: API.OperationMethod<
+  GetProcessStatusRequest,
+  ProcessStatusResponse,
+  GetProcessStatusError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetProcessStatusRequest,
+  output: ProcessStatusResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetRecordingError = DaytonaOpError;
+/** Get recording details Get details of a specific recording by ID */
+export const getRecording: API.OperationMethod<
+  GetRecordingRequest,
+  Recording,
+  GetRecordingError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetRecordingRequest,
+  output: Recording,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type GetWindowsError = DaytonaOpError;
+/** Get windows information Get information about all open windows */
+export const getWindows: API.OperationMethod<
+  GetWindowsRequest,
+  WindowsResponse,
+  GetWindowsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: GetWindowsRequest,
+  output: WindowsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type InvokeAccessibilityNodeError = DaytonaOpError;
+/** Invoke an action on an accessibility node Call an AT-SPI Action on the node. Leave action empty to invoke the node's primary (first) action. */
+export const invokeAccessibilityNode: API.OperationMethod<
+  InvokeAccessibilityNodeRequest,
+  InvokeAccessibilityNodeResponse,
+  InvokeAccessibilityNodeError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: InvokeAccessibilityNodeRequest,
+  output: InvokeAccessibilityNodeResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ListRecordingsError = DaytonaOpError;
+/** List all recordings Get a list of all recordings (active and completed) */
+export const listRecordings: API.OperationMethod<
+  ListRecordingsRequest,
+  ListRecordingsResponse,
+  ListRecordingsError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ListRecordingsRequest,
+  output: ListRecordingsResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type MoveMouseError = DaytonaOpError;
+/** Move mouse cursor Move the mouse cursor to the specified coordinates */
+export const moveMouse: API.OperationMethod<
+  MoveMouseRequest,
+  MousePositionResponse,
+  MoveMouseError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: MoveMouseRequest,
+  output: MousePositionResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PressHotkeyError = DaytonaOpError;
+/** Press hotkey Press a hotkey combination (e.g., ctrl+c, cmd+v) */
+export const pressHotkey: API.OperationMethod<
+  PressHotkeyRequest,
+  PressHotkeyResponse,
+  PressHotkeyError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PressHotkeyRequest,
+  output: PressHotkeyResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type PressKeyError = DaytonaOpError;
+/** Press key Press a key with optional modifiers */
+export const pressKey: API.OperationMethod<
+  PressKeyRequest,
+  PressKeyResponse,
+  PressKeyError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: PressKeyRequest,
+  output: PressKeyResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type RestartProcessError = DaytonaOpError;
+/** Restart specific process Restart a specific computer use process */
+export const restartProcess: API.OperationMethod<
+  RestartProcessRequest,
+  ProcessRestartResponse,
+  RestartProcessError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: RestartProcessRequest,
+  output: ProcessRestartResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type ScrollError = DaytonaOpError;
+/** Scroll mouse wheel Scroll the mouse wheel at the specified coordinates */
+export const scroll: API.OperationMethod<
+  ScrollRequest,
+  ScrollResponse,
+  ScrollError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: ScrollRequest,
+  output: ScrollResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type SetAccessibilityNodeValueError = DaytonaOpError;
+/** Set the value of an accessibility node Write the given value to the node via EditableText.SetTextContents or, for numeric controls, Value.CurrentValue. */
+export const setAccessibilityNodeValue: API.OperationMethod<
+  SetAccessibilityNodeValueRequest,
+  SetAccessibilityNodeValueResponse,
+  SetAccessibilityNodeValueError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: SetAccessibilityNodeValueRequest,
+  output: SetAccessibilityNodeValueResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StartComputerUseError = DaytonaOpError;
+/** Start computer use processes Start all computer use processes and return their status */
+export const startComputerUse: API.OperationMethod<
+  StartComputerUseRequest,
+  ComputerUseStartResponse,
+  StartComputerUseError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StartComputerUseRequest,
+  output: ComputerUseStartResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StartRecordingError = DaytonaOpError;
+/** Start a new recording Start a new screen recording session */
+export const startRecording: API.OperationMethod<
+  StartRecordingRequest,
+  Recording,
+  StartRecordingError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StartRecordingRequest,
+  output: Recording,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StopComputerUseError = DaytonaOpError;
+/** Stop computer use processes Stop all computer use processes and return their status */
+export const stopComputerUse: API.OperationMethod<
+  StopComputerUseRequest,
+  ComputerUseStopResponse,
+  StopComputerUseError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StopComputerUseRequest,
+  output: ComputerUseStopResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type StopRecordingError = DaytonaOpError;
+/** Stop a recording Stop an active screen recording session */
+export const stopRecording: API.OperationMethod<
+  StopRecordingRequest,
+  Recording,
+  StopRecordingError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: StopRecordingRequest,
+  output: Recording,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TakeCompressedRegionScreenshotError = DaytonaOpError;
+/** Take a compressed region screenshot Take a compressed screenshot of a specific region of the screen */
+export const takeCompressedRegionScreenshot: API.OperationMethod<
+  TakeCompressedRegionScreenshotRequest,
+  ScreenshotResponse,
+  TakeCompressedRegionScreenshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TakeCompressedRegionScreenshotRequest,
+  output: ScreenshotResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TakeCompressedScreenshotError = DaytonaOpError;
+/** Take a compressed screenshot Take a compressed screenshot of the entire screen */
+export const takeCompressedScreenshot: API.OperationMethod<
+  TakeCompressedScreenshotRequest,
+  ScreenshotResponse,
+  TakeCompressedScreenshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TakeCompressedScreenshotRequest,
+  output: ScreenshotResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TakeRegionScreenshotError = DaytonaOpError;
+/** Take a region screenshot Take a screenshot of a specific region of the screen */
+export const takeRegionScreenshot: API.OperationMethod<
+  TakeRegionScreenshotRequest,
+  ScreenshotResponse,
+  TakeRegionScreenshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TakeRegionScreenshotRequest,
+  output: ScreenshotResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TakeScreenshotError = DaytonaOpError;
+/** Take a screenshot Take a screenshot of the entire screen */
+export const takeScreenshot: API.OperationMethod<
+  TakeScreenshotRequest,
+  ScreenshotResponse,
+  TakeScreenshotError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TakeScreenshotRequest,
+  output: ScreenshotResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));
+
+export type TypeTextError = DaytonaOpError;
+/** Type text Type text with optional delay between keystrokes */
+export const typeText: API.OperationMethod<
+  TypeTextRequest,
+  TypeTextResponse,
+  TypeTextError,
+  DaytonaOpContext
+> = /*@__PURE__*/ API.make(() => ({
+  input: TypeTextRequest,
+  output: TypeTextResponse,
+  errors: [UnknownDaytonaError],
+  protocol: DaytonaProtocol,
+  retry: Retry.Retry,
+}));