cyberdesk 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cyberdesk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,91 @@
+# cyberdesk
+
+[![npm version](https://badge.fury.io/js/cyberdesk.svg)](https://badge.fury.io/js/cyberdesk)
+
+The official TypeScript SDK for Cyberdesk.
+
+## Installation
+
+```bash
+npm install cyberdesk
+# or
+yarn add cyberdesk
+# or
+pnpm add cyberdesk
+```
+
+## Usage
+
+First, configure the client, for example, by setting default headers for authentication. You only need to do this once.
+
+```typescript
+import { client, setConfig } from 'cyberdesk/client'; // Import client and setConfig
+
+// Configure the client (e.g., with an API Key)
+// Adjust based on your actual authentication method
+setConfig({
+  headers: {
+    'Authorization': `Bearer YOUR_API_KEY`
+  }
+});
+```
+
+Then, import and call the specific API functions you need:
+
+```typescript
+import {
+  postV1Desktop,
+  postV1DesktopIdComputerAction,
+  type PostV1DesktopData,
+  type PostV1DesktopIdComputerActionData
+} from 'cyberdesk';
+
+async function createAndInteract() {
+  try {
+    // 1. Create a new desktop
+    console.log('Creating desktop...');
+    const createResponse = await postV1Desktop({
+      // Pass request body parameters inside the 'data' object
+      data: {
+         timeoutMs: 10000 
+      }
+      // Headers like Authorization should be set globally via setConfig (see above)
+    });
+
+    if (!createResponse.data) {
+       throw new Error('Failed to create desktop: ' + (createResponse.error?.message || 'Unknown error'));
+    }
+
+    const desktopId = createResponse.data.id; // Assuming the response has an ID
+    console.log(`Desktop created with ID: ${desktopId}`);
+
+    // 2. Perform an action (e.g., a mouse click)
+    console.log(`Performing action on desktop ${desktopId}...`);
+    const actionData: PostV1DesktopIdComputerActionData['data'] = {
+        type: 'click_mouse', // Example action type
+        x: 100,
+        y: 150
+    };
+    
+    const actionResponse = await postV1DesktopIdComputerAction({
+      path: { id: desktopId }, // Provide path parameters
+      data: actionData // Provide request body data
+    });
+
+    if (actionResponse.error) {
+      throw new Error(`Action failed: ${actionResponse.error.message}`);
+    }
+
+    console.log('Action successful:', actionResponse.data);
+
+  } catch (error) {
+    console.error('Error using Cyberdesk SDK:', error);
+  }
+}
+
+createAndInteract();
+```
+
+## License
+
+[MIT](LICENSE) 

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

@@ -20,8 +20,9 @@ export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends
 export declare const getV1DesktopId: <ThrowOnError extends boolean = false>(options: Options<GetV1DesktopIdData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
     id: string;
     status: "pending" | "running" | "terminated" | "error";
-    createdAt: string;
-    timeoutAt: string;
+    stream_url: string;
+    created_at: string;
+    timeout_at: string;
 }, GetV1DesktopIdError, ThrowOnError>;
 /**
  * Create a new virtual desktop instance
@@ -29,37 +30,30 @@ export declare const getV1DesktopId: <ThrowOnError extends boolean = false>(opti
  */
 export declare const postV1Desktop: <ThrowOnError extends boolean = false>(options: Options<PostV1DesktopData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
     id: string;
-    streamUrl: string;
+    status: "pending" | "running" | "terminated" | "error";
 }, PostV1DesktopError, ThrowOnError>;
 /**
  * Stop a running desktop instance
  * Stops a running desktop instance and cleans up resources
  */
 export declare const postV1DesktopIdStop: <ThrowOnError extends boolean = false>(options: Options<PostV1DesktopIdStopData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
-    status: string;
-    image?: string;
-    cursorPosition?: {
-        x?: number;
-        y?: number;
-    };
+    status: "pending" | "running" | "terminated" | "error";
 }, PostV1DesktopIdStopError, ThrowOnError>;
 /**
  * Perform an action on the desktop
  * Executes a computer action such as mouse clicks, keyboard input, or screenshots on the desktop
  */
 export declare const postV1DesktopIdComputerAction: <ThrowOnError extends boolean = false>(options: Options<PostV1DesktopIdComputerActionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
-    status: string;
-    image?: string;
-    cursorPosition?: {
-        x?: number;
-        y?: number;
-    };
+    output?: string;
+    error?: string;
+    base64_image?: string;
 }, PostV1DesktopIdComputerActionError, ThrowOnError>;
 /**
  * Execute a bash command on the desktop
  * Runs a bash command on the desktop and returns the command output
  */
 export declare const postV1DesktopIdBashAction: <ThrowOnError extends boolean = false>(options: Options<PostV1DesktopIdBashActionData, ThrowOnError>) => import("@hey-api/client-fetch").RequestResult<{
-    status: string;
-    output: string;
+    output?: string;
+    error?: string;
+    base64_image?: string;
 }, PostV1DesktopIdBashActionError, ThrowOnError>;

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

@@ -20,50 +20,81 @@ export type GetV1DesktopIdErrors = {
      * 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).
      */
     400: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
      */
     401: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     403: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     404: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * This response is sent when a request conflicts with the current state of the server.
      */
     409: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The user has sent too many requests in a given amount of time ("rate limiting")
      */
     429: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The server has encountered a situation it does not know how to handle.
      */
     500: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
+    };
+    /**
+     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     */
+    502: {
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
 };
 export type GetV1DesktopIdError = GetV1DesktopIdErrors[keyof GetV1DesktopIdErrors];
@@ -80,14 +111,18 @@ export type GetV1DesktopIdResponses = {
          * 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
          */
-        createdAt: string;
+        created_at: string;
         /**
          * Timestamp when the instance will automatically time out
          */
-        timeoutAt: string;
+        timeout_at: string;
     };
 };
 export type GetV1DesktopIdResponse = GetV1DesktopIdResponses[keyof GetV1DesktopIdResponses];
