@archildata/api-types 0.0.3 → 0.0.4

package/index.d.ts

@@ -4,6 +4,26 @@
  */
 
 export interface paths {
+    "/api/activity": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List activity events
+         * @description Returns the authenticated account's activity events (disk lifecycle and exec events), newest first. Omitting `limit` returns up to 50 events; pass the response's `nextCursor` back as `cursor` to fetch the next page.
+         */
+        get: operations["listActivity"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/disks": {
         parameters: {
             query?: never;
@@ -124,6 +144,46 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/disks/{id}/delegations": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List delegations
+         * @description Lists all delegations currently held on a disk. A delegation grants a client exclusive write access to an inode and is identified by the (clientId, inodeId) pair. Orphaned entries are held by clients that disconnected without checking their delegations in. Paths are resolved best-effort and may be omitted.
+         */
+        get: operations["listDelegations"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/disks/{id}/revoke-delegation": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Revoke a delegation
+         * @description Forcibly revokes the delegation a client holds on an inode. Use this to reclaim write access from a client that is unreachable or crashed without checking its delegations in.
+         */
+        post: operations["revokeDelegation"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/disks/{id}/exec": {
         parameters: {
             query?: never;
@@ -260,6 +320,159 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/sandboxes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List sandboxes
+         * @description All the account's sandboxes, oldest first.
+         */
+        get: operations["listSandboxes"];
+        put?: never;
+        /**
+         * Create a sandbox
+         * @description Provisions a sandbox VM with the requested shape and Archil disks
+         *     mounted. By default the response reports `pending` after the runtime
+         *     accepts the start. Set `wait=true` to hold for `running`; if the wait
+         *     budget expires, the response remains `pending` and startup continues.
+         */
+        post: operations["createSandbox"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sandboxes/{sid}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a sandbox */
+        get: operations["getSandbox"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sandboxes/{sid}/execs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List recent execs
+         * @description The sandbox's most recent execs, newest first.
+         */
+        get: operations["listSandboxExecs"];
+        put?: never;
+        /**
+         * Run a command in a sandbox
+         * @description Submits a shell command to a running sandbox. By default the response
+         *     reports `running` after the runtime accepts it. Set `wait=true` to hold
+         *     for a terminal result; if the wait budget expires, the response remains
+         *     `running` and the result is available from getSandboxExec. Only
+         *     `running` sandboxes accept execs (409 otherwise).
+         */
+        post: operations["execInSandbox"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sandboxes/{sid}/execs/{eid}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get an exec's status and result */
+        get: operations["getSandboxExec"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sandboxes/{sid}/execs/{eid}/cancel": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Cancel a running exec
+         * @description Aborts a running exec. Idempotent; cancelling an exec that already
+         *     finished returns its terminal result unchanged.
+         */
+        post: operations["cancelSandboxExec"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sandboxes/{sid}/start": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Start or restart a sandbox
+         * @description Cold-boots the sandbox from its persisted configuration and disks. RAM
+         *     and process state are not restored. Starting a pending or running
+         *     sandbox is idempotent; a sandbox that is still stopping returns 409.
+         */
+        post: operations["startSandbox"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/sandboxes/{sid}/stop": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Stop a sandbox
+         * @description Shuts down the sandbox VM without taking a memory snapshot. The sandbox
+         *     identity, configuration, and disks remain available for a later start.
+         */
+        post: operations["stopSandbox"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -270,6 +483,37 @@ export interface components {
             /** @example Invalid request parameters */
             error: string;
         };
+        ActivityEvent: {
+            accountId: string;
+            /**
+             * Format: uuid
+             * @description Unique, time-ordered event id.
+             */
+            eventId: string;
+            /** @example dsk-0123456789abcdef */
+            diskId: string;
+            /** @example disk.created */
+            eventType: string;
+            /**
+             * @description Event severity.
+             * @example error
+             * @enum {string}
+             */
+            level: "info" | "warning" | "error";
+            /** Format: date-time */
+            createdAt: string;
+            /** @description Event-specific attributes (e.g. diskName on disk.created; containerId, outcome, exitCode, failureClass on disk.exec). */
+            details: {
+                [key: string]: string;
+            };
+        };
+        ApiResponse_ActivityList: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["ActivityEvent"][];
+            /** @description Set when more events remain beyond this page. Pass it back as the `cursor` query parameter to fetch the next page. Absent on the last page. */
+            nextCursor?: string;
+        };
         ApiResponse_Empty: {
             /** @example true */
             success: boolean;
@@ -281,6 +525,124 @@ export interface components {
                 message?: string;
             };
         };
+        /** @enum {string} */
+        SandboxState: "pending" | "running" | "stopping" | "stopped" | "exited" | "failed";
+        Sandbox: {
+            /** Format: uuid */
+            sandbox_id: string;
+            status: components["schemas"]["SandboxState"];
+            vcpu_count: number;
+            mem_size_mib: number;
+            /** @description Full lifetime budget applied independently to each powered-on session. */
+            max_ttl_seconds: number;
+            max_concurrent_execs: number;
+            port_mappings?: components["schemas"]["SandboxPortMapping"][];
+            /** Format: date-time */
+            created_at: string;
+            /** Format: date-time */
+            running_at?: string;
+            /** Format: date-time */
+            finished_at?: string;
+            /** Format: date-time */
+            last_active_at: string;
+            /**
+             * Format: date-time
+             * @description Current powered-on session deadline; absent while inactive.
+             */
+            expires_at?: string;
+            exit_reason?: string;
+        };
+        SandboxPortMapping: {
+            container_port: number;
+            /** @enum {string} */
+            protocol: "tcp" | "udp";
+        };
+        ApiResponse_Sandbox: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["Sandbox"];
+        };
+        /** @enum {string} */
+        SandboxExecState: "running" | "completed" | "failed" | "cancelled" | "timed_out";
+        SandboxExec: {
+            /** Format: uuid */
+            sandbox_id: string;
+            /** Format: uuid */
+            exec_id: string;
+            command: string;
+            status: components["schemas"]["SandboxExecState"];
+            exit_code?: number;
+            stdout?: string;
+            stderr?: string;
+            exit_reason?: string;
+            /** Format: int64 */
+            execute_time_ms?: number;
+            /** Format: date-time */
+            started_at: string;
+            /** Format: date-time */
+            finished_at?: string;
+        };
+        SandboxMount: {
+            disk_id: string;
+            /** @description Mount point relative to the sandbox's archil root. May be omitted when the sandbox mounts a single disk. */
+            relative_path?: string;
+            /** @description Expose this subdirectory of the disk instead of its root */
+            subdirectory?: string;
+            /** @description Writes against the mountpoint fail with EROFS */
+            read_only?: boolean;
+            /** @description Mount in shared mode, allowing concurrent writers on other clients. Defaults to true. */
+            shared?: boolean;
+            region?: string;
+        };
+        CreateSandboxRequest: {
+            vcpu_count?: number;
+            mem_size_mib?: number;
+            kernel?: string;
+            base_image?: string;
+            archil_mounts?: components["schemas"]["SandboxMount"][];
+            port_mappings?: components["schemas"]["SandboxPortMapping"][];
+            /** @description Environment variables applied to every exec */
+            env?: {
+                [key: string]: string;
+            };
+            /** @description Lifetime budget applied independently to each powered-on session */
+            max_ttl_seconds?: number;
+            max_concurrent_execs?: number;
+        };
+        SandboxExecRequest: {
+            /** @description Shell command, run via `/bin/sh -c` */
+            command: string;
+            /** @description Allocate a TTY for the command */
+            command_tty?: boolean;
+            /** @description Extra environment variables for this command */
+            env?: {
+                [key: string]: string;
+            };
+            /**
+             * Format: int64
+             * @description Server-side execution deadline; the exec reports timed_out past it
+             */
+            timeout_seconds?: number;
+        };
+        ApiResponse_SandboxList: {
+            /** @example true */
+            success: boolean;
+            data: {
+                sandboxes?: components["schemas"]["Sandbox"][];
+            };
+        };
+        ApiResponse_SandboxExec: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["SandboxExec"];
+        };
+        ApiResponse_SandboxExecList: {
+            /** @example true */
+            success: boolean;
+            data: {
+                execs?: components["schemas"]["SandboxExec"][];
+            };
+        };
         CreateDiskRequest: {
             /**
              * @description Disk name (alphanumeric, dashes, underscores)
@@ -514,6 +876,8 @@ export interface components {
             expiresAt?: string;
             /** @description When true, the token can only be used for a single mount authentication. After the first successful mount, subsequent attempts are rejected. Consumed tokens remain visible in the disk's authorized users list. */
             oneUse?: boolean;
+            /** @description When true, the token grants read-only access. Mounts authenticated with this token reject writes with EROFS. */
+            readOnly?: boolean;
         };
         AwsStsUser: {
             /**
@@ -532,6 +896,8 @@ export interface components {
             expiresAt?: string;
             /** @description When true, the credential can only be used for a single mount authentication. */
             oneUse?: boolean;
+            /** @description When true, the credential grants read-only access. Mounts authenticated with this credential reject writes with EROFS. */
+            readOnly?: boolean;
         };
         DiskUser: components["schemas"]["TokenUser"] | components["schemas"]["AwsStsUser"];
         DiskResponse: {
@@ -682,6 +1048,8 @@ export interface components {
              * @description When the one-use token was consumed (first successful mount auth). Absent if the token has not been consumed or is not one-use.
              */
             consumedAt?: string;
+            /** @description Whether this token grants read-only access. */
+            readOnly?: boolean;
             /**
              * @description Current lifecycle status of the token.
              * @enum {string}
@@ -693,6 +1061,8 @@ export interface components {
             /** @example true */
             success: boolean;
             data: components["schemas"]["DiskResponse"][];
+            /** @description Set when more disks remain beyond this page. Pass it back as the `cursor` query parameter to fetch the next page. Absent on the last page. */
+            nextCursor?: string;
         };
         ApiResponse_Disk: {
             /** @example true */
@@ -726,6 +1096,46 @@ export interface components {
                 allowedIps: string[];
             };
         };
+        DelegationEntry: {
+            /**
+             * @description ID of the client holding the delegation.
+             * @example 12345
+             */
+            clientId: string;
+            /**
+             * Format: int64
+             * @description Inode the delegation covers.
+             */
+            inodeId: number;
+            /**
+             * @description Absolute path of the inode, resolved best-effort. Omitted when the server could not resolve it.
+             * @example workspace/data.db
+             */
+            path?: string;
+            /** @description True while the delegation checkout is still in flight. */
+            isPending: boolean;
+            /** @description True when the holding client is no longer connected to the disk. */
+            isOrphaned: boolean;
+        };
+        ApiResponse_Delegations: {
+            /** @example true */
+            success: boolean;
+            data: {
+                delegations: components["schemas"]["DelegationEntry"][];
+            };
+        };
+        RevokeDelegationRequest: {
+            /**
+             * Format: int64
+             * @description Inode the delegation covers.
+             */
+            inodeId: number;
+            /**
+             * @description ID of the client holding the delegation.
+             * @example 12345
+             */
+            clientId: string;
+        };
         CreateApiTokenRequest: {
             /** @description Token name */
             name: string;
@@ -1034,7 +1444,13 @@ export interface components {
     parameters: {
         /** @description Disk ID (format `dsk-{16 hex chars}`) */
         DiskId: string;
-        /** @description Maximum number of items to return */
+        /** @description Sandbox UUID */
+        SandboxId: string;
+        /** @description Exec UUID */
+        ExecId: string;
+        /** @description Hold the request for a completed start or exec result */
+        Wait: boolean;
+        /** @description Maximum number of items to return. Omit to return all items in a single unpaginated response; when set, the response may include a nextCursor to fetch the next page. */
         Limit: number;
         /** @description Pagination cursor from a previous response */
         Cursor: string;
@@ -1045,10 +1461,45 @@ export interface components {
 }
 export type $defs = Record<string, never>;
 export interface operations {
+    listActivity: {
+        parameters: {
+            query?: {
+                /** @description Maximum events to return per page (default 50). */
+                limit?: number;
+                /** @description Pagination cursor from a previous response */
+                cursor?: components["parameters"]["Cursor"];
+                /** @description Restrict to a single disk owned by the account. */
+                diskId?: string;
+                /** @description Restrict to the given event types (`disk.created`, `disk.deleted`, `disk.user_added`, `disk.user_removed`, `disk.exec`). Repeat the parameter to select multiple types. */
+                eventType?: string[];
+                /** @description Restrict to the given severity levels. Repeat the parameter to select multiple levels. */
+                level?: ("info" | "warning" | "error")[];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Page of activity events */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_ActivityList"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
     listDisks: {
         parameters: {
             query?: {
-                /** @description Maximum number of items to return */
+                /** @description Maximum number of items to return. Omit to return all items in a single unpaginated response; when set, the response may include a nextCursor to fetch the next page. */
                 limit?: components["parameters"]["Limit"];
                 /** @description Pagination cursor from a previous response */
                 cursor?: components["parameters"]["Cursor"];
@@ -1314,7 +1765,64 @@ export interface operations {
             500: components["responses"]["InternalError"];
         };
     };
-    execDisk: {
+    listDelegations: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Delegations currently held on the disk */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Delegations"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    revokeDelegation: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RevokeDelegationRequest"];
+            };
+        };
+        responses: {
+            /** @description Delegation revoked */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Message"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    execDisk: {
         parameters: {
             query?: never;
             header?: never;
@@ -1425,7 +1933,7 @@ export interface operations {
     listApiTokens: {
         parameters: {
             query?: {
-                /** @description Maximum number of items to return */
+                /** @description Maximum number of items to return. Omit to return all items in a single unpaginated response; when set, the response may include a nextCursor to fetch the next page. */
                 limit?: components["parameters"]["Limit"];
                 /** @description Pagination cursor from a previous response */
                 cursor?: components["parameters"]["Cursor"];
@@ -1502,4 +2010,313 @@ export interface operations {
             500: components["responses"]["InternalError"];
         };
     };
+    listSandboxes: {
+        parameters: {
+            query?: {
+                /** @description Only sandboxes that mount this disk */
+                filesystem?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Sandboxes for the account */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_SandboxList"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    createSandbox: {
+        parameters: {
+            query?: {
+                /** @description Hold the request for a completed start or exec result */
+                wait?: components["parameters"]["Wait"];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateSandboxRequest"];
+            };
+        };
+        responses: {
+            /** @description The sandbox was created */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Sandbox"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            /** @description Sandbox capacity reached */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+        };
+    };
+    getSandbox: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The sandbox */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Sandbox"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    listSandboxExecs: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Recent execs */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_SandboxExecList"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    execInSandbox: {
+        parameters: {
+            query?: {
+                /** @description Hold the request for a completed start or exec result */
+                wait?: components["parameters"]["Wait"];
+            };
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["SandboxExecRequest"];
+            };
+        };
+        responses: {
+            /** @description The exec, terminal (result fields set) or still running */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_SandboxExec"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            /** @description The sandbox is not running */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description The sandbox's max_concurrent_execs cap is reached */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+        };
+    };
+    getSandboxExec: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+                /** @description Exec UUID */
+                eid: components["parameters"]["ExecId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The exec; result fields are set once terminal */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_SandboxExec"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    cancelSandboxExec: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+                /** @description Exec UUID */
+                eid: components["parameters"]["ExecId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The exec after the cancel */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_SandboxExec"];
+                };
+            };
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
+    startSandbox: {
+        parameters: {
+            query?: {
+                /** @description Hold the request for a completed start or exec result */
+                wait?: components["parameters"]["Wait"];
+            };
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The sandbox was already running */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Sandbox"];
+                };
+            };
+            /** @description The sandbox start is pending */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Sandbox"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            /** @description The previous VM is still stopping */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+        };
+    };
+    stopSandbox: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Sandbox UUID */
+                sid: components["parameters"]["SandboxId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The sandbox was already inactive */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Sandbox"];
+                };
+            };
+            /** @description The sandbox stop is in progress */
+            202: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ApiResponse_Sandbox"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            401: components["responses"]["Unauthorized"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalError"];
+        };
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archildata/api-types",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "API types for the Archil control plane",
   "type": "module",
   "types": "index.d.ts",