@alibaba-group/opensandbox 0.1.1-dev0 → 0.1.2-dev0

package/dist/internal.d.ts

@@ -1,22 +1,2516 @@
+import { Client } from 'openapi-fetch';
+import { S as Sandboxes, m as CreateSandboxRequest, n as CreateSandboxResponse, d as SandboxId, e as SandboxInfo, u as ListSandboxesParams, L as ListSandboxesResponse, y as RenewSandboxExpirationRequest, R as RenewSandboxExpirationResponse, j as Endpoint, b as ExecdHealth, c as ExecdMetrics, i as SandboxMetrics, a as SandboxFiles, F as FileInfo, W as WriteEntry, H as SetPermissionEntry, v as MoveEntry, l as ContentReplaceEntry, D as SearchEntry, G as SearchFilesResponse, E as ExecdCommands, A as RunCommandOpts, h as ServerStreamEvent, g as ExecutionHandlers, k as CommandExecution } from './sandboxes-HBCO9ttf.js';
+
 /**
- * INTERNAL / ADVANCED ENTRYPOINT
- *
- * This subpath exposes low-level OpenAPI clients and adapters for advanced integrations.
- * It is intentionally NOT exported from the root entrypoint (`@alibaba-group/opensandbox`),
- * because generated OpenAPI types are not considered stable public API.
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+interface paths$1 {
+    "/sandboxes": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List sandboxes
+         * @description List all sandboxes with optional filtering and pagination using query parameters.
+         *     All filter conditions use AND logic. Multiple `state` parameters use OR logic within states.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /**
+                     * @description Filter by lifecycle state. Pass multiple times for OR logic.
+                     *     Example: `?state=Running&state=Paused`
+                     */
+                    state?: string[];
+                    /**
+                     * @description Arbitrary metadata key-value pairs for filtering，keys and values must be url encoded
+                     *     Example: To filter by `project=Apollo` and `note=Demo Test`: `?metadata=project%3DApollo%26note%3DDemo%252520Test`
+                     */
+                    metadata?: string;
+                    /** @description Page number for pagination */
+                    page?: number;
+                    /** @description Number of items per page */
+                    pageSize?: number;
+                };
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Paginated collection of sandboxes */
+                200: {
+                    headers: {
+                        "X-Request-ID": components$1["headers"]["XRequestId"];
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components$1["schemas"]["ListSandboxesResponse"];
+                    };
+                };
+                400: components$1["responses"]["BadRequest"];
+                401: components$1["responses"]["Unauthorized"];
+                500: components$1["responses"]["InternalServerError"];
+            };
+        };
+        put?: never;
+        /**
+         * Create a sandbox from a container image
+         * @description Creates a new sandbox from a container image with optional resource limits,
+         *     environment variables, and metadata. Sandboxes are provisioned directly from
+         *     the specified image without requiring a pre-created template.
+         *
+         *     ## Authentication
+         *
+         *     API Key authentication is required via:
+         *     - `OPEN-SANDBOX-API-KEY: <api-key>` header
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components$1["schemas"]["CreateSandboxRequest"];
+                };
+            };
+            responses: {
+                /**
+                 * @description Sandbox created and accepted for provisioning.
+                 *
+                 *     The returned sandbox includes:
+                 *     - `id`: Unique sandbox identifier
+                 *     - `status.state: "Pending"` (auto-starting provisioning)
+                 *     - `status.reason` and `status.message` indicating initialization stage
+                 *     - `metadata`, `expiresAt`, `createdAt`: Core sandbox information
+                 *
+                 *     Note: `image` and `updatedAt` are not included in the create response.
+                 *     Use GET /sandboxes/{sandboxId} to retrieve the complete sandbox information including image spec.
+                 *
+                 *     To track provisioning progress, poll GET /sandboxes/{sandboxId}.
+                 *     The sandbox will automatically transition to `Running` state once provisioning completes.
+                 */
+                202: {
+                    headers: {
+                        "X-Request-ID": components$1["headers"]["XRequestId"];
+                        Location: components$1["headers"]["Location"];
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components$1["schemas"]["CreateSandboxResponse"];
+                    };
+                };
+                400: components$1["responses"]["BadRequest"];
+                401: components$1["responses"]["Unauthorized"];
+                409: components$1["responses"]["Conflict"];
+                500: components$1["responses"]["InternalServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sandboxes/{sandboxId}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Unique sandbox identifier */
+                sandboxId: components$1["parameters"]["SandboxId"];
+            };
+            cookie?: never;
+        };
+        /**
+         * Fetch a sandbox by id
+         * @description Returns the complete sandbox information including:
+         *     - `id`, `status`, `metadata`, `expiresAt`, `createdAt`: Core information
+         *     - `image`: Container image specification (not included in create response)
+         *     - `entrypoint`: Entry process specification
+         *
+         *     This is the complete representation of the sandbox resource.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Unique sandbox identifier */
+                    sandboxId: components$1["parameters"]["SandboxId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Sandbox current state and metadata */
+                200: {
+                    headers: {
+                        "X-Request-ID": components$1["headers"]["XRequestId"];
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components$1["schemas"]["Sandbox"];
+                    };
+                };
+                401: components$1["responses"]["Unauthorized"];
+                403: components$1["responses"]["Forbidden"];
+                404: components$1["responses"]["NotFound"];
+                500: components$1["responses"]["InternalServerError"];
+            };
+        };
+        put?: never;
+        post?: never;
+        /**
+         * Delete a sandbox
+         * @description Delete a sandbox, terminating its execution. The sandbox will transition through Stopping state to Terminated.
+         */
+        delete: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Unique sandbox identifier */
+                    sandboxId: components$1["parameters"]["SandboxId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /**
+                 * @description Sandbox successfully deleted.
+                 *
+                 *     Sandbox has been scheduled for termination and will transition to Stopping state, then Terminated.
+                 */
+                204: {
+                    headers: {
+                        "X-Request-ID": components$1["headers"]["XRequestId"];
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: components$1["responses"]["Unauthorized"];
+                403: components$1["responses"]["Forbidden"];
+                404: components$1["responses"]["NotFound"];
+                409: components$1["responses"]["Conflict"];
+                500: components$1["responses"]["InternalServerError"];
+            };
+        };
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sandboxes/{sandboxId}/pause": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Pause execution while retaining state
+         * @description Pause a running sandbox while preserving its state. Poll GET /sandboxes/{sandboxId} to track state transition to Paused.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Unique sandbox identifier */
+                    sandboxId: components$1["parameters"]["SandboxId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /**
+                 * @description Pause operation accepted.
+                 *
+                 *     Sandbox will transition to Pausing state.
+                 *     Poll GET /sandboxes/{sandboxId} to track progress.
+                 */
+                202: {
+                    headers: {
+                        "X-Request-ID": components$1["headers"]["XRequestId"];
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: components$1["responses"]["Unauthorized"];
+                403: components$1["responses"]["Forbidden"];
+                404: components$1["responses"]["NotFound"];
+                409: components$1["responses"]["Conflict"];
+                500: components$1["responses"]["InternalServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sandboxes/{sandboxId}/resume": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Resume a paused sandbox
+         * @description Resume execution of a paused sandbox. Poll GET /sandboxes/{sandboxId} to track state transition to Running.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Unique sandbox identifier */
+                    sandboxId: components$1["parameters"]["SandboxId"];
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /**
+                 * @description Resume operation accepted.
+                 *
+                 *     Sandbox will transition from Paused → Running.
+                 *     Poll GET /sandboxes/{sandboxId} to track progress.
+                 */
+                202: {
+                    headers: {
+                        "X-Request-ID": components$1["headers"]["XRequestId"];
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                401: components$1["responses"]["Unauthorized"];
+                403: components$1["responses"]["Forbidden"];
+                404: components$1["responses"]["NotFound"];
+                409: components$1["responses"]["Conflict"];
+                500: components$1["responses"]["InternalServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sandboxes/{sandboxId}/renew-expiration": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Renew sandbox expiration
+         * @description Renew the absolute expiration time of a sandbox.
+         */
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Unique sandbox identifier */
+                    sandboxId: components$1["parameters"]["SandboxId"];
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components$1["schemas"]["RenewSandboxExpirationRequest"];
+                };
+            };
+            responses: {
+                /**
+                 * @description Sandbox expiration updated successfully.
+                 *
+                 *     Returns only the updated expiresAt field.
+                 */
+                200: {
+                    headers: {
+                        "X-Request-ID": components$1["headers"]["XRequestId"];
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components$1["schemas"]["RenewSandboxExpirationResponse"];
+                    };
+                };
+                400: components$1["responses"]["BadRequest"];
+                401: components$1["responses"]["Unauthorized"];
+                403: components$1["responses"]["Forbidden"];
+                404: components$1["responses"]["NotFound"];
+                409: components$1["responses"]["Conflict"];
+                500: components$1["responses"]["InternalServerError"];
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/sandboxes/{sandboxId}/endpoints/{port}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get sandbox access endpoint
+         * @description Get the public access endpoint URL for accessing a service running on a specific port
+         *     within the sandbox. The service must be listening on the specified port inside
+         *     the sandbox for the endpoint to be available.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Unique sandbox identifier */
+                    sandboxId: components$1["parameters"]["SandboxId"];
+                    /** @description Port number where the service is listening inside the sandbox */
+                    port: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /**
+                 * @description Endpoint retrieved successfully.
+                 *
+                 *     Returns the public URL for accessing the service on the specified port.
+                 */
+                200: {
+                    headers: {
+                        "X-Request-ID": components$1["headers"]["XRequestId"];
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components$1["schemas"]["Endpoint"];
+                    };
+                };
+                401: components$1["responses"]["Unauthorized"];
+                403: components$1["responses"]["Forbidden"];
+                404: components$1["responses"]["NotFound"];
+                500: components$1["responses"]["InternalServerError"];
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components$1 {
+    schemas: {
+        ListSandboxesResponse: {
+            items: components$1["schemas"]["Sandbox"][];
+            pagination: components$1["schemas"]["PaginationInfo"];
+        };
+        /** @description Pagination metadata for list responses */
+        PaginationInfo: {
+            /** @description Current page number */
+            page: number;
+            /** @description Number of items per page */
+            pageSize: number;
+            /** @description Total number of items matching the filter */
+            totalItems: number;
+            /** @description Total number of pages */
+            totalPages: number;
+            /** @description Whether there are more pages after the current one */
+            hasNextPage: boolean;
+        };
+        /** @description Response from creating a new sandbox. Contains essential information without image and updatedAt. */
+        CreateSandboxResponse: {
+            /** @description Unique sandbox identifier */
+            id: string;
+            /** @description Current lifecycle status and detailed state information */
+            status: components$1["schemas"]["SandboxStatus"];
+            /** @description Custom metadata from creation request */
+            metadata?: {
+                [key: string]: string;
+            };
+            /**
+             * Format: date-time
+             * @description Timestamp when sandbox will auto-terminate
+             */
+            expiresAt: string;
+            /**
+             * Format: date-time
+             * @description Sandbox creation timestamp
+             */
+            createdAt: string;
+            /** @description Entry process specification from creation request */
+            entrypoint: string[];
+        };
+        /** @description Runtime execution environment provisioned from a container image */
+        Sandbox: {
+            /** @description Unique sandbox identifier */
+            id: string;
+            /**
+             * @description Container image specification used to provision this sandbox.
+             *     Only present in responses for GET/LIST operations. Not returned in createSandbox response.
+             */
+            image: components$1["schemas"]["ImageSpec"];
+            /** @description Current lifecycle status and detailed state information */
+            status: components$1["schemas"]["SandboxStatus"];
+            /** @description Custom metadata from creation request */
+            metadata?: {
+                [key: string]: string;
+            };
+            /**
+             * @description The command to execute as the sandbox's entry process.
+             *     Always present in responses since entrypoint is required in creation requests.
+             */
+            entrypoint: string[];
+            /**
+             * Format: date-time
+             * @description Timestamp when sandbox will auto-terminate
+             */
+            expiresAt: string;
+            /**
+             * Format: date-time
+             * @description Sandbox creation timestamp
+             */
+            createdAt: string;
+        };
+        /**
+         * @description High-level lifecycle state of the sandbox.
+         *
+         *     Common state values:
+         *     - Pending: Sandbox is being provisioned
+         *     - Running: Sandbox is running and ready to accept requests
+         *     - Pausing: Sandbox is in the process of pausing
+         *     - Paused: Sandbox has been paused while retaining its state
+         *     - Stopping: Sandbox is being terminated
+         *     - Terminated: Sandbox has been successfully terminated
+         *     - Failed: Sandbox encountered a critical error
+         *
+         *     State transitions:
+         *     - Pending → Running (after creation completes)
+         *     - Running → Pausing (when pause is requested)
+         *     - Pausing → Paused (pause operation completes)
+         *     - Paused → Running (when resume is requested)
+         *     - Running/Paused → Stopping (when kill is requested or TTL expires)
+         *     - Stopping → Terminated (kill/timeout operation completes)
+         *     - Pending/Running/Paused → Failed (on error)
+         *
+         *     Note: New state values may be added in future versions.
+         *     Clients should handle unknown state values gracefully.
+         */
+        SandboxState: string;
+        /** @description Detailed status information with lifecycle state and transition details */
+        SandboxStatus: {
+            /** @description Current lifecycle state of the sandbox */
+            state: components$1["schemas"]["SandboxState"];
+            /**
+             * @description Short machine-readable reason code for the current state.
+             *     Examples: "user_delete", "ttl_expiry", "provision_timeout", "runtime_error"
+             */
+            reason?: string;
+            /** @description Human-readable message describing the current state or reason for state transition */
+            message?: string;
+            /**
+             * Format: date-time
+             * @description Timestamp of the last state transition
+             */
+            lastTransitionAt?: string;
+        };
+        /**
+         * @description Container image specification for sandbox provisioning.
+         *
+         *     Supports public registry images and private registry images with authentication.
+         */
+        ImageSpec: {
+            /**
+             * @description Container image URI in standard format.
+             *
+             *     Examples:
+             *       - "python:3.11" (Docker Hub)
+             *       - "ubuntu:22.04"
+             *       - "gcr.io/my-project/model-server:v1.0"
+             *       - "private-registry.company.com:5000/app:latest"
+             */
+            uri: string;
+            /** @description Registry authentication credentials (required for private registries) */
+            auth?: {
+                /** @description Registry username or service account */
+                username?: string;
+                /** @description Registry password or authentication token */
+                password?: string;
+            };
+        };
+        /**
+         * @description Request to create a new sandbox from a container image.
+         *
+         *     **Note**: API Key authentication is required via the `OPEN-SANDBOX-API-KEY` header.
+         */
+        CreateSandboxRequest: {
+            /** @description Container image specification for the sandbox */
+            image: components$1["schemas"]["ImageSpec"];
+            /**
+             * @description Sandbox timeout in seconds. The sandbox will automatically terminate after this duration.
+             *     SDK clients should provide a default value (e.g., 3600 seconds / 1 hour).
+             */
+            timeout: number;
+            /**
+             * @description Runtime resource constraints for the sandbox instance.
+             *     SDK clients should provide sensible defaults (e.g., cpu: "500m", memory: "512Mi").
+             */
+            resourceLimits: components$1["schemas"]["ResourceLimits"];
+            /**
+             * @description Environment variables to inject into the sandbox runtime.
+             * @example {
+             *       "API_KEY": "secret-key",
+             *       "DEBUG": "true",
+             *       "LOG_LEVEL": "info"
+             *     }
+             */
+            env?: {
+                [key: string]: string;
+            };
+            /**
+             * @description Custom key-value metadata for management, filtering, and tagging.
+             *     Use "name" key for a human-readable identifier.
+             * @example {
+             *       "name": "Data Processing Sandbox",
+             *       "project": "data-processing",
+             *       "team": "ml",
+             *       "environment": "staging"
+             *     }
+             */
+            metadata?: {
+                [key: string]: string;
+            };
+            /**
+             * @description The command to execute as the sandbox's entry process (required).
+             *
+             *     Explicitly specifies the user's expected main process, allowing the sandbox management
+             *     service to reliably inject control processes before executing this command.
+             *
+             *     Format: [executable, arg1, arg2, ...]
+             *
+             *     Examples:
+             *     - ["python", "/app/main.py"]
+             *     - ["/bin/bash"]
+             *     - ["java", "-jar", "/app/app.jar"]
+             *     - ["node", "server.js"]
+             * @example [
+             *       "python",
+             *       "/app/main.py"
+             *     ]
+             */
+            entrypoint: string[];
+            /**
+             * @description Optional outbound network policy for the sandbox.
+             *     Shape matches the sidecar `/policy` endpoint. If omitted or empty,
+             *     the sidecar starts in allow-all mode until updated.
+             */
+            networkPolicy?: components$1["schemas"]["NetworkPolicy"];
+            /**
+             * @description Opaque container for provider-specific or transient parameters not supported by the core API.
+             *
+             *     **Note**: This field is reserved for internal features, experimental flags, or temporary behaviors. Standard parameters should be proposed as core API fields.
+             *
+             *     **Best Practices**:
+             *     - **Namespacing**: Use prefixed keys (e.g., `storage.id`) to prevent collisions.
+             *     - **Pass-through**: SDKs and middleware must treat this object as opaque and pass it through transparently.
+             */
+            extensions?: {
+                [key: string]: string;
+            };
+        };
+        /**
+         * @description Runtime resource constraints as key-value pairs. Similar to Kubernetes resource specifications,
+         *     allows flexible definition of resource limits. Common resource types include:
+         *     - `cpu`: CPU allocation in millicores (e.g., "250m" for 0.25 CPU cores)
+         *     - `memory`: Memory allocation in bytes or human-readable format (e.g., "512Mi", "1Gi")
+         *     - `gpu`: Number of GPU devices (e.g., "1")
+         *
+         *     New resource types can be added without API changes.
+         * @example {
+         *       "cpu": "500m",
+         *       "memory": "512Mi",
+         *       "gpu": "1"
+         *     }
+         */
+        ResourceLimits: {
+            [key: string]: string;
+        };
+        RenewSandboxExpirationRequest: {
+            /**
+             * Format: date-time
+             * @description New absolute expiration time in UTC (RFC 3339 format).
+             *     Must be in the future and after the current expiresAt time.
+             *
+             *     Example: "2025-11-16T14:30:45Z"
+             */
+            expiresAt: string;
+        };
+        RenewSandboxExpirationResponse: {
+            /**
+             * Format: date-time
+             * @description The new absolute expiration time in UTC (RFC 3339 format).
+             *
+             *     Example: "2025-11-16T14:30:45Z"
+             */
+            expiresAt: string;
+        };
+        /**
+         * @description Standard error response for all non-2xx HTTP responses.
+         *     HTTP status code indicates the error category; code and message provide details.
+         */
+        ErrorResponse: {
+            /**
+             * @description Machine-readable error code (e.g., INVALID_REQUEST, NOT_FOUND, INTERNAL_ERROR).
+             *     Use this for programmatic error handling.
+             */
+            code: string;
+            /** @description Human-readable error message describing what went wrong and how to fix it. */
+            message: string;
+        };
+        /**
+         * @description Endpoint for accessing a service running in the sandbox.
+         *     The service must be listening on the specified port inside the sandbox for the endpoint to be available.
+         */
+        Endpoint: {
+            /**
+             * @description Public URL to access the service from outside the sandbox.
+             *     Format: {endpoint-host}/sandboxes/{sandboxId}/port/{port}
+             *     Example: endpoint.opensandbox.io/sandboxes/abc123/port/8080
+             */
+            endpoint: string;
+        };
+        /**
+         * @description Egress network policy matching the sidecar `/policy` request body.
+         *     If `default_action` is omitted, the sidecar defaults to "deny"; passing an empty
+         *     object or null results in allow-all behavior at startup.
+         */
+        NetworkPolicy: {
+            /**
+             * @description Default action when no egress rule matches. Defaults to "deny".
+             * @enum {string}
+             */
+            default_action?: "allow" | "deny";
+            /** @description List of egress rules evaluated in order. */
+            egress?: components$1["schemas"]["NetworkRule"][];
+        };
+        NetworkRule: {
+            /**
+             * @description Whether to allow or deny matching targets.
+             * @enum {string}
+             */
+            action: "allow" | "deny";
+            /**
+             * @description FQDN or wildcard domain (e.g., "example.com", "*.example.com").
+             *     IP/CIDR not yet supported in the egress MVP.
+             */
+            target: string;
+        };
+    };
+    responses: {
+        /** @description Error response envelope */
+        Error: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components$1["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description The request was invalid or malformed */
+        BadRequest: {
+            headers: {
+                "X-Request-ID": components$1["headers"]["XRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components$1["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Authentication credentials are missing or invalid */
+        Unauthorized: {
+            headers: {
+                "X-Request-ID": components$1["headers"]["XRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components$1["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description The authenticated user lacks permission for this operation */
+        Forbidden: {
+            headers: {
+                "X-Request-ID": components$1["headers"]["XRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components$1["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description The requested resource does not exist */
+        NotFound: {
+            headers: {
+                "X-Request-ID": components$1["headers"]["XRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components$1["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description The operation conflicts with the current state */
+        Conflict: {
+            headers: {
+                "X-Request-ID": components$1["headers"]["XRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components$1["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description An unexpected server error occurred */
+        InternalServerError: {
+            headers: {
+                "X-Request-ID": components$1["headers"]["XRequestId"];
+                [name: string]: unknown;
+            };
+            content: {
+                "application/json": components$1["schemas"]["ErrorResponse"];
+            };
+        };
+    };
+    parameters: {
+        /** @description Unique sandbox identifier */
+        SandboxId: string;
+    };
+    requestBodies: never;
+    headers: {
+        /** @description Unique request identifier for tracing */
+        XRequestId: string;
+        /** @description URI of the newly created or related resource */
+        Location: string;
+        /** @description Suggested delay in seconds before retrying */
+        RetryAfter: number;
+    };
+    pathItems: never;
+}
+
+type LifecycleClient = Client<paths$1>;
+interface CreateLifecycleClientOptions {
+    /**
+     * Base URL to OpenSandbox Lifecycle API, including the `/v1` prefix.
+     * Example: `http://localhost:8080/v1`
+     */
+    baseUrl?: string;
+    /**
+     * API key for `OPEN-SANDBOX-API-KEY` header.
+     * If omitted, reads from `process.env.OPEN_SANDBOX_API_KEY` when available.
+     */
+    apiKey?: string;
+    /**
+     * Extra headers applied to every request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Custom fetch implementation.
+     *
+     * Useful for proxies, custom TLS, request tracing, retries, or running in environments
+     * where a global `fetch` is not available.
+     */
+    fetch?: typeof fetch;
+}
+declare function createLifecycleClient(opts?: CreateLifecycleClientOptions): LifecycleClient;
+
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+interface paths {
+    "/ping": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Health check endpoint
+         * @description Performs a simple health check to verify that the server is running and responsive.
+         *     Returns HTTP 200 OK status if the server is healthy. This endpoint is typically used
+         *     by load balancers, monitoring systems, and orchestration platforms (like Kubernetes)
+         *     to check service availability.
+         */
+        get: operations["ping"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/code/contexts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List active code execution contexts
+         * @description Lists all active/available code execution contexts.
+         *     If `language` is provided, only contexts under that language/runtime are returned.
+         */
+        get: operations["listContexts"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete all contexts under a language
+         * @description Deletes all existing code execution contexts under the specified `language`/runtime.
+         *     This is a bulk operation intended for code-interpreter context cleanup.
+         */
+        delete: operations["deleteContextsByLanguage"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/code/contexts/{context_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a code execution context by id
+         * @description Retrieves the details of an existing code execution context (session) by id.
+         *     Returns the context ID, language, and any associated metadata.
+         */
+        get: operations["getContext"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a code execution context by id
+         * @description Deletes an existing code execution context (session) by id.
+         *     This should terminate the underlying context thread/process and release resources.
+         */
+        delete: operations["deleteContext"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/code/context": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create code execution context
+         * @description Creates a new code execution environment and returns a session ID that can be used
+         *     for subsequent code execution requests. The context maintains state across multiple
+         *     code executions within the same session.
+         */
+        post: operations["createCodeContext"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/code": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Execute code in context
+         * @description Executes code using Jupyter kernel in a specified execution context and streams
+         *     the output in real-time using SSE (Server-Sent Events). Supports multiple programming
+         *     languages (Python, JavaScript, etc.) and maintains execution state within the session.
+         *     Returns execution results, output streams, execution count, and any errors.
+         */
+        post: operations["runCode"];
+        /**
+         * Interrupt code execution
+         * @description Interrupts the currently running code execution in the specified context.
+         *     This sends a signal to terminate the execution process and releases associated resources.
+         */
+        delete: operations["interruptCode"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/command": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Execute shell command
+         * @description Executes a shell command and streams the output in real-time using SSE (Server-Sent Events).
+         *     The command can run in foreground or background mode. The response includes stdout, stderr,
+         *     execution status, and completion events.
+         */
+        post: operations["runCommand"];
+        /**
+         * Interrupt command execution
+         * @description Interrupts the currently running command execution in the specified context.
+         *     This sends a signal to terminate the execution process and releases associated resources.
+         */
+        delete: operations["interruptCommand"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/command/status/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get command running status
+         * @description Returns the current status of a command (foreground or background) by command ID.
+         *     Includes running flag, exit code, error (if any), and start/finish timestamps.
+         */
+        get: operations["getCommandStatus"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/command/{id}/logs": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get background command stdout/stderr (non-streamed)
+         * @description Returns stdout and stderr for a background (detached) command by command ID.
+         *     Foreground commands should be consumed via SSE; this endpoint is intended for
+         *     polling logs of background commands. Supports incremental reads similar to a file seek:
+         *     pass a starting line via query to fetch output after that line and receive the latest
+         *     tail cursor for the next poll. When no starting line is provided, the full logs are returned.
+         *     Response body is plain text so it can be rendered directly in browsers; the latest line index
+         *     is provided via response header `EXECD-COMMANDS-TAIL-CURSOR` for subsequent incremental requests.
+         */
+        get: operations["getBackgroundCommandLogs"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/files/info": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get file metadata
+         * @description Retrieves detailed metadata for one or multiple files including permissions, owner,
+         *     group, size, and modification time. Returns a map of file paths to their corresponding
+         *     FileInfo objects.
+         */
+        get: operations["getFilesInfo"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/files": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Delete files
+         * @description Deletes one or multiple files from the sandbox. Only removes files, not directories.
+         *     Use RemoveDirs for directory removal.
+         */
+        delete: operations["removeFiles"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/files/permissions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Change file permissions
+         * @description Changes permissions (mode), owner, and group for one or multiple files.
+         *     Accepts a map of file paths to permission settings including octal mode,
+         *     owner username, and group name.
+         */
+        post: operations["chmodFiles"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/files/mv": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Rename or move files
+         * @description Renames or moves one or multiple files to new paths. Can be used for both
+         *     renaming within the same directory and moving to different directories.
+         *     Target directory must exist.
+         */
+        post: operations["renameFiles"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/files/search": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Search for files
+         * @description Searches for files matching a glob pattern within a specified directory and
+         *     its subdirectories. Returns file metadata including path, permissions, owner,
+         *     and group. Supports glob patterns like **, *.txt, etc. Default pattern is ** (all files).
+         */
+        get: operations["searchFiles"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/files/replace": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Replace file content
+         * @description Performs text replacement in one or multiple files. Replaces all occurrences
+         *     of the old string with the new string (similar to strings.ReplaceAll).
+         *     Preserves file permissions. Useful for batch text substitution across files.
+         */
+        post: operations["replaceContent"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/files/upload": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload files to sandbox
+         * @description Uploads one or multiple files to specified paths within the sandbox.
+         *     Reads metadata and file content from multipart form parts in sequence.
+         *     Each file upload consists of two parts: a metadata part (JSON) followed
+         *     by the actual file part.
+         */
+        post: operations["uploadFile"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/files/download": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Download file from sandbox
+         * @description Downloads a file from the specified path within the sandbox. Supports HTTP
+         *     range requests for resumable downloads and partial content retrieval.
+         *     Returns file as octet-stream with appropriate headers.
+         */
+        get: operations["downloadFile"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/directories": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Create directories
+         * @description Creates one or multiple directories with specified permissions. Creates parent
+         *     directories as needed (similar to mkdir -p). Accepts a map of directory paths
+         *     to permission objects.
+         */
+        post: operations["makeDirs"];
+        /**
+         * Delete directories
+         * @description Recursively deletes one or multiple directories and all their contents.
+         *     Similar to rm -rf. Use with caution as this operation cannot be undone.
+         */
+        delete: operations["removeDirs"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/metrics": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get system metrics
+         * @description Retrieves current system resource metrics including CPU usage percentage,
+         *     CPU core count, total memory, used memory, and timestamp. Provides a snapshot
+         *     of system resource utilization at the time of request.
+         */
+        get: operations["getMetrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/metrics/watch": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Watch system metrics in real-time
+         * @description Streams system resource metrics in real-time using Server-Sent Events (SSE).
+         *     Updates are sent every second, providing continuous monitoring of CPU usage,
+         *     memory usage, and other system metrics. The connection remains open until
+         *     the client disconnects.
+         */
+        get: operations["watchMetrics"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+interface components {
+    schemas: {
+        /** @description Request to create a code execution context */
+        CodeContextRequest: {
+            /**
+             * @description Execution runtime (python, bash, java, etc.)
+             * @example python
+             */
+            language?: string;
+        };
+        /** @description Code execution context with session identifier */
+        CodeContext: {
+            /**
+             * @description Unique session identifier returned by CreateContext
+             * @example session-abc123
+             */
+            id?: string;
+            /**
+             * @description Execution runtime
+             * @example python
+             */
+            language: string;
+        };
+        /** @description Request to execute code in a context */
+        RunCodeRequest: {
+            context?: components["schemas"]["CodeContext"];
+            /**
+             * @description Source code to execute
+             * @example import numpy as np
+             *     result = np.array([1, 2, 3])
+             *     print(result)
+             */
+            code: string;
+        };
+        /** @description Request to execute a shell command */
+        RunCommandRequest: {
+            /**
+             * @description Shell command to execute
+             * @example ls -la /workspace
+             */
+            command: string;
+            /**
+             * @description Working directory for command execution
+             * @example /workspace
+             */
+            cwd?: string;
+            /**
+             * @description Whether to run command in detached mode
+             * @default false
+             * @example false
+             */
+            background: boolean;
+        };
+        /** @description Command execution status (foreground or background) */
+        CommandStatusResponse: {
+            /**
+             * @description Command ID returned by RunCommand
+             * @example cmd-abc123
+             */
+            id?: string;
+            /**
+             * @description Original command content
+             * @example ls -la
+             */
+            content?: string;
+            /**
+             * @description Whether the command is still running
+             * @example false
+             */
+            running?: boolean;
+            /**
+             * Format: int32
+             * @description Exit code if the command has finished
+             * @example 0
+             */
+            exit_code?: number | null;
+            /**
+             * @description Error message if the command failed
+             * @example permission denied
+             */
+            error?: string;
+            /**
+             * Format: date-time
+             * @description Start time in RFC3339 format
+             * @example 2025-12-22T09:08:05Z
+             */
+            started_at?: string;
+            /**
+             * Format: date-time
+             * @description Finish time in RFC3339 format (null if still running)
+             * @example 2025-12-22T09:08:09Z
+             */
+            finished_at?: string | null;
+        };
+        /** @description Server-sent event for streaming execution output */
+        ServerStreamEvent: {
+            /**
+             * @description Event type for client-side handling
+             * @example stdout
+             * @enum {string}
+             */
+            type?: "init" | "status" | "error" | "stdout" | "stderr" | "result" | "execution_complete" | "execution_count" | "ping";
+            /**
+             * @description Textual data for status, init, and stream events
+             * @example Hello, World!
+             */
+            text?: string;
+            /**
+             * @description Cell execution number in the session
+             * @example 1
+             */
+            execution_count?: number;
+            /**
+             * Format: int64
+             * @description Execution duration in milliseconds
+             * @example 150
+             */
+            execution_time?: number;
+            /**
+             * Format: int64
+             * @description When the event was generated (Unix milliseconds)
+             * @example 1700000000000
+             */
+            timestamp?: number;
+            /**
+             * @description Execution output in various MIME types (e.g., "text/plain", "text/html")
+             * @example {
+             *       "text/plain": "4"
+             *     }
+             */
+            results?: {
+                [key: string]: unknown;
+            };
+            /** @description Execution error details if an error occurred */
+            error?: {
+                /**
+                 * @description Error name/type
+                 * @example NameError
+                 */
+                ename?: string;
+                /**
+                 * @description Error value/message
+                 * @example name 'undefined_var' is not defined
+                 */
+                evalue?: string;
+                /**
+                 * @description Stack trace lines
+                 * @example [
+                 *       "Traceback (most recent call last):",
+                 *       "  File \"<stdin>\", line 1, in <module>",
+                 *       "NameError: name 'undefined_var' is not defined"
+                 *     ]
+                 */
+                traceback?: string[];
+            };
+        };
+        /** @description File metadata including path and permissions */
+        FileInfo: {
+            /**
+             * @description Absolute file path
+             * @example /workspace/file.txt
+             */
+            path: string;
+            /**
+             * Format: int64
+             * @description File size in bytes
+             * @example 2048
+             */
+            size: number;
+            /**
+             * Format: date-time
+             * @description Last modification time
+             * @example 2025-11-16T14:30:45Z
+             */
+            modified_at: string;
+            /**
+             * Format: date-time
+             * @description File creation time
+             * @example 2025-11-16T14:30:45Z
+             */
+            created_at: string;
+            /**
+             * @description File owner username
+             * @example admin
+             */
+            owner: string;
+            /**
+             * @description File group name
+             * @example admin
+             */
+            group: string;
+            /**
+             * @description File permissions in octal format
+             * @example 755
+             */
+            mode: number;
+        };
+        /** @description File ownership and mode settings */
+        Permission: {
+            /**
+             * @description Owner username
+             * @example root
+             */
+            owner?: string;
+            /**
+             * @description Group name
+             * @example root
+             */
+            group?: string;
+            /**
+             * @description Permission mode in octal format (e.g., 644, 755)
+             * @default 755
+             * @example 755
+             */
+            mode: number;
+        };
+        /** @description File metadata for upload operations */
+        FileMetadata: {
+            /**
+             * @description Target file path
+             * @example /workspace/upload.txt
+             */
+            path?: string;
+            /**
+             * @description File owner
+             * @example admin
+             */
+            owner?: string;
+            /**
+             * @description File group
+             * @example admin
+             */
+            group?: string;
+            /**
+             * @description File permissions in octal
+             * @example 755
+             */
+            mode?: number;
+        };
+        /** @description File rename/move operation */
+        RenameFileItem: {
+            /**
+             * @description Source file path
+             * @example /workspace/old.txt
+             */
+            src: string;
+            /**
+             * @description Destination file path
+             * @example /workspace/new.txt
+             */
+            dest: string;
+        };
+        /** @description Content replacement operation */
+        ReplaceFileContentItem: {
+            /**
+             * @description String to be replaced
+             * @example localhost
+             */
+            old: string;
+            /**
+             * @description Replacement string
+             * @example 0.0.0.0
+             */
+            new: string;
+        };
+        /** @description System resource usage metrics */
+        Metrics: {
+            /**
+             * Format: float
+             * @description Number of CPU cores
+             * @example 4
+             */
+            cpu_count: number;
+            /**
+             * Format: float
+             * @description CPU usage percentage
+             * @example 45.5
+             */
+            cpu_used_pct: number;
+            /**
+             * Format: float
+             * @description Total memory in MiB
+             * @example 8192
+             */
+            mem_total_mib: number;
+            /**
+             * Format: float
+             * @description Used memory in MiB
+             * @example 4096
+             */
+            mem_used_mib: number;
+            /**
+             * Format: int64
+             * @description Timestamp when metrics were collected (Unix milliseconds)
+             * @example 1700000000000
+             */
+            timestamp: number;
+        };
+        /** @description Standard error response format */
+        ErrorResponse: {
+            /**
+             * @description Error code for programmatic handling
+             * @example INVALID_REQUEST_BODY
+             */
+            code: string;
+            /**
+             * @description Human-readable error message
+             * @example error parsing request, MAYBE invalid body format
+             */
+            message: string;
+        };
+    };
+    responses: {
+        /** @description Invalid request body format or missing required fields */
+        BadRequest: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                /**
+                 * @example {
+                 *       "code": "INVALID_REQUEST_BODY",
+                 *       "message": "error parsing request, MAYBE invalid body format"
+                 *     }
+                 */
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description File or resource not found */
+        NotFound: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                /**
+                 * @example {
+                 *       "code": "FILE_NOT_FOUND",
+                 *       "message": "file not found"
+                 *     }
+                 */
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+        /** @description Runtime server error during operation */
+        InternalServerError: {
+            headers: {
+                [name: string]: unknown;
+            };
+            content: {
+                /**
+                 * @example {
+                 *       "code": "RUNTIME_ERROR",
+                 *       "message": "error running code execution"
+                 *     }
+                 */
+                "application/json": components["schemas"]["ErrorResponse"];
+            };
+        };
+    };
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+interface operations {
+    ping: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Server is alive and healthy */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    listContexts: {
+        parameters: {
+            query: {
+                /**
+                 * @description Filter contexts by execution runtime (python, bash, java, etc.)
+                 * @example python
+                 */
+                language: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Array of active contexts */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeContext"][];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    deleteContextsByLanguage: {
+        parameters: {
+            query: {
+                /**
+                 * @description Target execution runtime whose contexts should be deleted
+                 * @example python
+                 */
+                language: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Contexts deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    getContext: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description Session/context id to get
+                 * @example session-abc123
+                 */
+                context_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Context details retrieved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeContext"];
+                };
+            };
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    deleteContext: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description Session/context id to delete
+                 * @example session-abc123
+                 */
+                context_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Context deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    createCodeContext: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CodeContextRequest"];
+            };
+        };
+        responses: {
+            /** @description Successfully created context with session ID */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CodeContext"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    runCode: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RunCodeRequest"];
+            };
+        };
+        responses: {
+            /** @description Stream of code execution events */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": components["schemas"]["ServerStreamEvent"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    interruptCode: {
+        parameters: {
+            query: {
+                /**
+                 * @description Session ID of the execution context to interrupt
+                 * @example session-123
+                 */
+                id: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Code execution successfully interrupted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    runCommand: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RunCommandRequest"];
+            };
+        };
+        responses: {
+            /** @description Stream of command execution events */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": components["schemas"]["ServerStreamEvent"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    interruptCommand: {
+        parameters: {
+            query: {
+                /**
+                 * @description Session ID of the execution context to interrupt
+                 * @example session-456
+                 */
+                id: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Command execution successfully interrupted */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    getCommandStatus: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /**
+                 * @description Command ID returned by RunCommand
+                 * @example cmd-abc123
+                 */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Command status */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["CommandStatusResponse"];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    getBackgroundCommandLogs: {
+        parameters: {
+            query?: {
+                /**
+                 * @description Optional 0-based line cursor (behaves like a file seek). When provided, only
+                 *     stdout/stderr lines after this line are returned. The response includes the
+                 *     latest line index (`cursor`) so the client can request incremental output
+                 *     on subsequent calls. If omitted, the full log is returned.
+                 * @example 120
+                 */
+                cursor?: number;
+            };
+            header?: never;
+            path: {
+                /**
+                 * @description Command ID returned by RunCommand
+                 * @example cmd-abc123
+                 */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Command output (plain text) and status metadata via headers */
+            200: {
+                headers: {
+                    /** @description Highest available 0-based line index after applying the request cursor (use as the next cursor for incremental reads) */
+                    "EXECD-COMMANDS-TAIL-CURSOR"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    /**
+                     * @example line1
+                     *     line2
+                     *     warn: something on stderr
+                     */
+                    "text/plain": string;
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    getFilesInfo: {
+        parameters: {
+            query: {
+                /** @description File path(s) to get info for (can be specified multiple times) */
+                path: string[];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Map of file paths to FileInfo objects */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        [key: string]: components["schemas"]["FileInfo"];
+                    };
+                };
+            };
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    removeFiles: {
+        parameters: {
+            query: {
+                /**
+                 * @description File path(s) to delete (can be specified multiple times)
+                 * @example [
+                 *       "/workspace/temp.txt"
+                 *     ]
+                 */
+                path: string[];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Files deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    chmodFiles: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "/workspace/script.sh": {
+                 *         "owner": "admin",
+                 *         "group": "admin",
+                 *         "mode": 755
+                 *       },
+                 *       "/workspace/config.json": {
+                 *         "owner": "admin",
+                 *         "group": "admin",
+                 *         "mode": 755
+                 *       }
+                 *     }
+                 */
+                "application/json": {
+                    [key: string]: components["schemas"]["Permission"];
+                };
+            };
+        };
+        responses: {
+            /** @description Permissions changed successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    renameFiles: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example [
+                 *       {
+                 *         "src": "/workspace/old_name.txt",
+                 *         "dest": "/workspace/new_name.txt"
+                 *       },
+                 *       {
+                 *         "src": "/workspace/file.py",
+                 *         "dest": "/archive/file.py"
+                 *       }
+                 *     ]
+                 */
+                "application/json": components["schemas"]["RenameFileItem"][];
+            };
+        };
+        responses: {
+            /** @description Files renamed/moved successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    searchFiles: {
+        parameters: {
+            query: {
+                /** @description Root directory path to search in */
+                path: string;
+                /** @description Glob pattern to match files (default is **) */
+                pattern?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Array of matching files with metadata */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["FileInfo"][];
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    replaceContent: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "/workspace/config.yaml": {
+                 *         "old": "localhost:8080",
+                 *         "new": "0.0.0.0:9090"
+                 *       },
+                 *       "/workspace/app.py": {
+                 *         "old": "DEBUG = True",
+                 *         "new": "DEBUG = False"
+                 *       }
+                 *     }
+                 */
+                "application/json": {
+                    [key: string]: components["schemas"]["ReplaceFileContentItem"];
+                };
+            };
+        };
+        responses: {
+            /** @description Content replaced successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    uploadFile: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "multipart/form-data": {
+                    /**
+                     * @description JSON-encoded file metadata (FileMetadata object)
+                     * @example {"path":"/workspace/file.txt","owner":"admin","group":"admin","mode":755}
+                     */
+                    metadata?: string;
+                    /**
+                     * Format: binary
+                     * @description File to upload
+                     */
+                    file?: string;
+                };
+            };
+        };
+        responses: {
+            /** @description Files uploaded successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    downloadFile: {
+        parameters: {
+            query: {
+                /**
+                 * @description Absolute or relative path of the file to download
+                 * @example /workspace/data.csv
+                 */
+                path: string;
+            };
+            header?: {
+                /**
+                 * @description HTTP Range header for partial content requests
+                 * @example bytes=0-1023
+                 */
+                Range?: string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description File content */
+            200: {
+                headers: {
+                    /** @description Attachment header with filename */
+                    "Content-Disposition"?: string;
+                    /** @description File size in bytes */
+                    "Content-Length"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/octet-stream": string;
+                };
+            };
+            /** @description Partial file content (when Range header is provided) */
+            206: {
+                headers: {
+                    /** @description Range of bytes being returned */
+                    "Content-Range"?: string;
+                    /** @description Length of the returned range */
+                    "Content-Length"?: number;
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/octet-stream": string;
+                };
+            };
+            400: components["responses"]["BadRequest"];
+            404: components["responses"]["NotFound"];
+            /** @description Requested range not satisfiable */
+            416: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    makeDirs: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                /**
+                 * @example {
+                 *       "/workspace/project": {
+                 *         "owner": "admin",
+                 *         "group": "admin",
+                 *         "mode": 755
+                 *       },
+                 *       "/workspace/logs": {
+                 *         "owner": "admin",
+                 *         "group": "admin",
+                 *         "mode": 755
+                 *       }
+                 *     }
+                 */
+                "application/json": {
+                    [key: string]: components["schemas"]["Permission"];
+                };
+            };
+        };
+        responses: {
+            /** @description Directories created successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            400: components["responses"]["BadRequest"];
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    removeDirs: {
+        parameters: {
+            query: {
+                /**
+                 * @description Directory path(s) to delete (can be specified multiple times)
+                 * @example [
+                 *       "/workspace/temp"
+                 *     ]
+                 */
+                path: string[];
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Directories deleted successfully */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    getMetrics: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Current system metrics including CPU and memory usage */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Metrics"];
+                };
+            };
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+    watchMetrics: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Stream of system metrics updated every second */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/event-stream": components["schemas"]["Metrics"];
+                };
+            };
+            500: components["responses"]["InternalServerError"];
+        };
+    };
+}
+
+type ExecdClient = Client<paths>;
+interface CreateExecdClientOptions {
+    /**
+     * Base URL to the Execd API (no `/v1` prefix).
+     * Examples:
+     * - `http://localhost:44772`
+     * - `http://api.opensandbox.io/sandboxes/<id>/port/44772`
+     */
+    baseUrl: string;
+    /**
+     * Extra headers applied to every request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Custom fetch implementation.
+     *
+     * Useful for proxies, custom TLS, request tracing, retries, or running in environments
+     * where a global `fetch` is not available.
+     */
+    fetch?: typeof fetch;
+}
+declare function createExecdClient(opts: CreateExecdClientOptions): ExecdClient;
+
+declare class SandboxesAdapter implements Sandboxes {
+    private readonly client;
+    constructor(client: LifecycleClient);
+    private parseIsoDate;
+    private mapSandboxInfo;
+    createSandbox(req: CreateSandboxRequest): Promise<CreateSandboxResponse>;
+    getSandbox(sandboxId: SandboxId): Promise<SandboxInfo>;
+    listSandboxes(params?: ListSandboxesParams): Promise<ListSandboxesResponse>;
+    deleteSandbox(sandboxId: SandboxId): Promise<void>;
+    pauseSandbox(sandboxId: SandboxId): Promise<void>;
+    resumeSandbox(sandboxId: SandboxId): Promise<void>;
+    renewSandboxExpiration(sandboxId: SandboxId, req: RenewSandboxExpirationRequest): Promise<RenewSandboxExpirationResponse>;
+    getSandboxEndpoint(sandboxId: SandboxId, port: number): Promise<Endpoint>;
+}
+
+declare class HealthAdapter implements ExecdHealth {
+    private readonly client;
+    constructor(client: ExecdClient);
+    ping(): Promise<boolean>;
+}
+
+declare class MetricsAdapter implements ExecdMetrics {
+    private readonly client;
+    constructor(client: ExecdClient);
+    getMetrics(): Promise<SandboxMetrics>;
+}
+
+interface FilesystemAdapterOptions {
+    /**
+     * Must match the baseUrl used by the ExecdClient, used for binary endpoints
+     * like download/upload where we bypass JSON parsing.
+     */
+    baseUrl: string;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+}
+/**
+ * Filesystem adapter that exposes user-facing file APIs (`sandbox.files`).
  *
- * Import path:
- * - `@alibaba-group/opensandbox/internal`
+ * This adapter owns all request/response conversions:
+ * - Maps friendly method shapes to API payloads
+ * - Parses timestamps into `Date`
+ * - Implements streaming upload/download helpers
  */
-export { createLifecycleClient } from "./openapi/lifecycleClient.js";
-export type { LifecycleClient } from "./openapi/lifecycleClient.js";
-export { createExecdClient } from "./openapi/execdClient.js";
-export type { ExecdClient } from "./openapi/execdClient.js";
-export type { paths as LifecyclePaths } from "./api/lifecycle.js";
-export type { paths as ExecdPaths } from "./api/execd.js";
-export { SandboxesAdapter } from "./adapters/sandboxesAdapter.js";
-export { HealthAdapter } from "./adapters/healthAdapter.js";
-export { MetricsAdapter } from "./adapters/metricsAdapter.js";
-export { FilesystemAdapter } from "./adapters/filesystemAdapter.js";
-export { CommandsAdapter } from "./adapters/commandsAdapter.js";
-//# sourceMappingURL=internal.d.ts.map
+declare class FilesystemAdapter implements SandboxFiles {
+    private readonly client;
+    private readonly opts;
+    private readonly fetch;
+    private static readonly Api;
+    constructor(client: ExecdClient, opts: FilesystemAdapterOptions);
+    private parseIsoDate;
+    private static readonly _ApiFileInfo;
+    private mapApiFileInfo;
+    getFileInfo(paths: string[]): Promise<Record<string, FileInfo>>;
+    deleteFiles(paths: string[]): Promise<void>;
+    createDirectories(entries: Pick<WriteEntry, "path" | "mode" | "owner" | "group">[]): Promise<void>;
+    deleteDirectories(paths: string[]): Promise<void>;
+    setPermissions(entries: SetPermissionEntry[]): Promise<void>;
+    moveFiles(entries: MoveEntry[]): Promise<void>;
+    replaceContents(entries: ContentReplaceEntry[]): Promise<void>;
+    search(entry: SearchEntry): Promise<SearchFilesResponse>;
+    private uploadFile;
+    readBytes(path: string, opts?: {
+        range?: string;
+    }): Promise<Uint8Array>;
+    readBytesStream(path: string, opts?: {
+        range?: string;
+    }): AsyncIterable<Uint8Array>;
+    private downloadStream;
+    readFile(path: string, opts?: {
+        encoding?: string;
+        range?: string;
+    }): Promise<string>;
+    writeFiles(entries: WriteEntry[]): Promise<void>;
+}
+
+interface CommandsAdapterOptions {
+    /**
+     * Must match the baseUrl used by the ExecdClient.
+     */
+    baseUrl: string;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+}
+declare class CommandsAdapter implements ExecdCommands {
+    private readonly client;
+    private readonly opts;
+    private readonly fetch;
+    constructor(client: ExecdClient, opts: CommandsAdapterOptions);
+    interrupt(sessionId: string): Promise<void>;
+    runStream(command: string, opts?: RunCommandOpts, signal?: AbortSignal): AsyncIterable<ServerStreamEvent>;
+    run(command: string, opts?: RunCommandOpts, handlers?: ExecutionHandlers, signal?: AbortSignal): Promise<CommandExecution>;
+}
+
+export { CommandsAdapter, type ExecdClient, type paths as ExecdPaths, FilesystemAdapter, HealthAdapter, type LifecycleClient, type paths$1 as LifecyclePaths, MetricsAdapter, SandboxesAdapter, createExecdClient, createLifecycleClient };