@@ -96,7 +131,7 @@ export type PostV1DesktopData = {
         /**
          * Timeout in milliseconds for the desktop session
          */
-        timeoutMs?: number;
+        timeout_ms?: number;
     };
     headers: {
         /**
@@ -113,56 +148,87 @@ export type PostV1DesktopErrors = {
      * 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).
      */
     400: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
      */
     401: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     403: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     404: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * This response is sent when a request conflicts with the current state of the server.
      */
     409: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The user has sent too many requests in a given amount of time ("rate limiting")
      */
     429: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The server has encountered a situation it does not know how to handle.
      */
     500: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
+    };
+    /**
+     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     */
+    502: {
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
 };
 export type PostV1DesktopError = PostV1DesktopErrors[keyof PostV1DesktopErrors];
 export type PostV1DesktopResponses = {
     /**
-     * Desktop created successfully
+     * Desktop creation initiated successfully
      */
     200: {
         /**
@@ -170,9 +236,9 @@ export type PostV1DesktopResponses = {
          */
         id: string;
         /**
-         * URL to stream the desktop via VNC
+         * Initial status of the desktop instance after creation request
          */
-        streamUrl: string;
+        status: 'pending' | 'running' | 'terminated' | 'error';
     };
 };
 export type PostV1DesktopResponse = PostV1DesktopResponses[keyof PostV1DesktopResponses];
@@ -198,50 +264,81 @@ export type PostV1DesktopIdStopErrors = {
      * 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).
      */
     400: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
      */
     401: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     403: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     404: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * This response is sent when a request conflicts with the current state of the server.
      */
     409: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The user has sent too many requests in a given amount of time ("rate limiting")
      */
     429: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The server has encountered a situation it does not know how to handle.
      */
     500: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
+    };
+    /**
+     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     */
+    502: {
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
 };
 export type PostV1DesktopIdStopError = PostV1DesktopIdStopErrors[keyof PostV1DesktopIdStopErrors];
@@ -251,26 +348,9 @@ export type PostV1DesktopIdStopResponses = {
      */
     200: {
         /**
-         * Status of the operation
+         * Status of the desktop instance after stopping
          */
-        status: string;
-        /**
-         * Base64 encoded image data (only returned for screenshot actions)
-         */
-        image?: string;
-        /**
-         * Current cursor coordinates (only returned for get_cursor_position action)
-         */
-        cursorPosition?: {
-            /**
-             * X coordinate on the screen
-             */
-            x?: number;
-            /**
-             * Y coordinate on the screen
-             */
-            y?: number;
-        };
+        status: 'pending' | 'running' | 'terminated' | 'error';
     };
 };
 export type PostV1DesktopIdStopResponse = PostV1DesktopIdStopResponses[keyof PostV1DesktopIdStopResponses];
@@ -416,79 +496,101 @@ export type PostV1DesktopIdComputerActionErrors = {
      * 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).
      */
     400: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
      */
     401: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     403: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     404: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * This response is sent when a request conflicts with the current state of the server.
      */
     409: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The user has sent too many requests in a given amount of time ("rate limiting")
      */
     429: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The server has encountered a situation it does not know how to handle.
      */
     500: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
