sandbox0 0.10.4 → 0.10.6

package/dist/apispec/src/apis/SandboxesApi.js

@@ -12,11 +12,99 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime.js';
-import { ClaimRequestToJSON, SandboxExecutionStateRequestToJSON, SandboxNetworkPolicyToJSON, SandboxPreviewCreateRequestToJSON, SandboxPreviewRenewRequestToJSON, SandboxRefreshRequestToJSON, SandboxServicesUpdateRequestToJSON, SandboxUpdateRequestToJSON, SuccessClaimResponseFromJSON, SuccessMessageResponseFromJSON, SuccessPauseSandboxResponseFromJSON, SuccessRefreshResponseFromJSON, SuccessResumeSandboxResponseFromJSON, SuccessSandboxListResponseFromJSON, SuccessSandboxNetworkPolicyResponseFromJSON, SuccessSandboxPreviewResponseFromJSON, SuccessSandboxResponseFromJSON, SuccessSandboxServicesResponseFromJSON, SuccessSandboxStatusResponseFromJSON, } from '../models/index.js';
+import { ClaimRequestToJSON, ManagedFileWriteRequestToJSON, SandboxExecutionStateRequestToJSON, SandboxNetworkPolicyToJSON, SandboxPauseRequestToJSON, SandboxPreviewCreateRequestToJSON, SandboxPreviewRenewRequestToJSON, SandboxRefreshRequestToJSON, SandboxRestartFinalCaptureAcknowledgementToJSON, SandboxRestartRequestToJSON, SandboxServicesUpdateRequestToJSON, SandboxSnapshotRestoreRequestToJSON, SandboxUpdateRequestToJSON, SuccessClaimResponseFromJSON, SuccessManagedFileReadResponseFromJSON, SuccessManagedFilesStateResponseFromJSON, SuccessMessageResponseFromJSON, SuccessPauseSandboxResponseFromJSON, SuccessRefreshResponseFromJSON, SuccessResumeSandboxResponseFromJSON, SuccessSandboxHealthResponseFromJSON, SuccessSandboxListResponseFromJSON, SuccessSandboxMemoryOperationResponseFromJSON, SuccessSandboxMemoryRestorationResponseFromJSON, SuccessSandboxNetworkPolicyResponseFromJSON, SuccessSandboxPreviewResponseFromJSON, SuccessSandboxResponseFromJSON, SuccessSandboxRestartFinalCaptureFileResponseFromJSON, SuccessSandboxRestartFinalCaptureResponseFromJSON, SuccessSandboxRestartOperationResponseFromJSON, SuccessSandboxServicesResponseFromJSON, SuccessSandboxSnapshotRestoreOperationResponseFromJSON, SuccessSandboxStatusResponseFromJSON, } from '../models/index.js';
 /**
  *
  */
 export class SandboxesApi extends runtime.BaseAPI {
+    /**
+     * Requires sandbox:write. Submit only after final credential or authenticated logout custody is durably committed by the owner. This permits irreversible cleanup of the old projection. Retry the same capture_id and receipt_id after a lost reply; another receipt conflicts. This schedules retirement, not immediate replacement success.
+     * Commit the owner receipt for final restart credentials
+     */
+    async acknowledgeSandboxRestartFinalCaptureRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling acknowledgeSandboxRestartFinalCapture().');
+        }
+        if (requestParameters['operationId'] == null) {
+            throw new runtime.RequiredError('operationId', 'Required parameter "operationId" was null or undefined when calling acknowledgeSandboxRestartFinalCapture().');
+        }
+        if (requestParameters['sandboxRestartFinalCaptureAcknowledgement'] == null) {
+            throw new runtime.RequiredError('sandboxRestartFinalCaptureAcknowledgement', 'Required parameter "sandboxRestartFinalCaptureAcknowledgement" was null or undefined when calling acknowledgeSandboxRestartFinalCapture().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/restart-operations/{operation_id}/final-capture/acknowledgement`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"operation_id"}}`, encodeURIComponent(String(requestParameters['operationId'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: SandboxRestartFinalCaptureAcknowledgementToJSON(requestParameters['sandboxRestartFinalCaptureAcknowledgement']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartFinalCaptureResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:write. Submit only after final credential or authenticated logout custody is durably committed by the owner. This permits irreversible cleanup of the old projection. Retry the same capture_id and receipt_id after a lost reply; another receipt conflicts. This schedules retirement, not immediate replacement success.
+     * Commit the owner receipt for final restart credentials
+     */
+    async acknowledgeSandboxRestartFinalCapture(requestParameters, initOverrides) {
+        const response = await this.acknowledgeSandboxRestartFinalCaptureRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:write. Submit only after final credential or authenticated logout custody is durably committed by the owner. This permits irreversible cleanup of the old projection. Retry the same capture_id and receipt_id after a lost reply; another receipt conflicts. This schedules retirement, not immediate replacement success.
+     * Commit the owner receipt for final restart credentials
+     */
+    async acknowledgeSandboxSnapshotRestoreFinalCaptureRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling acknowledgeSandboxSnapshotRestoreFinalCapture().');
+        }
+        if (requestParameters['operationId'] == null) {
+            throw new runtime.RequiredError('operationId', 'Required parameter "operationId" was null or undefined when calling acknowledgeSandboxSnapshotRestoreFinalCapture().');
+        }
+        if (requestParameters['sandboxRestartFinalCaptureAcknowledgement'] == null) {
+            throw new runtime.RequiredError('sandboxRestartFinalCaptureAcknowledgement', 'Required parameter "sandboxRestartFinalCaptureAcknowledgement" was null or undefined when calling acknowledgeSandboxSnapshotRestoreFinalCapture().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/snapshot-restore-operations/{operation_id}/final-capture/acknowledgement`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"operation_id"}}`, encodeURIComponent(String(requestParameters['operationId'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: SandboxRestartFinalCaptureAcknowledgementToJSON(requestParameters['sandboxRestartFinalCaptureAcknowledgement']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartFinalCaptureResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:write. Submit only after final credential or authenticated logout custody is durably committed by the owner. This permits irreversible cleanup of the old projection. Retry the same capture_id and receipt_id after a lost reply; another receipt conflicts. This schedules retirement, not immediate replacement success.
+     * Commit the owner receipt for final restart credentials
+     */
+    async acknowledgeSandboxSnapshotRestoreFinalCapture(requestParameters, initOverrides) {
+        const response = await this.acknowledgeSandboxSnapshotRestoreFinalCaptureRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      * List all sandboxes for the authenticated team. In multi-cluster mode, this endpoint aggregates results from all enabled clusters.
      * List sandboxes
@@ -201,7 +289,7 @@ export class SandboxesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * The default checkpoints only the writable RootFS. Set memory=true to also retain process execution state before releasing the runtime. A 202 response means checkpoint publication and cleanup are still pending.
+     * The default checkpoints only the writable RootFS. Set memory=true to also retain process execution state before releasing the runtime. A 202 response means checkpoint publication and cleanup are still pending. For conditional memory pause, send expected_runtime_generation and Idempotency-Key together with memory=true. Retries bind the same source generation and checkpoint operation; mismatched or aborted operations conflict.
      * Pause a sandbox
      */
     async apiV1SandboxesIdPausePostRaw(requestParameters, initOverrides) {
@@ -211,6 +299,9 @@ export class SandboxesApi extends runtime.BaseAPI {
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['idempotencyKey'] != null) {
+            headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -225,12 +316,12 @@ export class SandboxesApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: SandboxExecutionStateRequestToJSON(requestParameters['sandboxExecutionStateRequest']),
+            body: SandboxPauseRequestToJSON(requestParameters['sandboxPauseRequest']),
         }, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => SuccessPauseSandboxResponseFromJSON(jsonValue));
     }
     /**
-     * The default checkpoints only the writable RootFS. Set memory=true to also retain process execution state before releasing the runtime. A 202 response means checkpoint publication and cleanup are still pending.
+     * The default checkpoints only the writable RootFS. Set memory=true to also retain process execution state before releasing the runtime. A 202 response means checkpoint publication and cleanup are still pending. For conditional memory pause, send expected_runtime_generation and Idempotency-Key together with memory=true. Retries bind the same source generation and checkpoint operation; mismatched or aborted operations conflict.
      * Pause a sandbox
      */
     async apiV1SandboxesIdPausePost(requestParameters, initOverrides) {
@@ -430,7 +521,7 @@ export class SandboxesApi extends runtime.BaseAPI {
         return await response.value();
     }
     /**
-     * The default starts a new process runtime from the committed RootFS. Set memory=true to prefer a retained execution image. Missing or incompatible memory falls back to the committed RootFS. A failed memory target is physically reclaimed before a filesystem-only replacement starts. A response with resumed=false means durable fallback is pending; poll sandbox status until running. A disconnected request may continue through background recovery.
+     * The default starts a new process runtime from the committed RootFS. Set memory=true to require a retained execution image. Missing, incompatible, or failed memory restoration returns an error and never authorizes a filesystem-only replacement. Accepted memory operations may continue through background recovery after a disconnected request. For conditional memory resume, send memory=true, expected_runtime_generation, checkpoint_id and Idempotency-Key together. Keep the same authenticated identity, key, checkpoint and source generation on retries. A successful conditional response proves this request committed its exact restore; unrelated running state or a later lifecycle conflicts. An aborted request cannot create a new restore attempt.
      * Resume a sandbox
      */
     async apiV1SandboxesIdResumePostRaw(requestParameters, initOverrides) {
@@ -440,6 +531,9 @@ export class SandboxesApi extends runtime.BaseAPI {
         const queryParameters = {};
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['idempotencyKey'] != null) {
+            headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+        }
         if (this.configuration && this.configuration.accessToken) {
             const token = this.configuration.accessToken;
             const tokenString = await token("bearerAuth", []);
@@ -459,7 +553,7 @@ export class SandboxesApi extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => SuccessResumeSandboxResponseFromJSON(jsonValue));
     }
     /**
-     * The default starts a new process runtime from the committed RootFS. Set memory=true to prefer a retained execution image. Missing or incompatible memory falls back to the committed RootFS. A failed memory target is physically reclaimed before a filesystem-only replacement starts. A response with resumed=false means durable fallback is pending; poll sandbox status until running. A disconnected request may continue through background recovery.
+     * The default starts a new process runtime from the committed RootFS. Set memory=true to require a retained execution image. Missing, incompatible, or failed memory restoration returns an error and never authorizes a filesystem-only replacement. Accepted memory operations may continue through background recovery after a disconnected request. For conditional memory resume, send memory=true, expected_runtime_generation, checkpoint_id and Idempotency-Key together. Keep the same authenticated identity, key, checkpoint and source generation on retries. A successful conditional response proves this request committed its exact restore; unrelated running state or a later lifecycle conflicts. An aborted request cannot create a new restore attempt.
      * Resume a sandbox
      */
     async apiV1SandboxesIdResumePost(requestParameters, initOverrides) {
@@ -608,4 +702,920 @@ export class SandboxesApi extends runtime.BaseAPI {
         const response = await this.apiV1SandboxesPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
-}
+    /**
+     * Deletion consumes the expected sequence before I/O, including when the reply is lost. Inspect/read to reconcile ambiguous results before issuing a new mutation.
+     * Delete a managed runtime file conditionally
+     */
+    async deleteSandboxManagedFileRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteSandboxManagedFile().');
+        }
+        if (requestParameters['runtimeGeneration'] == null) {
+            throw new runtime.RequiredError('runtimeGeneration', 'Required parameter "runtimeGeneration" was null or undefined when calling deleteSandboxManagedFile().');
+        }
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError('name', 'Required parameter "name" was null or undefined when calling deleteSandboxManagedFile().');
+        }
+        if (requestParameters['expectedMutationSequence'] == null) {
+            throw new runtime.RequiredError('expectedMutationSequence', 'Required parameter "expectedMutationSequence" was null or undefined when calling deleteSandboxManagedFile().');
+        }
+        const queryParameters = {};
+        if (requestParameters['runtimeGeneration'] != null) {
+            queryParameters['runtime_generation'] = requestParameters['runtimeGeneration'];
+        }
+        if (requestParameters['expectedMutationSequence'] != null) {
+            queryParameters['expected_mutation_sequence'] = requestParameters['expectedMutationSequence'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/managed-files/{name}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters['name'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessManagedFilesStateResponseFromJSON(jsonValue));
+    }
+    /**
+     * Deletion consumes the expected sequence before I/O, including when the reply is lost. Inspect/read to reconcile ambiguous results before issuing a new mutation.
+     * Delete a managed runtime file conditionally
+     */
+    async deleteSandboxManagedFile(requestParameters, initOverrides) {
+        const response = await this.deleteSandboxManagedFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Deletion consumes the expected sequence before I/O, including when the reply is lost. Inspect/read to reconcile ambiguous results before issuing a new mutation.
+     * Delete a namespaced managed runtime file conditionally
+     */
+    async deleteSandboxNamespacedManagedFileRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['runtimeGeneration'] == null) {
+            throw new runtime.RequiredError('runtimeGeneration', 'Required parameter "runtimeGeneration" was null or undefined when calling deleteSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError('name', 'Required parameter "name" was null or undefined when calling deleteSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['namespace'] == null) {
+            throw new runtime.RequiredError('namespace', 'Required parameter "namespace" was null or undefined when calling deleteSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['expectedMutationSequence'] == null) {
+            throw new runtime.RequiredError('expectedMutationSequence', 'Required parameter "expectedMutationSequence" was null or undefined when calling deleteSandboxNamespacedManagedFile().');
+        }
+        const queryParameters = {};
+        if (requestParameters['runtimeGeneration'] != null) {
+            queryParameters['runtime_generation'] = requestParameters['runtimeGeneration'];
+        }
+        if (requestParameters['expectedMutationSequence'] != null) {
+            queryParameters['expected_mutation_sequence'] = requestParameters['expectedMutationSequence'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/managed-file-namespaces/{namespace}/{name}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters['name'])));
+        urlPath = urlPath.replace(`{${"namespace"}}`, encodeURIComponent(String(requestParameters['namespace'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessManagedFilesStateResponseFromJSON(jsonValue));
+    }
+    /**
+     * Deletion consumes the expected sequence before I/O, including when the reply is lost. Inspect/read to reconcile ambiguous results before issuing a new mutation.
+     * Delete a namespaced managed runtime file conditionally
+     */
+    async deleteSandboxNamespacedManagedFile(requestParameters, initOverrides) {
+        const response = await this.deleteSandboxNamespacedManagedFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Read-only acknowledgement recovery. Requires sandbox:read. Does not execute in the guest or submit a new restart.
+     * Find a restart by its original request key
+     */
+    async findSandboxRestartOperationRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling findSandboxRestartOperation().');
+        }
+        if (requestParameters['requestKey'] == null) {
+            throw new runtime.RequiredError('requestKey', 'Required parameter "requestKey" was null or undefined when calling findSandboxRestartOperation().');
+        }
+        const queryParameters = {};
+        if (requestParameters['requestKey'] != null) {
+            queryParameters['request_key'] = requestParameters['requestKey'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/restart-operations`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartOperationResponseFromJSON(jsonValue));
+    }
+    /**
+     * Read-only acknowledgement recovery. Requires sandbox:read. Does not execute in the guest or submit a new restart.
+     * Find a restart by its original request key
+     */
+    async findSandboxRestartOperation(requestParameters, initOverrides) {
+        const response = await this.findSandboxRestartOperationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Read-only acknowledgement recovery. Requires sandbox:read. Does not execute in the guest or submit a new snapshot restore.
+     * Find a snapshot restore by its original request key
+     */
+    async findSandboxSnapshotRestoreOperationRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling findSandboxSnapshotRestoreOperation().');
+        }
+        if (requestParameters['requestKey'] == null) {
+            throw new runtime.RequiredError('requestKey', 'Required parameter "requestKey" was null or undefined when calling findSandboxSnapshotRestoreOperation().');
+        }
+        const queryParameters = {};
+        if (requestParameters['requestKey'] != null) {
+            queryParameters['request_key'] = requestParameters['requestKey'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/snapshot-restore-operations`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxSnapshotRestoreOperationResponseFromJSON(jsonValue));
+    }
+    /**
+     * Read-only acknowledgement recovery. Requires sandbox:read. Does not execute in the guest or submit a new snapshot restore.
+     * Find a snapshot restore by its original request key
+     */
+    async findSandboxSnapshotRestoreOperation(requestParameters, initOverrides) {
+        const response = await this.findSandboxSnapshotRestoreOperationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read. Reads owner-scoped regional authority and bounded independent node and guest diagnostics without automatic resume, restart or credential preparation. Guest diagnostics may execute a fixed short shell command and allocate a temporary PTY; they create no platform session. No probe runs for a paused runtime or a pending lifecycle. Each observation has its own source and time. Guest results are advisory and cannot establish runtime or storage authority. Unknown means insufficient evidence, not success. A valid launch receipt is not current process liveness; RootFS identity and writer lease are not successful storage IO or a guarantee of uncommitted-write durability. Storage IO currently remains unknown. Authority is rechecked after probes so a changed generation or lifecycle cannot inherit a successful old-runtime observation.
+     * Observe independent runtime, execution, terminal and storage health
+     */
+    async getSandboxHealthRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getSandboxHealth().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/health`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxHealthResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read. Reads owner-scoped regional authority and bounded independent node and guest diagnostics without automatic resume, restart or credential preparation. Guest diagnostics may execute a fixed short shell command and allocate a temporary PTY; they create no platform session. No probe runs for a paused runtime or a pending lifecycle. Each observation has its own source and time. Guest results are advisory and cannot establish runtime or storage authority. Unknown means insufficient evidence, not success. A valid launch receipt is not current process liveness; RootFS identity and writer lease are not successful storage IO or a guarantee of uncommitted-write durability. Storage IO currently remains unknown. Authority is rechecked after probes so a changed generation or lifecycle cannot inherit a successful old-runtime observation.
+     * Observe independent runtime, execution, terminal and storage health
+     */
+    async getSandboxHealth(requestParameters, initOverrides) {
+        const response = await this.getSandboxHealthRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read. Returns external checkpoint/migration restore lineage for the exact current runtime generation after physical retirement commits. No guest execution or lifecycle mutation. This is not a session-health or credential-clean attestation. Missing, pending or incompatible authority is an error; never authorizes cold launch or key re-publication.
+     * Read committed same-sandbox memory restoration lineage
+     */
+    async getSandboxMemoryRestorationRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getSandboxMemoryRestoration().');
+        }
+        if (requestParameters['runtimeGeneration'] == null) {
+            throw new runtime.RequiredError('runtimeGeneration', 'Required parameter "runtimeGeneration" was null or undefined when calling getSandboxMemoryRestoration().');
+        }
+        const queryParameters = {};
+        if (requestParameters['runtimeGeneration'] != null) {
+            queryParameters['runtime_generation'] = requestParameters['runtimeGeneration'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/memory-restoration`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxMemoryRestorationResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read. Returns external checkpoint/migration restore lineage for the exact current runtime generation after physical retirement commits. No guest execution or lifecycle mutation. This is not a session-health or credential-clean attestation. Missing, pending or incompatible authority is an error; never authorizes cold launch or key re-publication.
+     * Read committed same-sandbox memory restoration lineage
+     */
+    async getSandboxMemoryRestoration(requestParameters, initOverrides) {
+        const response = await this.getSandboxMemoryRestorationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read. Reads durable metadata independently of procd. Pending has no capture ID. Stopped identifies one immutable externally stopped source. Acknowledged means the owner receipt is durable; released permits ordinary retirement. This is not a completed restart or a credential-content digest.
+     * Get retained cold-restart credential custody
+     */
+    async getSandboxRestartFinalCaptureRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getSandboxRestartFinalCapture().');
+        }
+        if (requestParameters['operationId'] == null) {
+            throw new runtime.RequiredError('operationId', 'Required parameter "operationId" was null or undefined when calling getSandboxRestartFinalCapture().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/restart-operations/{operation_id}/final-capture`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"operation_id"}}`, encodeURIComponent(String(requestParameters['operationId'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartFinalCaptureResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read. Reads durable metadata independently of procd. Pending has no capture ID. Stopped identifies one immutable externally stopped source. Acknowledged means the owner receipt is durable; released permits ordinary retirement. This is not a completed restart or a credential-content digest.
+     * Get retained cold-restart credential custody
+     */
+    async getSandboxRestartFinalCapture(requestParameters, initOverrides) {
+        const response = await this.getSandboxRestartFinalCaptureRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read. Available independently of procd. A succeeded operation reports its historical replacement generation; later lifecycle activity does not cause another restart or make this an application-health report.
+     * Get durable restart state and bounded retry diagnostics
+     */
+    async getSandboxRestartOperationRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getSandboxRestartOperation().');
+        }
+        if (requestParameters['operationId'] == null) {
+            throw new runtime.RequiredError('operationId', 'Required parameter "operationId" was null or undefined when calling getSandboxRestartOperation().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/restart-operations/{operation_id}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"operation_id"}}`, encodeURIComponent(String(requestParameters['operationId'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartOperationResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read. Available independently of procd. A succeeded operation reports its historical replacement generation; later lifecycle activity does not cause another restart or make this an application-health report.
+     * Get durable restart state and bounded retry diagnostics
+     */
+    async getSandboxRestartOperation(requestParameters, initOverrides) {
+        const response = await this.getSandboxRestartOperationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read. Reads durable metadata independently of procd. Pending has no capture ID. Stopped identifies one immutable externally stopped source. Acknowledged means the owner receipt is durable; released permits ordinary retirement. This is not a completed restart or a credential-content digest.
+     * Get retained cold-restart credential custody
+     */
+    async getSandboxSnapshotRestoreFinalCaptureRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getSandboxSnapshotRestoreFinalCapture().');
+        }
+        if (requestParameters['operationId'] == null) {
+            throw new runtime.RequiredError('operationId', 'Required parameter "operationId" was null or undefined when calling getSandboxSnapshotRestoreFinalCapture().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/snapshot-restore-operations/{operation_id}/final-capture`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"operation_id"}}`, encodeURIComponent(String(requestParameters['operationId'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartFinalCaptureResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read. Reads durable metadata independently of procd. Pending has no capture ID. Stopped identifies one immutable externally stopped source. Acknowledged means the owner receipt is durable; released permits ordinary retirement. This is not a completed restart or a credential-content digest.
+     * Get retained cold-restart credential custody
+     */
+    async getSandboxSnapshotRestoreFinalCapture(requestParameters, initOverrides) {
+        const response = await this.getSandboxSnapshotRestoreFinalCaptureRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read. Available independently of procd. A succeeded operation reports its historical replacement generation; later lifecycle activity does not cause another restart or make this an application-health report.
+     * Get durable restart state and bounded retry diagnostics
+     */
+    async getSandboxSnapshotRestoreOperationRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getSandboxSnapshotRestoreOperation().');
+        }
+        if (requestParameters['operationId'] == null) {
+            throw new runtime.RequiredError('operationId', 'Required parameter "operationId" was null or undefined when calling getSandboxSnapshotRestoreOperation().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/snapshot-restore-operations/{operation_id}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"operation_id"}}`, encodeURIComponent(String(requestParameters['operationId'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxSnapshotRestoreOperationResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read. Available independently of procd. A succeeded operation reports its historical replacement generation; later lifecycle activity does not cause another restart or make this an application-health report.
+     * Get durable restart state and bounded retry diagnostics
+     */
+    async getSandboxSnapshotRestoreOperation(requestParameters, initOverrides) {
+        const response = await this.getSandboxSnapshotRestoreOperationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Uses node-owned storage outside persistent RootFS without executing in the guest. This describes only managed files and does not attest that historical or user-created RootFS files contain no credentials.
+     * Inspect the current runtime-only managed file projection
+     */
+    async inspectSandboxManagedFilesRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling inspectSandboxManagedFiles().');
+        }
+        if (requestParameters['runtimeGeneration'] == null) {
+            throw new runtime.RequiredError('runtimeGeneration', 'Required parameter "runtimeGeneration" was null or undefined when calling inspectSandboxManagedFiles().');
+        }
+        const queryParameters = {};
+        if (requestParameters['runtimeGeneration'] != null) {
+            queryParameters['runtime_generation'] = requestParameters['runtimeGeneration'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/managed-files`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessManagedFilesStateResponseFromJSON(jsonValue));
+    }
+    /**
+     * Uses node-owned storage outside persistent RootFS without executing in the guest. This describes only managed files and does not attest that historical or user-created RootFS files contain no credentials.
+     * Inspect the current runtime-only managed file projection
+     */
+    async inspectSandboxManagedFiles(requestParameters, initOverrides) {
+        const response = await this.inspectSandboxManagedFilesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read and the original caller\'s Idempotency-Key. The authenticated team, user, sandbox and action derive the same request identity as conditional pause or resume. Performs no lifecycle mutation, guest access, quota admission or retry. A missing request returns 404 and never proves cancellation. Historical terminal results remain readable while their evidence is retained, including after later lifecycles; current only compares the owner snapshot and is not a lease or permission to mutate it. Source process health is not implied. A physically resolved failed restore consumes result_runtime_generation while retaining the checkpoint; it must never be retried as a new intent implicitly.
+     * Read the exact conditional memory lifecycle result
+     */
+    async lookupSandboxMemoryOperationRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling lookupSandboxMemoryOperation().');
+        }
+        if (requestParameters['idempotencyKey'] == null) {
+            throw new runtime.RequiredError('idempotencyKey', 'Required parameter "idempotencyKey" was null or undefined when calling lookupSandboxMemoryOperation().');
+        }
+        if (requestParameters['action'] == null) {
+            throw new runtime.RequiredError('action', 'Required parameter "action" was null or undefined when calling lookupSandboxMemoryOperation().');
+        }
+        if (requestParameters['expectedRuntimeGeneration'] == null) {
+            throw new runtime.RequiredError('expectedRuntimeGeneration', 'Required parameter "expectedRuntimeGeneration" was null or undefined when calling lookupSandboxMemoryOperation().');
+        }
+        const queryParameters = {};
+        if (requestParameters['action'] != null) {
+            queryParameters['action'] = requestParameters['action'];
+        }
+        if (requestParameters['expectedRuntimeGeneration'] != null) {
+            queryParameters['expected_runtime_generation'] = requestParameters['expectedRuntimeGeneration'];
+        }
+        if (requestParameters['checkpointId'] != null) {
+            queryParameters['checkpoint_id'] = requestParameters['checkpointId'];
+        }
+        const headerParameters = {};
+        if (requestParameters['idempotencyKey'] != null) {
+            headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/memory-operations/lookup`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxMemoryOperationResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read and the original caller\'s Idempotency-Key. The authenticated team, user, sandbox and action derive the same request identity as conditional pause or resume. Performs no lifecycle mutation, guest access, quota admission or retry. A missing request returns 404 and never proves cancellation. Historical terminal results remain readable while their evidence is retained, including after later lifecycles; current only compares the owner snapshot and is not a lease or permission to mutate it. Source process health is not implied. A physically resolved failed restore consumes result_runtime_generation while retaining the checkpoint; it must never be retried as a new intent implicitly.
+     * Read the exact conditional memory lifecycle result
+     */
+    async lookupSandboxMemoryOperation(requestParameters, initOverrides) {
+        const response = await this.lookupSandboxMemoryOperationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Read a managed runtime file
+     */
+    async readSandboxManagedFileRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling readSandboxManagedFile().');
+        }
+        if (requestParameters['runtimeGeneration'] == null) {
+            throw new runtime.RequiredError('runtimeGeneration', 'Required parameter "runtimeGeneration" was null or undefined when calling readSandboxManagedFile().');
+        }
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError('name', 'Required parameter "name" was null or undefined when calling readSandboxManagedFile().');
+        }
+        const queryParameters = {};
+        if (requestParameters['runtimeGeneration'] != null) {
+            queryParameters['runtime_generation'] = requestParameters['runtimeGeneration'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/managed-files/{name}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters['name'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessManagedFileReadResponseFromJSON(jsonValue));
+    }
+    /**
+     * Read a managed runtime file
+     */
+    async readSandboxManagedFile(requestParameters, initOverrides) {
+        const response = await this.readSandboxManagedFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Read a namespaced managed runtime file
+     */
+    async readSandboxNamespacedManagedFileRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling readSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['runtimeGeneration'] == null) {
+            throw new runtime.RequiredError('runtimeGeneration', 'Required parameter "runtimeGeneration" was null or undefined when calling readSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError('name', 'Required parameter "name" was null or undefined when calling readSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['namespace'] == null) {
+            throw new runtime.RequiredError('namespace', 'Required parameter "namespace" was null or undefined when calling readSandboxNamespacedManagedFile().');
+        }
+        const queryParameters = {};
+        if (requestParameters['runtimeGeneration'] != null) {
+            queryParameters['runtime_generation'] = requestParameters['runtimeGeneration'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/managed-file-namespaces/{namespace}/{name}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters['name'])));
+        urlPath = urlPath.replace(`{${"namespace"}}`, encodeURIComponent(String(requestParameters['namespace'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessManagedFileReadResponseFromJSON(jsonValue));
+    }
+    /**
+     * Read a namespaced managed runtime file
+     */
+    async readSandboxNamespacedManagedFile(requestParameters, initOverrides) {
+        const response = await this.readSandboxNamespacedManagedFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read and the exact capture_id from status. Never reads live or guest storage, creates files, or resumes execution. found=false attests an absent file only after retained backing and external absence are verified. Missing journals, mounts, authority and routes are errors, never logout. Read closes after acknowledgement. Responses must not be logged or cached.
+     * Read a file from the exact stopped restart source
+     */
+    async readSandboxRestartFinalCaptureFileRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling readSandboxRestartFinalCaptureFile().');
+        }
+        if (requestParameters['operationId'] == null) {
+            throw new runtime.RequiredError('operationId', 'Required parameter "operationId" was null or undefined when calling readSandboxRestartFinalCaptureFile().');
+        }
+        if (requestParameters['namespace'] == null) {
+            throw new runtime.RequiredError('namespace', 'Required parameter "namespace" was null or undefined when calling readSandboxRestartFinalCaptureFile().');
+        }
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError('name', 'Required parameter "name" was null or undefined when calling readSandboxRestartFinalCaptureFile().');
+        }
+        if (requestParameters['captureId'] == null) {
+            throw new runtime.RequiredError('captureId', 'Required parameter "captureId" was null or undefined when calling readSandboxRestartFinalCaptureFile().');
+        }
+        const queryParameters = {};
+        if (requestParameters['captureId'] != null) {
+            queryParameters['capture_id'] = requestParameters['captureId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/restart-operations/{operation_id}/final-capture/namespaces/{namespace}/{name}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"operation_id"}}`, encodeURIComponent(String(requestParameters['operationId'])));
+        urlPath = urlPath.replace(`{${"namespace"}}`, encodeURIComponent(String(requestParameters['namespace'])));
+        urlPath = urlPath.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters['name'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartFinalCaptureFileResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read and the exact capture_id from status. Never reads live or guest storage, creates files, or resumes execution. found=false attests an absent file only after retained backing and external absence are verified. Missing journals, mounts, authority and routes are errors, never logout. Read closes after acknowledgement. Responses must not be logged or cached.
+     * Read a file from the exact stopped restart source
+     */
+    async readSandboxRestartFinalCaptureFile(requestParameters, initOverrides) {
+        const response = await this.readSandboxRestartFinalCaptureFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Requires sandbox:read and the exact capture_id from status. Never reads live or guest storage, creates files, or resumes execution. found=false attests an absent file only after retained backing and external absence are verified. Missing journals, mounts, authority and routes are errors, never logout. Read closes after acknowledgement. Responses must not be logged or cached.
+     * Read a file from the exact stopped restart source
+     */
+    async readSandboxSnapshotRestoreFinalCaptureFileRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling readSandboxSnapshotRestoreFinalCaptureFile().');
+        }
+        if (requestParameters['operationId'] == null) {
+            throw new runtime.RequiredError('operationId', 'Required parameter "operationId" was null or undefined when calling readSandboxSnapshotRestoreFinalCaptureFile().');
+        }
+        if (requestParameters['namespace'] == null) {
+            throw new runtime.RequiredError('namespace', 'Required parameter "namespace" was null or undefined when calling readSandboxSnapshotRestoreFinalCaptureFile().');
+        }
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError('name', 'Required parameter "name" was null or undefined when calling readSandboxSnapshotRestoreFinalCaptureFile().');
+        }
+        if (requestParameters['captureId'] == null) {
+            throw new runtime.RequiredError('captureId', 'Required parameter "captureId" was null or undefined when calling readSandboxSnapshotRestoreFinalCaptureFile().');
+        }
+        const queryParameters = {};
+        if (requestParameters['captureId'] != null) {
+            queryParameters['capture_id'] = requestParameters['captureId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/snapshot-restore-operations/{operation_id}/final-capture/namespaces/{namespace}/{name}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"operation_id"}}`, encodeURIComponent(String(requestParameters['operationId'])));
+        urlPath = urlPath.replace(`{${"namespace"}}`, encodeURIComponent(String(requestParameters['namespace'])));
+        urlPath = urlPath.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters['name'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartFinalCaptureFileResponseFromJSON(jsonValue));
+    }
+    /**
+     * Requires sandbox:read and the exact capture_id from status. Never reads live or guest storage, creates files, or resumes execution. found=false attests an absent file only after retained backing and external absence are verified. Missing journals, mounts, authority and routes are errors, never logout. Read closes after acknowledgement. Responses must not be logged or cached.
+     * Read a file from the exact stopped restart source
+     */
+    async readSandboxSnapshotRestoreFinalCaptureFile(requestParameters, initOverrides) {
+        const response = await this.readSandboxSnapshotRestoreFinalCaptureFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Preserves the writable RootFS through external publication and writer fencing, ends the old processes, and starts a fresh runtime. This is not a reconnect, memory restore, or snapshot rollback. Requires sandbox:write and a stable Idempotency-Key bound to expected_runtime_generation. A duplicate returns the original operation and never restarts a newer generation. Request timeout does not cancel committed work. Find the operation by request_key if its acknowledgement was lost. Completion proves runtime replacement, not guest application health. Never use this as an automatic memory fallback.
+     * Explicitly replace a sandbox runtime and discard process state
+     */
+    async restartSandboxRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling restartSandbox().');
+        }
+        if (requestParameters['idempotencyKey'] == null) {
+            throw new runtime.RequiredError('idempotencyKey', 'Required parameter "idempotencyKey" was null or undefined when calling restartSandbox().');
+        }
+        if (requestParameters['sandboxRestartRequest'] == null) {
+            throw new runtime.RequiredError('sandboxRestartRequest', 'Required parameter "sandboxRestartRequest" was null or undefined when calling restartSandbox().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['idempotencyKey'] != null) {
+            headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/restart`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: SandboxRestartRequestToJSON(requestParameters['sandboxRestartRequest']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxRestartOperationResponseFromJSON(jsonValue));
+    }
+    /**
+     * Preserves the writable RootFS through external publication and writer fencing, ends the old processes, and starts a fresh runtime. This is not a reconnect, memory restore, or snapshot rollback. Requires sandbox:write and a stable Idempotency-Key bound to expected_runtime_generation. A duplicate returns the original operation and never restarts a newer generation. Request timeout does not cancel committed work. Find the operation by request_key if its acknowledgement was lost. Completion proves runtime replacement, not guest application health. Never use this as an automatic memory fallback.
+     * Explicitly replace a sandbox runtime and discard process state
+     */
+    async restartSandbox(requestParameters, initOverrides) {
+        const response = await this.restartSandboxRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * Explicitly discards source process state and replaces its writable RootFS with the exact selected snapshot generation. Requires sandbox:write, discard_process_state=true and a stable Idempotency-Key bound to the source runtime generation and snapshot identity. Admission pins the selected data, including across later snapshot expiry or deletion. External final capture retains projected credential custody before source retirement. Head replacement and cold resume admission commit together. A duplicate returns the original operation and cannot restore again. Request timeout does not cancel accepted work; recover its acknowledgement by request_key. Completion proves external runtime launch, not guest application health. Never use as a memory fallback.
+     * Restore a selected snapshot and start a fresh runtime
+     */
+    async restoreSandboxSnapshotRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling restoreSandboxSnapshot().');
+        }
+        if (requestParameters['idempotencyKey'] == null) {
+            throw new runtime.RequiredError('idempotencyKey', 'Required parameter "idempotencyKey" was null or undefined when calling restoreSandboxSnapshot().');
+        }
+        if (requestParameters['sandboxSnapshotRestoreRequest'] == null) {
+            throw new runtime.RequiredError('sandboxSnapshotRestoreRequest', 'Required parameter "sandboxSnapshotRestoreRequest" was null or undefined when calling restoreSandboxSnapshot().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (requestParameters['idempotencyKey'] != null) {
+            headerParameters['Idempotency-Key'] = String(requestParameters['idempotencyKey']);
+        }
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/snapshot-restore`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: SandboxSnapshotRestoreRequestToJSON(requestParameters['sandboxSnapshotRestoreRequest']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessSandboxSnapshotRestoreOperationResponseFromJSON(jsonValue));
+    }
+    /**
+     * Explicitly discards source process state and replaces its writable RootFS with the exact selected snapshot generation. Requires sandbox:write, discard_process_state=true and a stable Idempotency-Key bound to the source runtime generation and snapshot identity. Admission pins the selected data, including across later snapshot expiry or deletion. External final capture retains projected credential custody before source retirement. Head replacement and cold resume admission commit together. A duplicate returns the original operation and cannot restore again. Request timeout does not cancel accepted work; recover its acknowledgement by request_key. Completion proves external runtime launch, not guest application health. Never use as a memory fallback.
+     * Restore a selected snapshot and start a fresh runtime
+     */
+    async restoreSandboxSnapshot(requestParameters, initOverrides) {
+        const response = await this.restoreSandboxSnapshotRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * The expected mutation sequence is consumed before file I/O. An ambiguous response must be reconciled with inspect/read; never automatically retry with a newly fetched sequence. The sequence orders platform requests, not native guest refreshes.
+     * Replace a managed runtime file conditionally
+     */
+    async writeSandboxManagedFileRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling writeSandboxManagedFile().');
+        }
+        if (requestParameters['runtimeGeneration'] == null) {
+            throw new runtime.RequiredError('runtimeGeneration', 'Required parameter "runtimeGeneration" was null or undefined when calling writeSandboxManagedFile().');
+        }
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError('name', 'Required parameter "name" was null or undefined when calling writeSandboxManagedFile().');
+        }
+        if (requestParameters['managedFileWriteRequest'] == null) {
+            throw new runtime.RequiredError('managedFileWriteRequest', 'Required parameter "managedFileWriteRequest" was null or undefined when calling writeSandboxManagedFile().');
+        }
+        const queryParameters = {};
+        if (requestParameters['runtimeGeneration'] != null) {
+            queryParameters['runtime_generation'] = requestParameters['runtimeGeneration'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/managed-files/{name}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters['name'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ManagedFileWriteRequestToJSON(requestParameters['managedFileWriteRequest']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessManagedFilesStateResponseFromJSON(jsonValue));
+    }
+    /**
+     * The expected mutation sequence is consumed before file I/O. An ambiguous response must be reconciled with inspect/read; never automatically retry with a newly fetched sequence. The sequence orders platform requests, not native guest refreshes.
+     * Replace a managed runtime file conditionally
+     */
+    async writeSandboxManagedFile(requestParameters, initOverrides) {
+        const response = await this.writeSandboxManagedFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     * The expected mutation sequence is consumed before file I/O. An ambiguous response must be reconciled with inspect/read; never automatically retry with a newly fetched sequence. The sequence orders platform requests, not native guest refreshes.
+     * Replace a namespaced managed runtime file conditionally
+     */
+    async writeSandboxNamespacedManagedFileRaw(requestParameters, initOverrides) {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling writeSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['runtimeGeneration'] == null) {
+            throw new runtime.RequiredError('runtimeGeneration', 'Required parameter "runtimeGeneration" was null or undefined when calling writeSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['name'] == null) {
+            throw new runtime.RequiredError('name', 'Required parameter "name" was null or undefined when calling writeSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['namespace'] == null) {
+            throw new runtime.RequiredError('namespace', 'Required parameter "namespace" was null or undefined when calling writeSandboxNamespacedManagedFile().');
+        }
+        if (requestParameters['managedFileWriteRequest'] == null) {
+            throw new runtime.RequiredError('managedFileWriteRequest', 'Required parameter "managedFileWriteRequest" was null or undefined when calling writeSandboxNamespacedManagedFile().');
+        }
+        const queryParameters = {};
+        if (requestParameters['runtimeGeneration'] != null) {
+            queryParameters['runtime_generation'] = requestParameters['runtimeGeneration'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearerAuth", []);
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        let urlPath = `/api/v1/sandboxes/{id}/managed-file-namespaces/{namespace}/{name}`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+        urlPath = urlPath.replace(`{${"name"}}`, encodeURIComponent(String(requestParameters['name'])));
+        urlPath = urlPath.replace(`{${"namespace"}}`, encodeURIComponent(String(requestParameters['namespace'])));
+        const response = await this.request({
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ManagedFileWriteRequestToJSON(requestParameters['managedFileWriteRequest']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => SuccessManagedFilesStateResponseFromJSON(jsonValue));
+    }
+    /**
+     * The expected mutation sequence is consumed before file I/O. An ambiguous response must be reconciled with inspect/read; never automatically retry with a newly fetched sequence. The sequence orders platform requests, not native guest refreshes.
+     * Replace a namespaced managed runtime file conditionally
+     */
+    async writeSandboxNamespacedManagedFile(requestParameters, initOverrides) {
+        const response = await this.writeSandboxNamespacedManagedFileRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+}
+/**
+ * @export
+ */
+export const LookupSandboxMemoryOperationActionEnum = {
+    Pause: 'pause',
+    Resume: 'resume'
+};