cyberdesk 0.2.1 → 1.1.0

package/dist/client/types.gen.d.ts

@@ -1,724 +1,1237 @@
-export type GetV1DesktopByIdData = {
+/**
+ * Schema for creating a connection
+ */
+export type ConnectionCreate = {
+    websocket_id: string;
+    ip_address?: string | null;
+    user_agent?: string | null;
+    machine_id: string;
+};
+/**
+ * Connection response schema
+ */
+export type ConnectionResponse = {
+    websocket_id: string;
+    ip_address?: string | null;
+    user_agent?: string | null;
+    id: string;
+    machine_id: string;
+    connected_at: string;
+    disconnected_at: string | null;
+    last_ping: string;
+    status: ConnectionStatus;
+};
+export type ConnectionStatus = 'connected' | 'disconnected' | 'error';
+/**
+ * Schema for updating a connection
+ */
+export type ConnectionUpdate = {
+    status?: ConnectionStatus | null;
+    last_ping?: string | null;
+    disconnected_at?: string | null;
+};
+export type DisplayDimensions = {
+    width: number;
+    height: number;
+};
+export type HttpValidationError = {
+    detail?: Array<ValidationError>;
+};
+export type KeyboardKeyRequest = {
+    text: string;
+};
+export type KeyboardTypeRequest = {
+    text: string;
+};
+/**
+ * Schema for creating a machine
+ */
+export type MachineCreate = {
+    fingerprint: string;
+    version?: string | null;
+    hostname?: string | null;
+    os_info?: string | null;
+    unkey_key_id: string;
+};
+/**
+ * Machine response schema
+ */
+export type MachineResponse = {
+    fingerprint: string;
+    version?: string | null;
+    hostname?: string | null;
+    os_info?: string | null;
+    id: string;
+    user_id: string;
+    unkey_key_id: string;
+    status: MachineStatus;
+    is_available: boolean;
+    created_at: string;
+    last_seen: string;
+};
+export type MachineStatus = 'connected' | 'disconnected' | 'error';
+/**
+ * Schema for updating a machine
+ */
+export type MachineUpdate = {
+    version?: string | null;
+    hostname?: string | null;
+    os_info?: string | null;
+    status?: MachineStatus | null;
+    is_available?: boolean | null;
+    last_seen?: string | null;
+};
+export type MouseClickRequest = {
+    x?: number | null;
+    y?: number | null;
+    button?: string;
+    down?: boolean;
+};
+export type MouseMoveRequest = {
+    x: number;
+    y: number;
+};
+export type MousePosition = {
+    x: number;
+    y: number;
+};
+/**
+ * Paginated response wrapper
+ */
+export type PaginatedResponse = {
+    items: Array<unknown>;
+    total: number;
+    skip: number;
+    limit: number;
+};
+export type PaginatedResponseConnectionResponse = {
+    items: Array<ConnectionResponse>;
+    total: number;
+    skip: number;
+    limit: number;
+};
+export type PaginatedResponseMachineResponse = {
+    items: Array<MachineResponse>;
+    total: number;
+    skip: number;
+    limit: number;
+};
+export type PaginatedResponseRunResponse = {
+    items: Array<RunResponse>;
+    total: number;
+    skip: number;
+    limit: number;
+};
+export type PaginatedResponseTrajectoryResponse = {
+    items: Array<TrajectoryResponse>;
+    total: number;
+    skip: number;
+    limit: number;
+};
+export type PaginatedResponseWorkflowResponse = {
+    items: Array<WorkflowResponse>;
+    total: number;
+    skip: number;
+    limit: number;
+};
+/**
+ * Schema for creating a request log
+ */
+export type RequestLogCreate = {
+    request_id: string;
+    method: string;
+    path: string;
+    status_code?: number | null;
+    request_size_bytes?: number | null;
+    response_size_bytes?: number | null;
+    duration_ms?: number | null;
+    error_message?: string | null;
+    machine_id: string;
+};
+/**
+ * Request log response schema
+ */
+export type RequestLogResponse = {
+    request_id: string;
+    method: string;
+    path: string;
+    status_code?: number | null;
+    request_size_bytes?: number | null;
+    response_size_bytes?: number | null;
+    duration_ms?: number | null;
+    error_message?: string | null;
+    id: string;
+    machine_id: string;
+    created_at: string;
+    completed_at: string | null;
+};
+/**
+ * Schema for updating a request log
+ */
+export type RequestLogUpdate = {
+    status_code?: number | null;
+    response_size_bytes?: number | null;
+    completed_at?: string | null;
+    duration_ms?: number | null;
+    error_message?: string | null;
+};
+/**
+ * Schema for creating a run
+ */
+export type RunCreate = {
+    workflow_id: string;
+    /**
+     * Machine ID. If not provided, an available machine will be automatically selected.
+     */
+    machine_id?: string | null;
+};
+/**
+ * Run response schema
+ */
+export type RunResponse = {
+    workflow_id: string;
+    machine_id: string;
+    id: string;
+    user_id: string;
+    status: RunStatus;
+    error: Array<string> | null;
+    output_data: {
+        [key: string]: unknown;
+    } | null;
+    output_attachment_ids: Array<string> | null;
+    run_message_history: Array<{
+        [key: string]: unknown;
+    }> | null;
+    created_at: string;
+};
+export type RunStatus = 'scheduling' | 'running' | 'success' | 'cancelled' | 'error';
+/**
+ * Schema for updating a run
+ */
+export type RunUpdate = {
+    status?: RunStatus | null;
+    error?: Array<string> | null;
+    output_data?: {
+        [key: string]: unknown;
+    } | null;
+    output_attachment_ids?: Array<string> | null;
+    run_message_history?: Array<{
+        [key: string]: unknown;
+    }> | null;
+};
+/**
+ * Schema for creating a trajectory
+ */
+export type TrajectoryCreate = {
+    workflow_id: string;
+    trajectory_data: Array<{
+        [key: string]: unknown;
+    }>;
+};
+/**
+ * Trajectory response schema
+ */
+export type TrajectoryResponse = {
+    workflow_id: string;
+    trajectory_data: Array<{
+        [key: string]: unknown;
+    }>;
+    id: string;
+    user_id: string;
+    created_at: string;
+    updated_at: string;
+};
+/**
+ * Schema for updating a trajectory
+ */
+export type TrajectoryUpdate = {
+    trajectory_data?: Array<{
+        [key: string]: unknown;
+    }> | null;
+};
+export type ValidationError = {
+    loc: Array<string | number>;
+    msg: string;
+    type: string;
+};
+/**
+ * Schema for creating a workflow
+ */
+export type WorkflowCreate = {
+    main_prompt: string;
+    cleanup_prompt?: string | null;
+};
+/**
+ * Workflow response schema
+ */
+export type WorkflowResponse = {
+    main_prompt: string;
+    cleanup_prompt?: string | null;
+    id: string;
+    user_id: string;
+    old_versions?: Array<{
+        [key: string]: unknown;
+    }> | null;
+    created_at: string;
+    updated_at: string;
+};
+/**
+ * Schema for updating a workflow
+ */
+export type WorkflowUpdate = {
+    main_prompt?: string | null;
+    cleanup_prompt?: string | null;
+};
+export type HealthCheckV1HealthGetData = {
     body?: never;
-    headers: {
-        /**
-         * API key for authentication
-         */
-        'x-api-key': string;
-    };
-    path: {
-        /**
-         * The UUID of the desktop instance to retrieve
-         */
-        id: string;
-    };
+    path?: never;
     query?: never;
-    url: '/v1/desktop/{id}';
+    url: '/v1/health';
 };
-export type GetV1DesktopByIdErrors = {
+export type HealthCheckV1HealthGetResponses = {
     /**
-     * The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
+     * Successful Response
      */
-    400: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    200: {
+        [key: string]: string;
     };
+};
+export type HealthCheckV1HealthGetResponse = HealthCheckV1HealthGetResponses[keyof HealthCheckV1HealthGetResponses];
+export type DatabaseHealthCheckV1HealthDbGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/health/db';
+};
+export type DatabaseHealthCheckV1HealthDbGetResponses = {
     /**
-     * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
+     * Successful Response
      */
-    401: {
-        status: 'error';
+    200: {
+        [key: string]: string;
+    };
+};
+export type DatabaseHealthCheckV1HealthDbGetResponse = DatabaseHealthCheckV1HealthDbGetResponses[keyof DatabaseHealthCheckV1HealthDbGetResponses];
+export type ListMachinesV1MachinesGetData = {
+    body?: never;
+    path?: never;
+    query?: {
         /**
-         * Error message detailing what went wrong
+         * Filter by machine status
          */
-        error: string;
+        status?: MachineStatus | null;
+        skip?: number;
+        limit?: number;
     };
+    url: '/v1/machines';
+};
+export type ListMachinesV1MachinesGetErrors = {
     /**
-     * The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server.
+     * Validation Error
      */
-    403: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type ListMachinesV1MachinesGetError = ListMachinesV1MachinesGetErrors[keyof ListMachinesV1MachinesGetErrors];
+export type ListMachinesV1MachinesGetResponses = {
     /**
-     * The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web.
+     * Successful Response
      */
-    404: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    200: PaginatedResponseMachineResponse;
+};
+export type ListMachinesV1MachinesGetResponse = ListMachinesV1MachinesGetResponses[keyof ListMachinesV1MachinesGetResponses];
+export type CreateMachineV1MachinesPostData = {
+    body: MachineCreate;
+    path?: never;
+    query?: never;
+    url: '/v1/machines';
+};
+export type CreateMachineV1MachinesPostErrors = {
     /**
-     * This response is sent when a request conflicts with the current state of the server.
+     * Validation Error
      */
-    409: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type CreateMachineV1MachinesPostError = CreateMachineV1MachinesPostErrors[keyof CreateMachineV1MachinesPostErrors];
+export type CreateMachineV1MachinesPostResponses = {
     /**
-     * The user has sent too many requests in a given amount of time ("rate limiting")
+     * Successful Response
      */
-    429: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    201: MachineResponse;
+};
+export type CreateMachineV1MachinesPostResponse = CreateMachineV1MachinesPostResponses[keyof CreateMachineV1MachinesPostResponses];
+export type DeleteMachineV1MachinesMachineIdDeleteData = {
+    body?: never;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/machines/{machine_id}';
+};
+export type DeleteMachineV1MachinesMachineIdDeleteErrors = {
     /**
-     * The server has encountered a situation it does not know how to handle.
+     * Validation Error
      */
-    500: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type DeleteMachineV1MachinesMachineIdDeleteError = DeleteMachineV1MachinesMachineIdDeleteErrors[keyof DeleteMachineV1MachinesMachineIdDeleteErrors];
+export type DeleteMachineV1MachinesMachineIdDeleteResponses = {
     /**
-     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     * Successful Response
      */
-    502: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    204: void;
+};
+export type DeleteMachineV1MachinesMachineIdDeleteResponse = DeleteMachineV1MachinesMachineIdDeleteResponses[keyof DeleteMachineV1MachinesMachineIdDeleteResponses];
+export type GetMachineV1MachinesMachineIdGetData = {
+    body?: never;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/machines/{machine_id}';
 };
-export type GetV1DesktopByIdError = GetV1DesktopByIdErrors[keyof GetV1DesktopByIdErrors];
-export type GetV1DesktopByIdResponses = {
+export type GetMachineV1MachinesMachineIdGetErrors = {
     /**
-     * Desktop instance details retrieved successfully
+     * Validation Error
      */
-    200: {
-        /**
-         * Unique identifier for the desktop instance
-         */
-        id: string;
-        /**
-         * Current status of the desktop instance
-         */
-        status: 'pending' | 'running' | 'terminated' | 'error';
-        /**
-         * URL for the desktop stream (null if the desktop is not running)
-         */
-        stream_url: string;
-        /**
-         * Timestamp when the instance was created
-         */
-        created_at: string;
-        /**
-         * Timestamp when the instance will automatically time out
-         */
-        timeout_at: string;
-    };
+    422: HttpValidationError;
 };
-export type GetV1DesktopByIdResponse = GetV1DesktopByIdResponses[keyof GetV1DesktopByIdResponses];
-export type PostV1DesktopData = {
-    body?: {
-        /**
-         * Timeout in milliseconds for the desktop session
-         */
-        timeout_ms?: number;
+export type GetMachineV1MachinesMachineIdGetError = GetMachineV1MachinesMachineIdGetErrors[keyof GetMachineV1MachinesMachineIdGetErrors];
+export type GetMachineV1MachinesMachineIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: MachineResponse;
+};
+export type GetMachineV1MachinesMachineIdGetResponse = GetMachineV1MachinesMachineIdGetResponses[keyof GetMachineV1MachinesMachineIdGetResponses];
+export type UpdateMachineV1MachinesMachineIdPatchData = {
+    body: MachineUpdate;
+    path: {
+        machine_id: string;
     };
-    headers: {
-        /**
-         * API key for authentication
-         */
-        'x-api-key': string;
+    query?: never;
+    url: '/v1/machines/{machine_id}';
+};
+export type UpdateMachineV1MachinesMachineIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type UpdateMachineV1MachinesMachineIdPatchError = UpdateMachineV1MachinesMachineIdPatchErrors[keyof UpdateMachineV1MachinesMachineIdPatchErrors];
+export type UpdateMachineV1MachinesMachineIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: MachineResponse;
+};
+export type UpdateMachineV1MachinesMachineIdPatchResponse = UpdateMachineV1MachinesMachineIdPatchResponses[keyof UpdateMachineV1MachinesMachineIdPatchResponses];
+export type ListWorkflowsV1WorkflowsGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        skip?: number;
+        limit?: number;
     };
+    url: '/v1/workflows';
+};
+export type ListWorkflowsV1WorkflowsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type ListWorkflowsV1WorkflowsGetError = ListWorkflowsV1WorkflowsGetErrors[keyof ListWorkflowsV1WorkflowsGetErrors];
+export type ListWorkflowsV1WorkflowsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: PaginatedResponseWorkflowResponse;
+};
+export type ListWorkflowsV1WorkflowsGetResponse = ListWorkflowsV1WorkflowsGetResponses[keyof ListWorkflowsV1WorkflowsGetResponses];
+export type CreateWorkflowV1WorkflowsPostData = {
+    body: WorkflowCreate;
     path?: never;
     query?: never;
-    url: '/v1/desktop';
+    url: '/v1/workflows';
 };
-export type PostV1DesktopErrors = {
+export type CreateWorkflowV1WorkflowsPostErrors = {
     /**
-     * The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
+     * Validation Error
      */
-    400: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type CreateWorkflowV1WorkflowsPostError = CreateWorkflowV1WorkflowsPostErrors[keyof CreateWorkflowV1WorkflowsPostErrors];
+export type CreateWorkflowV1WorkflowsPostResponses = {
     /**
-     * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
+     * Successful Response
      */
-    401: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    201: WorkflowResponse;
+};
+export type CreateWorkflowV1WorkflowsPostResponse = CreateWorkflowV1WorkflowsPostResponses[keyof CreateWorkflowV1WorkflowsPostResponses];
+export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteData = {
+    body?: never;
+    path: {
+        workflow_id: string;
     };
+    query?: never;
+    url: '/v1/workflows/{workflow_id}';
+};
+export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteErrors = {
     /**
-     * The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server.
+     * Validation Error
      */
-    403: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteError = DeleteWorkflowV1WorkflowsWorkflowIdDeleteErrors[keyof DeleteWorkflowV1WorkflowsWorkflowIdDeleteErrors];
+export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteResponses = {
     /**
-     * The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web.
+     * Successful Response
      */
-    404: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    204: void;
+};
+export type DeleteWorkflowV1WorkflowsWorkflowIdDeleteResponse = DeleteWorkflowV1WorkflowsWorkflowIdDeleteResponses[keyof DeleteWorkflowV1WorkflowsWorkflowIdDeleteResponses];
+export type GetWorkflowV1WorkflowsWorkflowIdGetData = {
+    body?: never;
+    path: {
+        workflow_id: string;
     };
+    query?: never;
+    url: '/v1/workflows/{workflow_id}';
+};
+export type GetWorkflowV1WorkflowsWorkflowIdGetErrors = {
     /**
-     * This response is sent when a request conflicts with the current state of the server.
+     * Validation Error
      */
-    409: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type GetWorkflowV1WorkflowsWorkflowIdGetError = GetWorkflowV1WorkflowsWorkflowIdGetErrors[keyof GetWorkflowV1WorkflowsWorkflowIdGetErrors];
+export type GetWorkflowV1WorkflowsWorkflowIdGetResponses = {
     /**
-     * The user has sent too many requests in a given amount of time ("rate limiting")
+     * Successful Response
      */
-    429: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    200: WorkflowResponse;
+};
+export type GetWorkflowV1WorkflowsWorkflowIdGetResponse = GetWorkflowV1WorkflowsWorkflowIdGetResponses[keyof GetWorkflowV1WorkflowsWorkflowIdGetResponses];
+export type UpdateWorkflowV1WorkflowsWorkflowIdPatchData = {
+    body: WorkflowUpdate;
+    path: {
+        workflow_id: string;
     };
+    query?: never;
+    url: '/v1/workflows/{workflow_id}';
+};
+export type UpdateWorkflowV1WorkflowsWorkflowIdPatchErrors = {
     /**
-     * The server has encountered a situation it does not know how to handle.
+     * Validation Error
      */
-    500: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type UpdateWorkflowV1WorkflowsWorkflowIdPatchError = UpdateWorkflowV1WorkflowsWorkflowIdPatchErrors[keyof UpdateWorkflowV1WorkflowsWorkflowIdPatchErrors];
+export type UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses = {
     /**
-     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     * Successful Response
      */
-    502: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    200: WorkflowResponse;
+};
+export type UpdateWorkflowV1WorkflowsWorkflowIdPatchResponse = UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses[keyof UpdateWorkflowV1WorkflowsWorkflowIdPatchResponses];
+export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetData = {
+    body?: never;
+    path: {
+        workflow_id: string;
     };
+    query?: never;
+    url: '/v1/workflows/{workflow_id}/versions';
 };
-export type PostV1DesktopError = PostV1DesktopErrors[keyof PostV1DesktopErrors];
-export type PostV1DesktopResponses = {
+export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors = {
     /**
-     * Desktop creation initiated successfully
+     * Validation Error
      */
-    200: {
+    422: HttpValidationError;
+};
+export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetError = GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors[keyof GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetErrors];
+export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: Array<{
+        [key: string]: unknown;
+    }>;
+};
+export type GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetResponse = GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetResponses[keyof GetWorkflowVersionsV1WorkflowsWorkflowIdVersionsGetResponses];
+export type ListRunsV1RunsGetData = {
+    body?: never;
+    path?: never;
+    query?: {
         /**
-         * Unique identifier for the desktop instance
+         * Filter by workflow ID
          */
-        id: string;
+        workflow_id?: string | null;
         /**
-         * Initial status of the desktop instance after creation request
+         * Filter by machine ID
          */
-        status: 'pending' | 'running' | 'terminated' | 'error';
-    };
-};
-export type PostV1DesktopResponse = PostV1DesktopResponses[keyof PostV1DesktopResponses];
-export type PostV1DesktopByIdStopData = {
-    body?: never;
-    headers: {
+        machine_id?: string | null;
         /**
-         * API key for authentication
+         * Filter by run status
          */
-        'x-api-key': string;
+        status?: RunStatus | null;
+        skip?: number;
+        limit?: number;
     };
+    url: '/v1/runs';
+};
+export type ListRunsV1RunsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type ListRunsV1RunsGetError = ListRunsV1RunsGetErrors[keyof ListRunsV1RunsGetErrors];
+export type ListRunsV1RunsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: PaginatedResponseRunResponse;
+};
+export type ListRunsV1RunsGetResponse = ListRunsV1RunsGetResponses[keyof ListRunsV1RunsGetResponses];
+export type CreateRunV1RunsPostData = {
+    body: RunCreate;
+    path?: never;
+    query?: never;
+    url: '/v1/runs';
+};
+export type CreateRunV1RunsPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type CreateRunV1RunsPostError = CreateRunV1RunsPostErrors[keyof CreateRunV1RunsPostErrors];
+export type CreateRunV1RunsPostResponses = {
+    /**
+     * Successful Response
+     */
+    201: RunResponse;
+};
+export type CreateRunV1RunsPostResponse = CreateRunV1RunsPostResponses[keyof CreateRunV1RunsPostResponses];
+export type DeleteRunV1RunsRunIdDeleteData = {
+    body?: never;
     path: {
-        /**
-         * Desktop instance ID to stop
-         */
-        id: string;
+        run_id: string;
     };
     query?: never;
-    url: '/v1/desktop/{id}/stop';
+    url: '/v1/runs/{run_id}';
 };
-export type PostV1DesktopByIdStopErrors = {
+export type DeleteRunV1RunsRunIdDeleteErrors = {
     /**
-     * The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
+     * Validation Error
      */
-    400: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type DeleteRunV1RunsRunIdDeleteError = DeleteRunV1RunsRunIdDeleteErrors[keyof DeleteRunV1RunsRunIdDeleteErrors];
+export type DeleteRunV1RunsRunIdDeleteResponses = {
     /**
-     * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
+     * Successful Response
      */
-    401: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    204: void;
+};
+export type DeleteRunV1RunsRunIdDeleteResponse = DeleteRunV1RunsRunIdDeleteResponses[keyof DeleteRunV1RunsRunIdDeleteResponses];
+export type GetRunV1RunsRunIdGetData = {
+    body?: never;
+    path: {
+        run_id: string;
     };
+    query?: never;
+    url: '/v1/runs/{run_id}';
+};
+export type GetRunV1RunsRunIdGetErrors = {
     /**
-     * The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server.
+     * Validation Error
      */
-    403: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type GetRunV1RunsRunIdGetError = GetRunV1RunsRunIdGetErrors[keyof GetRunV1RunsRunIdGetErrors];
+export type GetRunV1RunsRunIdGetResponses = {
     /**
-     * The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web.
+     * Successful Response
      */
-    404: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    200: RunResponse;
+};
+export type GetRunV1RunsRunIdGetResponse = GetRunV1RunsRunIdGetResponses[keyof GetRunV1RunsRunIdGetResponses];
+export type UpdateRunV1RunsRunIdPatchData = {
+    body: RunUpdate;
+    path: {
+        run_id: string;
     };
+    query?: never;
+    url: '/v1/runs/{run_id}';
+};
+export type UpdateRunV1RunsRunIdPatchErrors = {
     /**
-     * This response is sent when a request conflicts with the current state of the server.
+     * Validation Error
      */
-    409: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type UpdateRunV1RunsRunIdPatchError = UpdateRunV1RunsRunIdPatchErrors[keyof UpdateRunV1RunsRunIdPatchErrors];
+export type UpdateRunV1RunsRunIdPatchResponses = {
     /**
-     * The user has sent too many requests in a given amount of time ("rate limiting")
+     * Successful Response
      */
-    429: {
-        status: 'error';
+    200: RunResponse;
+};
+export type UpdateRunV1RunsRunIdPatchResponse = UpdateRunV1RunsRunIdPatchResponses[keyof UpdateRunV1RunsRunIdPatchResponses];
+export type ListConnectionsV1ConnectionsGetData = {
+    body?: never;
+    path?: never;
+    query?: {
+        /**
+         * Filter by machine ID
+         */
+        machine_id?: string | null;
         /**
-         * Error message detailing what went wrong
+         * Filter by connection status
          */
-        error: string;
+        status?: ConnectionStatus | null;
+        skip?: number;
+        limit?: number;
     };
+    url: '/v1/connections';
+};
+export type ListConnectionsV1ConnectionsGetErrors = {
     /**
-     * The server has encountered a situation it does not know how to handle.
+     * Validation Error
      */
-    500: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type ListConnectionsV1ConnectionsGetError = ListConnectionsV1ConnectionsGetErrors[keyof ListConnectionsV1ConnectionsGetErrors];
+export type ListConnectionsV1ConnectionsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: PaginatedResponseConnectionResponse;
+};
+export type ListConnectionsV1ConnectionsGetResponse = ListConnectionsV1ConnectionsGetResponses[keyof ListConnectionsV1ConnectionsGetResponses];
+export type CreateConnectionV1ConnectionsPostData = {
+    body: ConnectionCreate;
+    path?: never;
+    query?: never;
+    url: '/v1/connections';
+};
+export type CreateConnectionV1ConnectionsPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type CreateConnectionV1ConnectionsPostError = CreateConnectionV1ConnectionsPostErrors[keyof CreateConnectionV1ConnectionsPostErrors];
+export type CreateConnectionV1ConnectionsPostResponses = {
+    /**
+     * Successful Response
+     */
+    201: ConnectionResponse;
+};
+export type CreateConnectionV1ConnectionsPostResponse = CreateConnectionV1ConnectionsPostResponses[keyof CreateConnectionV1ConnectionsPostResponses];
+export type DeleteConnectionV1ConnectionsConnectionIdDeleteData = {
+    body?: never;
+    path: {
+        connection_id: string;
     };
+    query?: never;
+    url: '/v1/connections/{connection_id}';
+};
+export type DeleteConnectionV1ConnectionsConnectionIdDeleteErrors = {
     /**
-     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     * Validation Error
      */
-    502: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type DeleteConnectionV1ConnectionsConnectionIdDeleteError = DeleteConnectionV1ConnectionsConnectionIdDeleteErrors[keyof DeleteConnectionV1ConnectionsConnectionIdDeleteErrors];
+export type DeleteConnectionV1ConnectionsConnectionIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    204: void;
+};
+export type DeleteConnectionV1ConnectionsConnectionIdDeleteResponse = DeleteConnectionV1ConnectionsConnectionIdDeleteResponses[keyof DeleteConnectionV1ConnectionsConnectionIdDeleteResponses];
+export type GetConnectionV1ConnectionsConnectionIdGetData = {
+    body?: never;
+    path: {
+        connection_id: string;
     };
+    query?: never;
+    url: '/v1/connections/{connection_id}';
 };
-export type PostV1DesktopByIdStopError = PostV1DesktopByIdStopErrors[keyof PostV1DesktopByIdStopErrors];
-export type PostV1DesktopByIdStopResponses = {
+export type GetConnectionV1ConnectionsConnectionIdGetErrors = {
     /**
-     * Desktop stopped successfully
+     * Validation Error
      */
-    200: {
-        /**
-         * Status of the desktop instance after stopping
-         */
-        status: 'pending' | 'running' | 'terminated' | 'error';
+    422: HttpValidationError;
+};
+export type GetConnectionV1ConnectionsConnectionIdGetError = GetConnectionV1ConnectionsConnectionIdGetErrors[keyof GetConnectionV1ConnectionsConnectionIdGetErrors];
+export type GetConnectionV1ConnectionsConnectionIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: ConnectionResponse;
+};
+export type GetConnectionV1ConnectionsConnectionIdGetResponse = GetConnectionV1ConnectionsConnectionIdGetResponses[keyof GetConnectionV1ConnectionsConnectionIdGetResponses];
+export type UpdateConnectionV1ConnectionsConnectionIdPatchData = {
+    body: ConnectionUpdate;
+    path: {
+        connection_id: string;
     };
+    query?: never;
+    url: '/v1/connections/{connection_id}';
 };
-export type PostV1DesktopByIdStopResponse = PostV1DesktopByIdStopResponses[keyof PostV1DesktopByIdStopResponses];
-export type PostV1DesktopByIdComputerActionData = {
-    body?: {
-        /**
-         * Perform a mouse action: click, press (down), or release (up). Defaults to a single left click at the current position.
-         */
-        type: 'click_mouse';
-        /**
-         * X coordinate for the action (optional, uses current position if omitted)
-         */
-        x?: number;
-        /**
-         * Y coordinate for the action (optional, uses current position if omitted)
-         */
-        y?: number;
-        /**
-         * Mouse button to use (optional, defaults to 'left')
-         */
-        button?: 'left' | 'right' | 'middle';
-        /**
-         * Number of clicks to perform (optional, defaults to 1, only applicable for 'click' type)
-         */
-        num_of_clicks?: number;
-        /**
-         * Type of mouse action (optional, defaults to 'click')
-         */
-        click_type?: 'click' | 'down' | 'up';
-    } | {
-        /**
-         * Scroll the mouse wheel in the specified direction
-         */
-        type: 'scroll';
-        /**
-         * Direction to scroll
-         */
-        direction: 'up' | 'down' | 'left' | 'right';
-        /**
-         * Amount to scroll in pixels
-         */
-        amount: number;
-    } | {
-        /**
-         * Move the mouse cursor to the specified coordinates
-         */
-        type: 'move_mouse';
-        /**
-         * X coordinate to move to
-         */
-        x: number;
-        /**
-         * Y coordinate to move to
-         */
-        y: number;
-    } | {
-        /**
-         * Drag the mouse from start to end coordinates
-         */
-        type: 'drag_mouse';
-        /**
-         * Starting coordinates for the drag operation
-         */
-        start: {
-            /**
-             * X coordinate on the screen
-             */
-            x: number;
-            /**
-             * Y coordinate on the screen
-             */
-            y: number;
-        };
-        /**
-         * Ending coordinates for the drag operation
-         */
-        end: {
-            /**
-             * X coordinate on the screen
-             */
-            x: number;
-            /**
-             * Y coordinate on the screen
-             */
-            y: number;
-        };
-    } | {
-        /**
-         * Type text at the current cursor position
-         */
-        type: 'type';
-        /**
-         * Text to type
-         */
-        text: string;
-    } | {
-        /**
-         * Press, hold down, or release one or more keyboard keys. Defaults to a single press and release.
-         */
-        type: 'press_keys';
-        keys: string | Array<string>;
-        /**
-         * Type of key action (optional, defaults to 'press' which is a down and up action)
-         */
-        key_action_type?: 'press' | 'down' | 'up';
-    } | {
-        /**
-         * Wait for the specified number of milliseconds
-         */
-        type: 'wait';
-        /**
-         * Time to wait in milliseconds
-         */
-        ms: number;
-    } | {
+export type UpdateConnectionV1ConnectionsConnectionIdPatchErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type UpdateConnectionV1ConnectionsConnectionIdPatchError = UpdateConnectionV1ConnectionsConnectionIdPatchErrors[keyof UpdateConnectionV1ConnectionsConnectionIdPatchErrors];
+export type UpdateConnectionV1ConnectionsConnectionIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: ConnectionResponse;
+};
+export type UpdateConnectionV1ConnectionsConnectionIdPatchResponse = UpdateConnectionV1ConnectionsConnectionIdPatchResponses[keyof UpdateConnectionV1ConnectionsConnectionIdPatchResponses];
+export type ListRequestLogsV1RequestLogsGetData = {
+    body?: never;
+    path?: never;
+    query?: {
         /**
-         * Take a screenshot of the desktop
+         * Filter by machine ID
          */
-        type: 'screenshot';
-    } | {
+        machine_id?: string | null;
         /**
-         * Get the current mouse cursor position
+         * Filter by HTTP method
          */
-        type: 'get_cursor_position';
-    };
-    headers: {
+        method?: string | null;
         /**
-         * API key for authentication
+         * Filter by status code
          */
-        'x-api-key': string;
+        status_code?: number | null;
+        skip?: number;
+        limit?: number;
     };
+    url: '/v1/request-logs';
+};
+export type ListRequestLogsV1RequestLogsGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type ListRequestLogsV1RequestLogsGetError = ListRequestLogsV1RequestLogsGetErrors[keyof ListRequestLogsV1RequestLogsGetErrors];
+export type ListRequestLogsV1RequestLogsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: PaginatedResponse;
+};
+export type ListRequestLogsV1RequestLogsGetResponse = ListRequestLogsV1RequestLogsGetResponses[keyof ListRequestLogsV1RequestLogsGetResponses];
+export type CreateRequestLogV1RequestLogsPostData = {
+    body: RequestLogCreate;
+    path?: never;
+    query?: never;
+    url: '/v1/request-logs';
+};
+export type CreateRequestLogV1RequestLogsPostErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type CreateRequestLogV1RequestLogsPostError = CreateRequestLogV1RequestLogsPostErrors[keyof CreateRequestLogV1RequestLogsPostErrors];
+export type CreateRequestLogV1RequestLogsPostResponses = {
+    /**
+     * Successful Response
+     */
+    201: RequestLogResponse;
+};
+export type CreateRequestLogV1RequestLogsPostResponse = CreateRequestLogV1RequestLogsPostResponses[keyof CreateRequestLogV1RequestLogsPostResponses];
+export type DeleteRequestLogV1RequestLogsLogIdDeleteData = {
+    body?: never;
     path: {
-        /**
-         * Desktop instance ID to perform the action on
-         */
-        id: string;
+        log_id: string;
     };
     query?: never;
-    url: '/v1/desktop/{id}/computer-action';
+    url: '/v1/request-logs/{log_id}';
 };
-export type PostV1DesktopByIdComputerActionErrors = {
+export type DeleteRequestLogV1RequestLogsLogIdDeleteErrors = {
     /**
-     * The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
+     * Validation Error
      */
-    400: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type DeleteRequestLogV1RequestLogsLogIdDeleteError = DeleteRequestLogV1RequestLogsLogIdDeleteErrors[keyof DeleteRequestLogV1RequestLogsLogIdDeleteErrors];
+export type DeleteRequestLogV1RequestLogsLogIdDeleteResponses = {
     /**
-     * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
+     * Successful Response
      */
-    401: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    204: void;
+};
+export type DeleteRequestLogV1RequestLogsLogIdDeleteResponse = DeleteRequestLogV1RequestLogsLogIdDeleteResponses[keyof DeleteRequestLogV1RequestLogsLogIdDeleteResponses];
+export type GetRequestLogV1RequestLogsLogIdGetData = {
+    body?: never;
+    path: {
+        log_id: string;
     };
+    query?: never;
+    url: '/v1/request-logs/{log_id}';
+};
+export type GetRequestLogV1RequestLogsLogIdGetErrors = {
     /**
-     * The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server.
+     * Validation Error
      */
-    403: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type GetRequestLogV1RequestLogsLogIdGetError = GetRequestLogV1RequestLogsLogIdGetErrors[keyof GetRequestLogV1RequestLogsLogIdGetErrors];
+export type GetRequestLogV1RequestLogsLogIdGetResponses = {
     /**
-     * The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web.
+     * Successful Response
      */
-    404: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    200: RequestLogResponse;
+};
+export type GetRequestLogV1RequestLogsLogIdGetResponse = GetRequestLogV1RequestLogsLogIdGetResponses[keyof GetRequestLogV1RequestLogsLogIdGetResponses];
+export type UpdateRequestLogV1RequestLogsLogIdPatchData = {
+    body: RequestLogUpdate;
+    path: {
+        log_id: string;
     };
+    query?: never;
+    url: '/v1/request-logs/{log_id}';
+};
+export type UpdateRequestLogV1RequestLogsLogIdPatchErrors = {
     /**
-     * This response is sent when a request conflicts with the current state of the server.
+     * Validation Error
      */
-    409: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type UpdateRequestLogV1RequestLogsLogIdPatchError = UpdateRequestLogV1RequestLogsLogIdPatchErrors[keyof UpdateRequestLogV1RequestLogsLogIdPatchErrors];
+export type UpdateRequestLogV1RequestLogsLogIdPatchResponses = {
     /**
-     * The user has sent too many requests in a given amount of time ("rate limiting")
+     * Successful Response
      */
-    429: {
-        status: 'error';
+    200: RequestLogResponse;
+};
+export type UpdateRequestLogV1RequestLogsLogIdPatchResponse = UpdateRequestLogV1RequestLogsLogIdPatchResponses[keyof UpdateRequestLogV1RequestLogsLogIdPatchResponses];
+export type ListTrajectoriesV1TrajectoriesGetData = {
+    body?: never;
+    path?: never;
+    query?: {
         /**
-         * Error message detailing what went wrong
+         * Filter by workflow ID
          */
-        error: string;
+        workflow_id?: string | null;
+        skip?: number;
+        limit?: number;
     };
+    url: '/v1/trajectories';
+};
+export type ListTrajectoriesV1TrajectoriesGetErrors = {
     /**
-     * The server has encountered a situation it does not know how to handle.
+     * Validation Error
      */
-    500: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    422: HttpValidationError;
+};
+export type ListTrajectoriesV1TrajectoriesGetError = ListTrajectoriesV1TrajectoriesGetErrors[keyof ListTrajectoriesV1TrajectoriesGetErrors];
+export type ListTrajectoriesV1TrajectoriesGetResponses = {
     /**
-     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     * Successful Response
      */
-    502: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
-    };
+    200: PaginatedResponseTrajectoryResponse;
 };
-export type PostV1DesktopByIdComputerActionError = PostV1DesktopByIdComputerActionErrors[keyof PostV1DesktopByIdComputerActionErrors];
-export type PostV1DesktopByIdComputerActionResponses = {
+export type ListTrajectoriesV1TrajectoriesGetResponse = ListTrajectoriesV1TrajectoriesGetResponses[keyof ListTrajectoriesV1TrajectoriesGetResponses];
+export type CreateTrajectoryV1TrajectoriesPostData = {
+    body: TrajectoryCreate;
+    path?: never;
+    query?: never;
+    url: '/v1/trajectories';
+};
+export type CreateTrajectoryV1TrajectoriesPostErrors = {
     /**
-     * Action executed successfully. Response may contain output or image data depending on the action.
+     * Validation Error
      */
-    200: {
-        /**
-         * Raw string output from the executed command (if any)
-         */
-        output?: string;
-        /**
-         * Error message if the operation failed (also indicated by non-2xx HTTP status)
-         */
-        error?: string;
-        /**
-         * Base64 encoded JPEG image data (only returned for screenshot actions)
-         */
-        base64_image?: string;
-    };
+    422: HttpValidationError;
 };
-export type PostV1DesktopByIdComputerActionResponse = PostV1DesktopByIdComputerActionResponses[keyof PostV1DesktopByIdComputerActionResponses];
-export type PostV1DesktopByIdBashActionData = {
-    body?: {
-        /**
-         * Bash command to execute
-         */
-        command: string;
+export type CreateTrajectoryV1TrajectoriesPostError = CreateTrajectoryV1TrajectoriesPostErrors[keyof CreateTrajectoryV1TrajectoriesPostErrors];
+export type CreateTrajectoryV1TrajectoriesPostResponses = {
+    /**
+     * Successful Response
+     */
+    201: TrajectoryResponse;
+};
+export type CreateTrajectoryV1TrajectoriesPostResponse = CreateTrajectoryV1TrajectoriesPostResponses[keyof CreateTrajectoryV1TrajectoriesPostResponses];
+export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteData = {
+    body?: never;
+    path: {
+        trajectory_id: string;
     };
-    headers: {
-        /**
-         * API key for authentication
-         */
-        'x-api-key': string;
+    query?: never;
+    url: '/v1/trajectories/{trajectory_id}';
+};
+export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteError = DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteErrors[keyof DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteErrors];
+export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteResponses = {
+    /**
+     * Successful Response
+     */
+    204: void;
+};
+export type DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteResponse = DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteResponses[keyof DeleteTrajectoryV1TrajectoriesTrajectoryIdDeleteResponses];
+export type GetTrajectoryV1TrajectoriesTrajectoryIdGetData = {
+    body?: never;
+    path: {
+        trajectory_id: string;
     };
+    query?: never;
+    url: '/v1/trajectories/{trajectory_id}';
+};
+export type GetTrajectoryV1TrajectoriesTrajectoryIdGetErrors = {
+    /**
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type GetTrajectoryV1TrajectoriesTrajectoryIdGetError = GetTrajectoryV1TrajectoriesTrajectoryIdGetErrors[keyof GetTrajectoryV1TrajectoriesTrajectoryIdGetErrors];
+export type GetTrajectoryV1TrajectoriesTrajectoryIdGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: TrajectoryResponse;
+};
+export type GetTrajectoryV1TrajectoriesTrajectoryIdGetResponse = GetTrajectoryV1TrajectoriesTrajectoryIdGetResponses[keyof GetTrajectoryV1TrajectoriesTrajectoryIdGetResponses];
+export type UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchData = {
+    body: TrajectoryUpdate;
     path: {
-        /**
-         * Desktop instance ID to run the command on
-         */
-        id: string;
+        trajectory_id: string;
     };
     query?: never;
-    url: '/v1/desktop/{id}/bash-action';
+    url: '/v1/trajectories/{trajectory_id}';
 };
-export type PostV1DesktopByIdBashActionErrors = {
+export type UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchErrors = {
     /**
-     * The server cannot or will not process the request due to something that is perceived to be a client error (e.g., malformed request syntax, invalid request message framing, or deceptive request routing).
+     * Validation Error
      */
-    400: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchError = UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchErrors[keyof UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchErrors];
+export type UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchResponses = {
+    /**
+     * Successful Response
+     */
+    200: TrajectoryResponse;
+};
+export type UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchResponse = UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchResponses[keyof UpdateTrajectoryV1TrajectoriesTrajectoryIdPatchResponses];
+export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetData = {
+    body?: never;
+    path: {
+        workflow_id: string;
     };
+    query?: never;
+    url: '/v1/workflows/{workflow_id}/latest-trajectory';
+};
+export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetErrors = {
     /**
-     * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
+     * Validation Error
      */
-    401: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetError = GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetErrors[keyof GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetErrors];
+export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: TrajectoryResponse;
+};
+export type GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetResponse = GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetResponses[keyof GetLatestTrajectoryForWorkflowV1WorkflowsWorkflowIdLatestTrajectoryGetResponses];
+export type GetScreenshotV1ComputerMachineIdDisplayScreenshotGetData = {
+    body?: never;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/computer/{machine_id}/display/screenshot';
+};
+export type GetScreenshotV1ComputerMachineIdDisplayScreenshotGetErrors = {
     /**
-     * The client does not have access rights to the content; that is, it is unauthorized, so the server is refusing to give the requested resource. Unlike 401 Unauthorized, the client's identity is known to the server.
+     * Validation Error
      */
-    403: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type GetScreenshotV1ComputerMachineIdDisplayScreenshotGetError = GetScreenshotV1ComputerMachineIdDisplayScreenshotGetErrors[keyof GetScreenshotV1ComputerMachineIdDisplayScreenshotGetErrors];
+export type GetScreenshotV1ComputerMachineIdDisplayScreenshotGetResponses = {
+    /**
+     * PNG image of the screenshot
+     */
+    200: unknown;
+};
+export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetData = {
+    body?: never;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/computer/{machine_id}/display/dimensions';
+};
+export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetErrors = {
     /**
-     * The server cannot find the requested resource. In the browser, this means the URL is not recognized. In an API, this can also mean that the endpoint is valid but the resource itself does not exist. Servers may also send this response instead of 403 Forbidden to hide the existence of a resource from an unauthorized client. This response code is probably the most well known due to its frequent occurrence on the web.
+     * Validation Error
      */
-    404: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetError = GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetErrors[keyof GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetErrors];
+export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: DisplayDimensions;
+};
+export type GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetResponse = GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetResponses[keyof GetDisplayDimensionsV1ComputerMachineIdDisplayDimensionsGetResponses];
+export type KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostData = {
+    body: KeyboardTypeRequest;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/computer/{machine_id}/input/keyboard/type';
+};
+export type KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostErrors = {
     /**
-     * This response is sent when a request conflicts with the current state of the server.
+     * Validation Error
      */
-    409: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostError = KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostErrors[keyof KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostErrors];
+export type KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostResponses = {
+    /**
+     * Successful Response
+     */
+    204: void;
+};
+export type KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostResponse = KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostResponses[keyof KeyboardTypeV1ComputerMachineIdInputKeyboardTypePostResponses];
+export type KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostData = {
+    body: KeyboardKeyRequest;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/computer/{machine_id}/input/keyboard/key';
+};
+export type KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostErrors = {
     /**
-     * The user has sent too many requests in a given amount of time ("rate limiting")
+     * Validation Error
      */
-    429: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostError = KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostErrors[keyof KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostErrors];
+export type KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostResponses = {
+    /**
+     * Successful Response
+     */
+    204: void;
+};
+export type KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostResponse = KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostResponses[keyof KeyboardKeyV1ComputerMachineIdInputKeyboardKeyPostResponses];
+export type GetMousePositionV1ComputerMachineIdInputMousePositionGetData = {
+    body?: never;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/computer/{machine_id}/input/mouse/position';
+};
+export type GetMousePositionV1ComputerMachineIdInputMousePositionGetErrors = {
     /**
-     * The server has encountered a situation it does not know how to handle.
+     * Validation Error
      */
-    500: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type GetMousePositionV1ComputerMachineIdInputMousePositionGetError = GetMousePositionV1ComputerMachineIdInputMousePositionGetErrors[keyof GetMousePositionV1ComputerMachineIdInputMousePositionGetErrors];
+export type GetMousePositionV1ComputerMachineIdInputMousePositionGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: MousePosition;
+};
+export type GetMousePositionV1ComputerMachineIdInputMousePositionGetResponse = GetMousePositionV1ComputerMachineIdInputMousePositionGetResponses[keyof GetMousePositionV1ComputerMachineIdInputMousePositionGetResponses];
+export type MouseMoveV1ComputerMachineIdInputMouseMovePostData = {
+    body: MouseMoveRequest;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/computer/{machine_id}/input/mouse/move';
+};
+export type MouseMoveV1ComputerMachineIdInputMouseMovePostErrors = {
     /**
-     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     * Validation Error
      */
-    502: {
-        status: 'error';
-        /**
-         * Error message detailing what went wrong
-         */
-        error: string;
+    422: HttpValidationError;
+};
+export type MouseMoveV1ComputerMachineIdInputMouseMovePostError = MouseMoveV1ComputerMachineIdInputMouseMovePostErrors[keyof MouseMoveV1ComputerMachineIdInputMouseMovePostErrors];
+export type MouseMoveV1ComputerMachineIdInputMouseMovePostResponses = {
+    /**
+     * Successful Response
+     */
+    204: void;
+};
+export type MouseMoveV1ComputerMachineIdInputMouseMovePostResponse = MouseMoveV1ComputerMachineIdInputMouseMovePostResponses[keyof MouseMoveV1ComputerMachineIdInputMouseMovePostResponses];
+export type MouseClickV1ComputerMachineIdInputMouseClickPostData = {
+    body: MouseClickRequest;
+    path: {
+        machine_id: string;
     };
+    query?: never;
+    url: '/v1/computer/{machine_id}/input/mouse/click';
 };
-export type PostV1DesktopByIdBashActionError = PostV1DesktopByIdBashActionErrors[keyof PostV1DesktopByIdBashActionErrors];
-export type PostV1DesktopByIdBashActionResponses = {
+export type MouseClickV1ComputerMachineIdInputMouseClickPostErrors = {
     /**
-     * Command executed successfully. Response contains command output.
+     * Validation Error
+     */
+    422: HttpValidationError;
+};
+export type MouseClickV1ComputerMachineIdInputMouseClickPostError = MouseClickV1ComputerMachineIdInputMouseClickPostErrors[keyof MouseClickV1ComputerMachineIdInputMouseClickPostErrors];
+export type MouseClickV1ComputerMachineIdInputMouseClickPostResponses = {
+    /**
+     * Successful Response
+     */
+    204: void;
+};
+export type MouseClickV1ComputerMachineIdInputMouseClickPostResponse = MouseClickV1ComputerMachineIdInputMouseClickPostResponses[keyof MouseClickV1ComputerMachineIdInputMouseClickPostResponses];
+export type DummyTestEndpointV1TestPostData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/test';
+};
+export type DummyTestEndpointV1TestPostResponses = {
+    /**
+     * Successful Response
      */
     200: {
-        /**
-         * Raw string output from the executed command (if any)
-         */
-        output?: string;
-        /**
-         * Error message if the operation failed (also indicated by non-2xx HTTP status)
-         */
-        error?: string;
-        /**
-         * Base64 encoded JPEG image data (only returned for screenshot actions)
-         */
-        base64_image?: string;
+        [key: string]: unknown;
     };
 };
-export type PostV1DesktopByIdBashActionResponse = PostV1DesktopByIdBashActionResponses[keyof PostV1DesktopByIdBashActionResponses];
+export type DummyTestEndpointV1TestPostResponse = DummyTestEndpointV1TestPostResponses[keyof DummyTestEndpointV1TestPostResponses];
+export type RootGetData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/';
+};
+export type RootGetResponses = {
+    /**
+     * Successful Response
+     */
+    200: unknown;
+};
 export type ClientOptions = {
-    baseUrl: 'https://api.cyberdesk.io' | (string & {});
+    baseUrl: `${string}://${string}` | (string & {});
 };