+    };
+    /**
+     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     */
+    502: {
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
 };
 export type PostV1DesktopIdComputerActionError = PostV1DesktopIdComputerActionErrors[keyof PostV1DesktopIdComputerActionErrors];
 export type PostV1DesktopIdComputerActionResponses = {
     /**
-     * Action executed successfully
+     * Action executed successfully. Response may contain output or image data depending on the action.
      */
     200: {
         /**
-         * Status of the operation
+         * Raw string output from the executed command (if any)
          */
-        status: string;
+        output?: string;
         /**
-         * Base64 encoded image data (only returned for screenshot actions)
+         * Error message if the operation failed (also indicated by non-2xx HTTP status)
          */
-        image?: string;
+        error?: string;
         /**
-         * Current cursor coordinates (only returned for get_cursor_position action)
+         * Base64 encoded JPEG image data (only returned for screenshot actions)
          */
-        cursorPosition?: {
-            /**
-             * X coordinate on the screen
-             */
-            x?: number;
-            /**
-             * Y coordinate on the screen
-             */
-            y?: number;
-        };
+        base64_image?: string;
     };
 };
 export type PostV1DesktopIdComputerActionResponse = PostV1DesktopIdComputerActionResponses[keyof PostV1DesktopIdComputerActionResponses];
@@ -519,66 +621,101 @@ export type PostV1DesktopIdBashActionErrors = {
      * 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).
      */
     400: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * Although the HTTP standard specifies "unauthorized", semantically this response means "unauthenticated". That is, the client must authenticate itself to get the requested response.
      */
     401: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     403: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * 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.
      */
     404: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * This response is sent when a request conflicts with the current state of the server.
      */
     409: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The user has sent too many requests in a given amount of time ("rate limiting")
      */
     429: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
     /**
      * The server has encountered a situation it does not know how to handle.
      */
     500: {
-        message: string;
-        docs: string;
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
+    };
+    /**
+     * The server, while acting as a gateway or proxy, received an invalid response from the upstream server.
+     */
+    502: {
+        status: 'error';
+        /**
+         * Error message detailing what went wrong
+         */
+        error: string;
     };
 };
 export type PostV1DesktopIdBashActionError = PostV1DesktopIdBashActionErrors[keyof PostV1DesktopIdBashActionErrors];
 export type PostV1DesktopIdBashActionResponses = {
     /**
-     * Command executed successfully
+     * Command executed successfully. Response contains command output.
      */
     200: {
         /**
-         * Status of the bash command execution
+         * Raw string output from the executed command (if any)
+         */
+        output?: string;
+        /**
+         * Error message if the operation failed (also indicated by non-2xx HTTP status)
          */
-        status: string;
+        error?: string;
         /**
-         * Output from the bash command execution
+         * Base64 encoded JPEG image data (only returned for screenshot actions)
          */
-        output: string;
+        base64_image?: string;
     };
 };
 export type PostV1DesktopIdBashActionResponse = PostV1DesktopIdBashActionResponses[keyof PostV1DesktopIdBashActionResponses];

package/dist/index.d.ts

@@ -0,0 +1,34 @@
+import { createClient, type Options as ClientOptions } from '@hey-api/client-fetch';
+import * as apiMethods from './client/sdk.gen';
+export * from './client/types.gen';
+import { type GetV1DesktopIdData, type PostV1DesktopData, type PostV1DesktopIdStopData, type PostV1DesktopIdComputerActionData, type PostV1DesktopIdBashActionData } from './client/types.gen';
+type FetchFn = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/**
+ * Configuration options for the Cyberdesk SDK client.
+ */
+export interface CyberdeskClientOptions {
+    /** Your Cyberdesk API Key */
+    apiKey: string;
+    /** Optional: Override the base URL for the API. Defaults to Cyberdesk production API. */
+    baseUrl?: string;
+    /** Optional: Provide a custom fetch implementation. */
+    fetch?: FetchFn;
+    /** Optional: Provide additional default options for the underlying client (e.g., timeout, keepalive). */
+    clientOptions?: Partial<ClientOptions>;
+}
+export type CyberdeskSdk = {
+    getV1DesktopId: (opts: Omit<GetV1DesktopIdData, 'headers' | 'url'>) => ReturnType<typeof apiMethods.getV1DesktopId>;
+    postV1Desktop: (opts: Omit<PostV1DesktopData, 'headers' | 'url'>) => ReturnType<typeof apiMethods.postV1Desktop>;
+    postV1DesktopIdStop: (opts: Omit<PostV1DesktopIdStopData, 'headers' | 'url'>) => ReturnType<typeof apiMethods.postV1DesktopIdStop>;
+    postV1DesktopIdComputerAction: (opts: Omit<PostV1DesktopIdComputerActionData, 'headers' | 'url'>) => ReturnType<typeof apiMethods.postV1DesktopIdComputerAction>;
+    postV1DesktopIdBashAction: (opts: Omit<PostV1DesktopIdBashActionData, 'headers' | 'url'>) => ReturnType<typeof apiMethods.postV1DesktopIdBashAction>;
+};
+/**
+ * Creates a Cyberdesk SDK instance configured with your API key.
+ *
+ * @param options - Configuration options including the API key.
+ * @returns An SDK instance with methods ready to be called.
+ */
+export declare function createCyberdeskClient(options: CyberdeskClientOptions): CyberdeskSdk;
+export { createClient };
+export * as rawApiMethods from './client/sdk.gen';

package/dist/index.js

@@ -0,0 +1,84 @@
+"use strict";
+/// <reference lib="dom" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rawApiMethods = exports.createClient = void 0;
+exports.createCyberdeskClient = createCyberdeskClient;
+const client_fetch_1 = require("@hey-api/client-fetch");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_fetch_1.createClient; } });
+const apiMethods = __importStar(require("./client/sdk.gen")); // Import the generated methods
+// Re-export all types from types.gen for user convenience
+__exportStar(require("./client/types.gen"), exports);
+const DEFAULT_BASE_URL = 'https://api.cyberdesk.io'; // Replace if needed
+/**
+ * Creates a Cyberdesk SDK instance configured with your API key.
+ *
+ * @param options - Configuration options including the API key.
+ * @returns An SDK instance with methods ready to be called.
+ */
+function createCyberdeskClient(options) {
+    const { apiKey, baseUrl = DEFAULT_BASE_URL, fetch: customFetch, clientOptions = {} } = options;
+    if (!apiKey) {
+        throw new Error('Cyberdesk SDK requires an `apiKey` to be provided.');
+    }
+    // Ensure baseUrl is string | undefined before use
+    const finalBaseUrl = baseUrl;
+    // Prepare headers, merging defaults with any provided in clientOptions
+    const mergedHeaders = Object.assign({ 'x-api-key': apiKey, 'Content-Type': 'application/json' }, (clientOptions.headers || {}));
+    // Construct the final options for createClient explicitly
+    const finalClientOptions = Object.assign({ 
+        // Set base URL
+        baseUrl: finalBaseUrl, 
+        // Set merged headers
+        headers: mergedHeaders }, (customFetch && { fetch: customFetch }));
+    // Pass the inferred options object directly
+    const configuredClient = (0, client_fetch_1.createClient)(finalClientOptions);
+    // Return an object where each method is pre-configured with the client instance
+    return {
+        getV1DesktopId: (opts) => apiMethods.getV1DesktopId(Object.assign(Object.assign({}, opts), { client: configuredClient, 
+            // Merge client headers with potentially provided headers from opts
+            headers: Object.assign(Object.assign({}, mergedHeaders), opts.headers) })),
+        postV1Desktop: (opts) => apiMethods.postV1Desktop(Object.assign(Object.assign({}, opts), { client: configuredClient, headers: Object.assign(Object.assign({}, mergedHeaders), opts.headers) })),
+        postV1DesktopIdStop: (opts) => apiMethods.postV1DesktopIdStop(Object.assign(Object.assign({}, opts), { client: configuredClient, headers: Object.assign(Object.assign({}, mergedHeaders), opts.headers) })),
+        postV1DesktopIdComputerAction: (opts) => apiMethods.postV1DesktopIdComputerAction(Object.assign(Object.assign({}, opts), { client: configuredClient, headers: Object.assign(Object.assign({}, mergedHeaders), opts.headers) })),
+        postV1DesktopIdBashAction: (opts) => apiMethods.postV1DesktopIdBashAction(Object.assign(Object.assign({}, opts), { client: configuredClient, headers: Object.assign(Object.assign({}, mergedHeaders), opts.headers) })),
+        // Add bindings for other generated methods here following the same pattern
+    };
+}
+// Optional: Export the underlying api methods if needed, though usually accessed via the sdk instance
+exports.rawApiMethods = __importStar(require("./client/sdk.gen"));

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "cyberdesk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The official TypeScript SDK for Cyberdesk",
-  "main": "dist/client/index.js",
-  "types": "dist/client/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "LICENSE",