@daytonaio/sdk 0.175.0 → 0.178.0

package/esm/Sandbox.js

@@ -2,8 +2,8 @@
  * Copyright 2025 Daytona Platforms Inc.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { __decorate, __metadata } from "tslib";
-import { SandboxState, } from '@daytona/api-client';
+import { __esDecorate, __runInitializers } from "tslib";
+import { SandboxState } from '@daytona/api-client';
 import { Daytona } from './Daytona.js';
 import { FileSystemApi, GitApi, ProcessApi, LspApi, InfoApi, ComputerUseApi, InterpreterApi, } from '@daytona/toolbox-api-client';
 import { FileSystem } from './FileSystem.js';
@@ -54,848 +54,784 @@ import { WithInstrumentation } from './utils/otel.decorator.js';
  *
  * @class
  */
-export class Sandbox {
-    clientConfig;
-    axiosInstance;
-    sandboxApi;
-    fs;
-    git;
-    process;
-    computerUse;
-    codeInterpreter;
-    id;
-    name;
-    organizationId;
-    snapshot;
-    user;
-    env;
-    labels;
-    public;
-    target;
-    cpu;
-    gpu;
-    memory;
-    disk;
-    state;
-    errorReason;
-    recoverable;
-    backupState;
-    backupCreatedAt;
-    autoStopInterval;
-    autoArchiveInterval;
-    autoDeleteInterval;
-    volumes;
-    buildInfo;
-    createdAt;
-    updatedAt;
-    lastActivityAt;
-    networkBlockAll;
-    networkAllowList;
-    toolboxProxyUrl;
-    infoApi;
-    /**
-     * Creates a new Sandbox instance
-     *
-     * @param {SandboxDto} sandboxDto - The API Sandbox instance
-     */
-    constructor(sandboxDto, clientConfig, axiosInstance, sandboxApi) {
-        this.clientConfig = clientConfig;
-        this.axiosInstance = axiosInstance;
-        this.sandboxApi = sandboxApi;
-        this.processSandboxDto(sandboxDto);
-        // Set the toolbox base URL
-        let baseUrl = this.toolboxProxyUrl;
-        if (!baseUrl.endsWith('/')) {
-            baseUrl += '/';
-        }
-        this.axiosInstance.defaults.baseURL = baseUrl + this.id;
-        this.clientConfig.basePath = this.axiosInstance.defaults.baseURL;
-        // Initialize Services
-        const getPreviewToken = async () => (await this.getPreviewLink(1)).token;
-        this.fs = new FileSystem(this.clientConfig, new FileSystemApi(this.clientConfig, '', this.axiosInstance));
-        this.git = new Git(new GitApi(this.clientConfig, '', this.axiosInstance));
-        const language = sandboxDto.labels?.[CODE_TOOLBOX_LANGUAGE_LABEL];
-        this.process = new Process(this.clientConfig, new ProcessApi(this.clientConfig, '', this.axiosInstance), getPreviewToken, language);
-        this.codeInterpreter = new CodeInterpreter(this.clientConfig, new InterpreterApi(this.clientConfig, '', this.axiosInstance), getPreviewToken);
-        this.computerUse = new ComputerUse(new ComputerUseApi(this.clientConfig, '', this.axiosInstance));
-        this.infoApi = new InfoApi(this.clientConfig, '', this.axiosInstance);
-    }
-    /**
-     * Gets the user's home directory path for the logged in user inside the Sandbox.
-     *
-     * @returns {Promise<string | undefined>} The absolute path to the Sandbox user's home directory for the logged in user
-     *
-     * @example
-     * const userHomeDir = await sandbox.getUserHomeDir();
-     * console.log(`Sandbox user home: ${userHomeDir}`);
-     */
-    async getUserHomeDir() {
-        const response = await this.infoApi.getUserHomeDir();
-        return response.data.dir;
-    }
-    /**
-     * @deprecated Use `getUserHomeDir` instead. This method will be removed in a future version.
-     */
-    async getUserRootDir() {
-        return this.getUserHomeDir();
-    }
-    /**
-     * Gets the working directory path inside the Sandbox.
-     *
-     * @returns {Promise<string | undefined>} The absolute path to the Sandbox working directory. Uses the WORKDIR specified
-     * in the Dockerfile if present, or falling back to the user's home directory if not.
-     *
-     * @example
-     * const workDir = await sandbox.getWorkDir();
-     * console.log(`Sandbox working directory: ${workDir}`);
-     */
-    async getWorkDir() {
-        const response = await this.infoApi.getWorkDir();
-        return response.data.dir;
-    }
-    /**
-     * Creates a new Language Server Protocol (LSP) server instance.
-     *
-     * The LSP server provides language-specific features like code completion,
-     * diagnostics, and more.
-     *
-     * @param {LspLanguageId} languageId - The language server type (e.g., "typescript")
-     * @param {string} pathToProject - Path to the project root directory. Relative paths are resolved based on the sandbox working directory.
-     * @returns {LspServer} A new LSP server instance configured for the specified language
-     *
-     * @example
-     * const lsp = await sandbox.createLspServer('typescript', 'workspace/project');
-     */
-    async createLspServer(languageId, pathToProject) {
-        return new LspServer(languageId, pathToProject, new LspApi(this.clientConfig, '', this.axiosInstance));
-    }
-    /**
-     * Sets labels for the Sandbox.
-     *
-     * Labels are key-value pairs that can be used to organize and identify Sandboxes.
-     *
-     * @param {Record<string, string>} labels - Dictionary of key-value pairs representing Sandbox labels
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Set sandbox labels
-     * await sandbox.setLabels({
-     *   project: 'my-project',
-     *   environment: 'development',
-     *   team: 'backend'
-     * });
-     */
-    async setLabels(labels) {
-        this.labels = (await this.sandboxApi.replaceLabels(this.id, { labels })).data.labels;
-        return this.labels;
-    }
-    /**
-     * Start the Sandbox.
-     *
-     * This method starts the Sandbox and waits for it to be ready.
-     *
-     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
-     *                            Defaults to 60-second timeout.
-     * @returns {Promise<void>}
-     * @throws {DaytonaError} - `DaytonaError` - If Sandbox fails to start or times out
-     *
-     * @example
-     * const sandbox = await daytona.getCurrentSandbox('my-sandbox');
-     * await sandbox.start(40);  // Wait up to 40 seconds
-     * console.log('Sandbox started successfully');
-     */
-    async start(timeout = 60) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        const startTime = Date.now();
-        const response = await this.sandboxApi.startSandbox(this.id, undefined, { timeout: timeout * 1000 });
-        this.processSandboxDto(response.data);
-        const timeElapsed = Date.now() - startTime;
-        await this.waitUntilStarted(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
-    }
-    /**
-     * Recover the Sandbox from a recoverable error and wait for it to be ready.
-     *
-     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
-     *                            Defaults to 60-second timeout.
-     * @returns {Promise<void>}
-     * @throws {DaytonaError} - `DaytonaError` - If Sandbox fails to recover or times out
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox-id');
-     * await sandbox.recover();
-     * console.log('Sandbox recovered successfully');
-     */
-    async recover(timeout = 60) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        const startTime = Date.now();
-        const response = await this.sandboxApi.recoverSandbox(this.id, undefined, undefined, { timeout: timeout * 1000 });
-        this.processSandboxDto(response.data);
-        const timeElapsed = Date.now() - startTime;
-        await this.waitUntilStarted(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
-    }
-    /**
-     * Stops the Sandbox.
-     *
-     * This method stops the Sandbox and waits for it to be fully stopped.
-     *
-     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
-     *                            Defaults to 60-second timeout.
-     * @param {boolean} [force] - If true, uses SIGKILL instead of SIGTERM. Defaults to false.
-     * @returns {Promise<void>}
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox-id');
-     * await sandbox.stop();
-     * console.log('Sandbox stopped successfully');
-     */
-    async stop(timeout = 60, force = false) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        const startTime = Date.now();
-        await this.sandboxApi.stopSandbox(this.id, undefined, force, { timeout: timeout * 1000 });
-        await this.refreshDataSafe();
-        const timeElapsed = Date.now() - startTime;
-        await this.waitUntilStopped(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
-    }
-    /**
-     * Forks the Sandbox, creating a new Sandbox with an identical filesystem.
-     *
-     * The forked Sandbox is a copy-on-write clone of the original. It starts
-     * with the same disk contents but operates independently from that point on.
-     *
-     * @param {object} [params] - Fork parameters
-     * @param {string} [params.name] - Optional name for the forked Sandbox. If not provided, a unique name will be generated.
-     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
-     *                            Defaults to 60-second timeout.
-     * @returns {Promise<Sandbox>} The forked Sandbox.
-     * @throws {DaytonaValidationError} - If timeout is a negative number
-     * @throws {DaytonaError} - If the fork operation fails or times out
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox');
-     * const forked = await sandbox._experimental_fork({ name: 'my-fork' });
-     * console.log(`Forked sandbox: ${forked.id}`);
-     */
-    async _experimental_fork(params, timeout = 60) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        const startTime = Date.now();
-        const response = await this.sandboxApi.forkSandbox(this.id, { name: params?.name }, undefined, {
-            timeout: timeout * 1000,
-        });
-        const sandboxDto = response.data;
-        const forkedSandbox = new Sandbox(sandboxDto, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi);
-        const timeElapsed = Date.now() - startTime;
-        await forkedSandbox.waitUntilStarted(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
-        return forkedSandbox;
-    }
-    /**
-     * Creates a snapshot from the current state of the Sandbox.
-     *
-     * This captures the Sandbox's filesystem into a reusable snapshot that can be
-     * used to create new Sandboxes. The Sandbox will temporarily enter a
-     * 'snapshotting' state and return to its previous state when complete.
-     *
-     * @param {string} name - Name for the new snapshot
-     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
-     *                            Defaults to 60-second timeout.
-     * @returns {Promise<void>}
-     * @throws {DaytonaValidationError} - If timeout is a negative number
-     * @throws {DaytonaError} - If the snapshot operation fails or times out
-     *
-     * @example
-     * const sandbox = await daytona.get('my-sandbox');
-     * await sandbox._experimental_createSnapshot('my-snapshot');
-     * console.log('Snapshot created successfully');
-     */
-    async _experimental_createSnapshot(name, timeout = 60) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        const startTime = Date.now();
-        const req = { name };
-        await this.sandboxApi.createSandboxSnapshot(this.id, req, undefined, {
-            timeout: timeout * 1000,
-        });
-        await this.refreshData();
-        const timeElapsed = Date.now() - startTime;
-        const remainingTimeout = timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout;
-        await this.waitForSnapshotComplete(remainingTimeout);
-    }
-    async waitForSnapshotComplete(timeout) {
-        let checkInterval = 100;
-        const startTime = Date.now();
-        while (this.state === SandboxState.SNAPSHOTTING) {
-            await this.refreshData();
-            // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-            if (this.state === SandboxState.ERROR || this.state === SandboxState.BUILD_FAILED) {
-                throw new DaytonaError(`Sandbox ${this.id} snapshot failed with state: ${this.state}, error reason: ${this.errorReason}`);
-            }
-            if (this.state !== SandboxState.SNAPSHOTTING) {
-                return;
+let Sandbox = (() => {
+    let _instanceExtraInitializers = [];
+    let _getUserHomeDir_decorators;
+    let _getUserRootDir_decorators;
+    let _getWorkDir_decorators;
+    let _createLspServer_decorators;
+    let _setLabels_decorators;
+    let _start_decorators;
+    let _stop_decorators;
+    let __experimental_fork_decorators;
+    let __experimental_createSnapshot_decorators;
+    let _delete_decorators;
+    let _waitUntilStarted_decorators;
+    let _waitUntilStopped_decorators;
+    let _refreshData_decorators;
+    let _setAutostopInterval_decorators;
+    let _setAutoArchiveInterval_decorators;
+    let _setAutoDeleteInterval_decorators;
+    let _updateNetworkSettings_decorators;
+    let _getPreviewLink_decorators;
+    let _archive_decorators;
+    let _resize_decorators;
+    let _waitForResizeComplete_decorators;
+    let _createSshAccess_decorators;
+    let _revokeSshAccess_decorators;
+    let _validateSshAccess_decorators;
+    return class Sandbox {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getUserHomeDir_decorators = [WithInstrumentation()];
+            _getUserRootDir_decorators = [WithInstrumentation()];
+            _getWorkDir_decorators = [WithInstrumentation()];
+            _createLspServer_decorators = [WithInstrumentation()];
+            _setLabels_decorators = [WithInstrumentation()];
+            _start_decorators = [WithInstrumentation()];
+            _stop_decorators = [WithInstrumentation()];
+            __experimental_fork_decorators = [WithInstrumentation()];
+            __experimental_createSnapshot_decorators = [WithInstrumentation()];
+            _delete_decorators = [WithInstrumentation()];
+            _waitUntilStarted_decorators = [WithInstrumentation()];
+            _waitUntilStopped_decorators = [WithInstrumentation()];
+            _refreshData_decorators = [WithInstrumentation()];
+            _setAutostopInterval_decorators = [WithInstrumentation()];
+            _setAutoArchiveInterval_decorators = [WithInstrumentation()];
+            _setAutoDeleteInterval_decorators = [WithInstrumentation()];
+            _updateNetworkSettings_decorators = [WithInstrumentation()];
+            _getPreviewLink_decorators = [WithInstrumentation()];
+            _archive_decorators = [WithInstrumentation()];
+            _resize_decorators = [WithInstrumentation()];
+            _waitForResizeComplete_decorators = [WithInstrumentation()];
+            _createSshAccess_decorators = [WithInstrumentation()];
+            _revokeSshAccess_decorators = [WithInstrumentation()];
+            _validateSshAccess_decorators = [WithInstrumentation()];
+            __esDecorate(this, null, _getUserHomeDir_decorators, { kind: "method", name: "getUserHomeDir", static: false, private: false, access: { has: obj => "getUserHomeDir" in obj, get: obj => obj.getUserHomeDir }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getUserRootDir_decorators, { kind: "method", name: "getUserRootDir", static: false, private: false, access: { has: obj => "getUserRootDir" in obj, get: obj => obj.getUserRootDir }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getWorkDir_decorators, { kind: "method", name: "getWorkDir", static: false, private: false, access: { has: obj => "getWorkDir" in obj, get: obj => obj.getWorkDir }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createLspServer_decorators, { kind: "method", name: "createLspServer", static: false, private: false, access: { has: obj => "createLspServer" in obj, get: obj => obj.createLspServer }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setLabels_decorators, { kind: "method", name: "setLabels", static: false, private: false, access: { has: obj => "setLabels" in obj, get: obj => obj.setLabels }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _start_decorators, { kind: "method", name: "start", static: false, private: false, access: { has: obj => "start" in obj, get: obj => obj.start }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: obj => "stop" in obj, get: obj => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, __experimental_fork_decorators, { kind: "method", name: "_experimental_fork", static: false, private: false, access: { has: obj => "_experimental_fork" in obj, get: obj => obj._experimental_fork }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, __experimental_createSnapshot_decorators, { kind: "method", name: "_experimental_createSnapshot", static: false, private: false, access: { has: obj => "_experimental_createSnapshot" in obj, get: obj => obj._experimental_createSnapshot }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _delete_decorators, { kind: "method", name: "delete", static: false, private: false, access: { has: obj => "delete" in obj, get: obj => obj.delete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _waitUntilStarted_decorators, { kind: "method", name: "waitUntilStarted", static: false, private: false, access: { has: obj => "waitUntilStarted" in obj, get: obj => obj.waitUntilStarted }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _waitUntilStopped_decorators, { kind: "method", name: "waitUntilStopped", static: false, private: false, access: { has: obj => "waitUntilStopped" in obj, get: obj => obj.waitUntilStopped }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _refreshData_decorators, { kind: "method", name: "refreshData", static: false, private: false, access: { has: obj => "refreshData" in obj, get: obj => obj.refreshData }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setAutostopInterval_decorators, { kind: "method", name: "setAutostopInterval", static: false, private: false, access: { has: obj => "setAutostopInterval" in obj, get: obj => obj.setAutostopInterval }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setAutoArchiveInterval_decorators, { kind: "method", name: "setAutoArchiveInterval", static: false, private: false, access: { has: obj => "setAutoArchiveInterval" in obj, get: obj => obj.setAutoArchiveInterval }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setAutoDeleteInterval_decorators, { kind: "method", name: "setAutoDeleteInterval", static: false, private: false, access: { has: obj => "setAutoDeleteInterval" in obj, get: obj => obj.setAutoDeleteInterval }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _updateNetworkSettings_decorators, { kind: "method", name: "updateNetworkSettings", static: false, private: false, access: { has: obj => "updateNetworkSettings" in obj, get: obj => obj.updateNetworkSettings }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getPreviewLink_decorators, { kind: "method", name: "getPreviewLink", static: false, private: false, access: { has: obj => "getPreviewLink" in obj, get: obj => obj.getPreviewLink }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _archive_decorators, { kind: "method", name: "archive", static: false, private: false, access: { has: obj => "archive" in obj, get: obj => obj.archive }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _resize_decorators, { kind: "method", name: "resize", static: false, private: false, access: { has: obj => "resize" in obj, get: obj => obj.resize }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _waitForResizeComplete_decorators, { kind: "method", name: "waitForResizeComplete", static: false, private: false, access: { has: obj => "waitForResizeComplete" in obj, get: obj => obj.waitForResizeComplete }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _createSshAccess_decorators, { kind: "method", name: "createSshAccess", static: false, private: false, access: { has: obj => "createSshAccess" in obj, get: obj => obj.createSshAccess }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _revokeSshAccess_decorators, { kind: "method", name: "revokeSshAccess", static: false, private: false, access: { has: obj => "revokeSshAccess" in obj, get: obj => obj.revokeSshAccess }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _validateSshAccess_decorators, { kind: "method", name: "validateSshAccess", static: false, private: false, access: { has: obj => "validateSshAccess" in obj, get: obj => obj.validateSshAccess }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        clientConfig = __runInitializers(this, _instanceExtraInitializers);
+        axiosInstance;
+        sandboxApi;
+        fs;
+        git;
+        process;
+        computerUse;
+        codeInterpreter;
+        id;
+        name;
+        organizationId;
+        snapshot;
+        user;
+        env;
+        labels;
+        public;
+        target;
+        cpu;
+        gpu;
+        memory;
+        disk;
+        state;
+        errorReason;
+        recoverable;
+        backupState;
+        backupCreatedAt;
+        autoStopInterval;
+        autoArchiveInterval;
+        autoDeleteInterval;
+        volumes;
+        buildInfo;
+        createdAt;
+        updatedAt;
+        lastActivityAt;
+        networkBlockAll;
+        networkAllowList;
+        toolboxProxyUrl;
+        infoApi;
+        /**
+         * Creates a new Sandbox instance
+         *
+         * @param {SandboxDto} sandboxDto - The API Sandbox instance
+         */
+        constructor(sandboxDto, clientConfig, axiosInstance, sandboxApi) {
+            this.clientConfig = clientConfig;
+            this.axiosInstance = axiosInstance;
+            this.sandboxApi = sandboxApi;
+            this.processSandboxDto(sandboxDto);
+            // Set the toolbox base URL
+            let baseUrl = this.toolboxProxyUrl;
+            if (!baseUrl.endsWith('/')) {
+                baseUrl += '/';
             }
-            if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
-                throw new DaytonaTimeoutError('Sandbox snapshot did not complete within the timeout period');
+            this.axiosInstance.defaults.baseURL = baseUrl + this.id;
+            this.clientConfig.basePath = this.axiosInstance.defaults.baseURL;
+            // Initialize Services
+            const getPreviewToken = async () => (await this.getPreviewLink(1)).token;
+            this.fs = new FileSystem(this.clientConfig, new FileSystemApi(this.clientConfig, '', this.axiosInstance));
+            this.git = new Git(new GitApi(this.clientConfig, '', this.axiosInstance));
+            const language = sandboxDto.labels?.[CODE_TOOLBOX_LANGUAGE_LABEL];
+            this.process = new Process(this.clientConfig, new ProcessApi(this.clientConfig, '', this.axiosInstance), getPreviewToken, language);
+            this.codeInterpreter = new CodeInterpreter(this.clientConfig, new InterpreterApi(this.clientConfig, '', this.axiosInstance), getPreviewToken);
+            this.computerUse = new ComputerUse(new ComputerUseApi(this.clientConfig, '', this.axiosInstance));
+            this.infoApi = new InfoApi(this.clientConfig, '', this.axiosInstance);
+        }
+        /**
+         * Gets the user's home directory path for the logged in user inside the Sandbox.
+         *
+         * @returns {Promise<string | undefined>} The absolute path to the Sandbox user's home directory for the logged in user
+         *
+         * @example
+         * const userHomeDir = await sandbox.getUserHomeDir();
+         * console.log(`Sandbox user home: ${userHomeDir}`);
+         */
+        async getUserHomeDir() {
+            const response = await this.infoApi.getUserHomeDir();
+            return response.data.dir;
+        }
+        /**
+         * @deprecated Use `getUserHomeDir` instead. This method will be removed in a future version.
+         */
+        async getUserRootDir() {
+            return this.getUserHomeDir();
+        }
+        /**
+         * Gets the working directory path inside the Sandbox.
+         *
+         * @returns {Promise<string | undefined>} The absolute path to the Sandbox working directory. Uses the WORKDIR specified
+         * in the Dockerfile if present, or falling back to the user's home directory if not.
+         *
+         * @example
+         * const workDir = await sandbox.getWorkDir();
+         * console.log(`Sandbox working directory: ${workDir}`);
+         */
+        async getWorkDir() {
+            const response = await this.infoApi.getWorkDir();
+            return response.data.dir;
+        }
+        /**
+         * Creates a new Language Server Protocol (LSP) server instance.
+         *
+         * The LSP server provides language-specific features like code completion,
+         * diagnostics, and more.
+         *
+         * @param {LspLanguageId} languageId - The language server type (e.g., "typescript")
+         * @param {string} pathToProject - Path to the project root directory. Relative paths are resolved based on the sandbox working directory.
+         * @returns {LspServer} A new LSP server instance configured for the specified language
+         *
+         * @example
+         * const lsp = await sandbox.createLspServer('typescript', 'workspace/project');
+         */
+        async createLspServer(languageId, pathToProject) {
+            return new LspServer(languageId, pathToProject, new LspApi(this.clientConfig, '', this.axiosInstance));
+        }
+        /**
+         * Sets labels for the Sandbox.
+         *
+         * Labels are key-value pairs that can be used to organize and identify Sandboxes.
+         *
+         * @param {Record<string, string>} labels - Dictionary of key-value pairs representing Sandbox labels
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Set sandbox labels
+         * await sandbox.setLabels({
+         *   project: 'my-project',
+         *   environment: 'development',
+         *   team: 'backend'
+         * });
+         */
+        async setLabels(labels) {
+            this.labels = (await this.sandboxApi.replaceLabels(this.id, { labels })).data.labels;
+            return this.labels;
+        }
+        /**
+         * Start the Sandbox.
+         *
+         * This method starts the Sandbox and waits for it to be ready.
+         *
+         * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+         *                            Defaults to 60-second timeout.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - `DaytonaError` - If Sandbox fails to start or times out
+         *
+         * @example
+         * const sandbox = await daytona.getCurrentSandbox('my-sandbox');
+         * await sandbox.start(40);  // Wait up to 40 seconds
+         * console.log('Sandbox started successfully');
+         */
+        async start(timeout = 60) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            await new Promise((resolve) => setTimeout(resolve, checkInterval));
-            if (Date.now() - startTime > 5000) {
-                checkInterval = Math.min(checkInterval * 1.1, 1000);
+            const startTime = Date.now();
+            const response = await this.sandboxApi.startSandbox(this.id, undefined, { timeout: timeout * 1000 });
+            this.processSandboxDto(response.data);
+            const timeElapsed = Date.now() - startTime;
+            await this.waitUntilStarted(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
+        }
+        /**
+         * Recover the Sandbox from a recoverable error and wait for it to be ready.
+         *
+         * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+         *                            Defaults to 60-second timeout.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - `DaytonaError` - If Sandbox fails to recover or times out
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox-id');
+         * await sandbox.recover();
+         * console.log('Sandbox recovered successfully');
+         */
+        async recover(timeout = 60) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
+            const startTime = Date.now();
+            const response = await this.sandboxApi.recoverSandbox(this.id, undefined, undefined, { timeout: timeout * 1000 });
+            this.processSandboxDto(response.data);
+            const timeElapsed = Date.now() - startTime;
+            await this.waitUntilStarted(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
         }
-    }
-    /**
-     * Deletes the Sandbox.
-     * @returns {Promise<void>}
-     */
-    async delete(timeout = 60) {
-        await this.sandboxApi.deleteSandbox(this.id, undefined, { timeout: timeout * 1000 });
-        this.refreshDataSafe();
-    }
-    /**
-     * Waits for the Sandbox to reach the 'started' state.
-     *
-     * This method polls the Sandbox status until it reaches the 'started' state
-     * or encounters an error.
-     *
-     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
-     *                               Defaults to 60 seconds.
-     * @returns {Promise<void>}
-     * @throws {DaytonaError} - `DaytonaError` - If the sandbox ends up in an error state or fails to start within the timeout period.
-     */
-    async waitUntilStarted(timeout = 60) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        let checkInterval = 100;
-        const startTime = Date.now();
-        while (this.state !== 'started') {
-            await this.refreshData();
-            // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-            if (this.state === 'started') {
-                return;
+        /**
+         * Stops the Sandbox.
+         *
+         * This method stops the Sandbox and waits for it to be fully stopped.
+         *
+         * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+         *                            Defaults to 60-second timeout.
+         * @param {boolean} [force] - If true, uses SIGKILL instead of SIGTERM. Defaults to false.
+         * @returns {Promise<void>}
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox-id');
+         * await sandbox.stop();
+         * console.log('Sandbox stopped successfully');
+         */
+        async stop(timeout = 60, force = false) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            if (this.state === 'error') {
-                const errMsg = `Sandbox ${this.id} failed to start with status: ${this.state}, error reason: ${this.errorReason}`;
-                throw new DaytonaError(errMsg);
+            const startTime = Date.now();
+            await this.sandboxApi.stopSandbox(this.id, undefined, force, { timeout: timeout * 1000 });
+            await this.refreshDataSafe();
+            const timeElapsed = Date.now() - startTime;
+            await this.waitUntilStopped(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
+        }
+        /**
+         * Forks the Sandbox, creating a new Sandbox with an identical filesystem.
+         *
+         * The forked Sandbox is a copy-on-write clone of the original. It starts
+         * with the same disk contents but operates independently from that point on.
+         *
+         * @param {object} [params] - Fork parameters
+         * @param {string} [params.name] - Optional name for the forked Sandbox. If not provided, a unique name will be generated.
+         * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+         *                            Defaults to 60-second timeout.
+         * @returns {Promise<Sandbox>} The forked Sandbox.
+         * @throws {DaytonaValidationError} - If timeout is a negative number
+         * @throws {DaytonaError} - If the fork operation fails or times out
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox');
+         * const forked = await sandbox._experimental_fork({ name: 'my-fork' });
+         * console.log(`Forked sandbox: ${forked.id}`);
+         */
+        async _experimental_fork(params, timeout = 60) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
-                throw new DaytonaTimeoutError('Sandbox failed to become ready within the timeout period');
+            const startTime = Date.now();
+            const response = await this.sandboxApi.forkSandbox(this.id, { name: params?.name }, undefined, {
+                timeout: timeout * 1000,
+            });
+            const sandboxDto = response.data;
+            const forkedSandbox = new Sandbox(sandboxDto, structuredClone(this.clientConfig), Daytona.createAxiosInstance(), this.sandboxApi);
+            const timeElapsed = Date.now() - startTime;
+            await forkedSandbox.waitUntilStarted(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
+            return forkedSandbox;
+        }
+        /**
+         * Creates a snapshot from the current state of the Sandbox.
+         *
+         * This captures the Sandbox's filesystem into a reusable snapshot that can be
+         * used to create new Sandboxes. The Sandbox will temporarily enter a
+         * 'snapshotting' state and return to its previous state when complete.
+         *
+         * @param {string} name - Name for the new snapshot
+         * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+         *                            Defaults to 60-second timeout.
+         * @returns {Promise<void>}
+         * @throws {DaytonaValidationError} - If timeout is a negative number
+         * @throws {DaytonaError} - If the snapshot operation fails or times out
+         *
+         * @example
+         * const sandbox = await daytona.get('my-sandbox');
+         * await sandbox._experimental_createSnapshot('my-snapshot');
+         * console.log('Snapshot created successfully');
+         */
+        async _experimental_createSnapshot(name, timeout = 60) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            await new Promise((resolve) => setTimeout(resolve, checkInterval));
-            if (Date.now() - startTime > 5000) {
-                checkInterval = Math.min(checkInterval * 1.1, 1000);
+            const startTime = Date.now();
+            const req = { name };
+            await this.sandboxApi.createSandboxSnapshot(this.id, req, undefined, {
+                timeout: timeout * 1000,
+            });
+            await this.refreshData();
+            const timeElapsed = Date.now() - startTime;
+            const remainingTimeout = timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout;
+            await this.waitForSnapshotComplete(remainingTimeout);
+        }
+        async waitForSnapshotComplete(timeout) {
+            let checkInterval = 100;
+            const startTime = Date.now();
+            while (this.state === SandboxState.SNAPSHOTTING) {
+                await this.refreshData();
+                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
+                if (this.state === SandboxState.ERROR || this.state === SandboxState.BUILD_FAILED) {
+                    throw new DaytonaError(`Sandbox ${this.id} snapshot failed with state: ${this.state}, error reason: ${this.errorReason}`);
+                }
+                if (this.state !== SandboxState.SNAPSHOTTING) {
+                    return;
+                }
+                if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
+                    throw new DaytonaTimeoutError('Sandbox snapshot did not complete within the timeout period');
+                }
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+                if (Date.now() - startTime > 5000) {
+                    checkInterval = Math.min(checkInterval * 1.1, 1000);
+                }
             }
         }
-    }
-    /**
-     * Wait for Sandbox to reach 'stopped' state.
-     *
-     * This method polls the Sandbox status until it reaches the 'stopped' state
-     * or encounters an error.
-     *
-     * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
-     *                               Defaults to 60 seconds.
-     * @returns {Promise<void>}
-     * @throws {DaytonaError} - `DaytonaError` - If the sandbox fails to stop within the timeout period.
-     */
-    async waitUntilStopped(timeout = 60) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        let checkInterval = 100;
-        const startTime = Date.now();
-        // Treat destroyed as stopped to cover ephemeral sandboxes that are automatically deleted after stopping
-        while (this.state !== 'stopped' && this.state !== 'destroyed') {
+        /**
+         * Deletes the Sandbox.
+         * @returns {Promise<void>}
+         */
+        async delete(timeout = 60) {
+            await this.sandboxApi.deleteSandbox(this.id, undefined, { timeout: timeout * 1000 });
             this.refreshDataSafe();
-            // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-            if (this.state === 'stopped' || this.state === 'destroyed') {
-                return;
+        }
+        /**
+         * Waits for the Sandbox to reach the 'started' state.
+         *
+         * This method polls the Sandbox status until it reaches the 'started' state
+         * or encounters an error.
+         *
+         * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+         *                               Defaults to 60 seconds.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - `DaytonaError` - If the sandbox ends up in an error state or fails to start within the timeout period.
+         */
+        async waitUntilStarted(timeout = 60) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            if (this.state === 'error') {
-                const errMsg = `Sandbox failed to stop with status: ${this.state}, error reason: ${this.errorReason}`;
-                throw new DaytonaError(errMsg);
+            let checkInterval = 100;
+            const startTime = Date.now();
+            while (this.state !== 'started') {
+                await this.refreshData();
+                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
+                if (this.state === 'started') {
+                    return;
+                }
+                if (this.state === 'error') {
+                    const errMsg = `Sandbox ${this.id} failed to start with status: ${this.state}, error reason: ${this.errorReason}`;
+                    throw new DaytonaError(errMsg);
+                }
+                if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
+                    throw new DaytonaTimeoutError('Sandbox failed to become ready within the timeout period');
+                }
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+                if (Date.now() - startTime > 5000) {
+                    checkInterval = Math.min(checkInterval * 1.1, 1000);
+                }
             }
-            if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
-                throw new DaytonaTimeoutError('Sandbox failed to become stopped within the timeout period');
+        }
+        /**
+         * Wait for Sandbox to reach 'stopped' state.
+         *
+         * This method polls the Sandbox status until it reaches the 'stopped' state
+         * or encounters an error.
+         *
+         * @param {number} [timeout] - Maximum time to wait in seconds. 0 means no timeout.
+         *                               Defaults to 60 seconds.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - `DaytonaError` - If the sandbox fails to stop within the timeout period.
+         */
+        async waitUntilStopped(timeout = 60) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
             }
-            await new Promise((resolve) => setTimeout(resolve, checkInterval));
-            if (Date.now() - startTime > 5000) {
-                checkInterval = Math.min(checkInterval * 1.1, 1000);
+            let checkInterval = 100;
+            const startTime = Date.now();
+            // Treat destroyed as stopped to cover ephemeral sandboxes that are automatically deleted after stopping
+            while (this.state !== 'stopped' && this.state !== 'destroyed') {
+                this.refreshDataSafe();
+                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
+                if (this.state === 'stopped' || this.state === 'destroyed') {
+                    return;
+                }
+                if (this.state === 'error') {
+                    const errMsg = `Sandbox failed to stop with status: ${this.state}, error reason: ${this.errorReason}`;
+                    throw new DaytonaError(errMsg);
+                }
+                if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
+                    throw new DaytonaTimeoutError('Sandbox failed to become stopped within the timeout period');
+                }
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+                if (Date.now() - startTime > 5000) {
+                    checkInterval = Math.min(checkInterval * 1.1, 1000);
+                }
             }
         }
-    }
-    /**
-     * Refreshes the Sandbox data from the API.
-     *
-     * @returns {Promise<void>}
-     *
-     * @example
-     * await sandbox.refreshData();
-     * console.log(`Sandbox ${sandbox.id}:`);
-     * console.log(`State: ${sandbox.state}`);
-     * console.log(`Resources: ${sandbox.cpu} CPU, ${sandbox.memory} GiB RAM`);
-     */
-    async refreshData() {
-        const response = await this.sandboxApi.getSandbox(this.id);
-        this.processSandboxDto(response.data);
-    }
-    /**
-     * Refreshes the sandbox activity to reset the timer for automated lifecycle management actions.
-     *
-     * This method updates the sandbox's last activity timestamp without changing its state.
-     * It is useful for keeping long-running sessions alive while there is still user activity.
-     *
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Keep sandbox activity alive
-     * await sandbox.refreshActivity();
-     */
-    async refreshActivity() {
-        await this.sandboxApi.updateLastActivity(this.id);
-    }
-    /**
-     * Set the auto-stop interval for the Sandbox.
-     *
-     * The Sandbox will automatically stop after being idle (no new events) for the specified interval.
-     * Events include any state changes or interactions with the Sandbox through the sdk.
-     * Interactions using Sandbox Previews are not included.
-     *
-     * @param {number} interval - Number of minutes of inactivity before auto-stopping.
-     *                           Set to 0 to disable auto-stop. Default is 15 minutes.
-     * @returns {Promise<void>}
-     * @throws {DaytonaError} - `DaytonaError` - If interval is not a non-negative integer
-     *
-     * @example
-     * // Auto-stop after 1 hour
-     * await sandbox.setAutostopInterval(60);
-     * // Or disable auto-stop
-     * await sandbox.setAutostopInterval(0);
-     */
-    async setAutostopInterval(interval) {
-        if (!Number.isInteger(interval) || interval < 0) {
-            throw new DaytonaValidationError('autoStopInterval must be a non-negative integer');
-        }
-        await this.sandboxApi.setAutostopInterval(this.id, interval);
-        this.autoStopInterval = interval;
-    }
-    /**
-     * Set the auto-archive interval for the Sandbox.
-     *
-     * The Sandbox will automatically archive after being continuously stopped for the specified interval.
-     *
-     * @param {number} interval - Number of minutes after which a continuously stopped Sandbox will be auto-archived.
-     *                           Set to 0 for the maximum interval. Default is 7 days.
-     * @returns {Promise<void>}
-     * @throws {DaytonaError} - `DaytonaError` - If interval is not a non-negative integer
-     *
-     * @example
-     * // Auto-archive after 1 hour
-     * await sandbox.setAutoArchiveInterval(60);
-     * // Or use the maximum interval
-     * await sandbox.setAutoArchiveInterval(0);
-     */
-    async setAutoArchiveInterval(interval) {
-        if (!Number.isInteger(interval) || interval < 0) {
-            throw new DaytonaValidationError('autoArchiveInterval must be a non-negative integer');
-        }
-        await this.sandboxApi.setAutoArchiveInterval(this.id, interval);
-        this.autoArchiveInterval = interval;
-    }
-    /**
-     * Set the auto-delete interval for the Sandbox.
-     *
-     * The Sandbox will automatically delete after being continuously stopped for the specified interval.
-     *
-     * @param {number} interval - Number of minutes after which a continuously stopped Sandbox will be auto-deleted.
-     *                           Set to negative value to disable auto-delete. Set to 0 to delete immediately upon stopping.
-     *                           By default, auto-delete is disabled.
-     * @returns {Promise<void>}
-     *
-     * @example
-     * // Auto-delete after 1 hour
-     * await sandbox.setAutoDeleteInterval(60);
-     * // Or delete immediately upon stopping
-     * await sandbox.setAutoDeleteInterval(0);
-     * // Or disable auto-delete
-     * await sandbox.setAutoDeleteInterval(-1);
-     */
-    async setAutoDeleteInterval(interval) {
-        await this.sandboxApi.setAutoDeleteInterval(this.id, interval);
-        this.autoDeleteInterval = interval;
-    }
-    /**
-     * Updates outbound network policy for this sandbox on the runner (for example block all traffic,
-     * restore general internet access, or apply a CIDR allow list) without stopping the sandbox.
-     *
-     * This maps to the same mechanism as creating a sandbox with `networkBlockAll` / `networkAllowList`:
-     * the runner applies iptables rules to the sandbox container.
-     *
-     * @param {UpdateSandboxNetworkSettings} settings - At least one of `networkBlockAll` or `networkAllowList` must be set.
-     *   Set `networkBlockAll` to `false` to restore outbound access after a block (and clear a stored allow list).
-     *
-     * @example
-     * // Pause internet (outbound blocked)
-     * await sandbox.updateNetworkSettings({ networkBlockAll: true });
-     * // Resume internet
-     * await sandbox.updateNetworkSettings({ networkBlockAll: false });
-     */
-    async updateNetworkSettings(settings) {
-        if (settings.networkBlockAll === undefined && settings.networkAllowList === undefined) {
-            throw new DaytonaValidationError('At least one of networkBlockAll or networkAllowList must be set');
-        }
-        const response = await this.sandboxApi.updateNetworkSettings(this.id, settings);
-        this.processSandboxDto(response.data);
-    }
-    /**
-     * Retrieves the preview link for the sandbox at the specified port. If the port is closed,
-     * it will be opened automatically. For private sandboxes, a token is included to grant access
-     * to the URL.
-     *
-     * @param {number} port - The port to open the preview link on.
-     * @returns {PortPreviewUrl} The response object for the preview link, which includes the `url`
-     * and the `token` (to access private sandboxes).
-     *
-     * @example
-     * const previewLink = await sandbox.getPreviewLink(3000);
-     * console.log(`Preview URL: ${previewLink.url}`);
-     * console.log(`Token: ${previewLink.token}`);
-     */
-    async getPreviewLink(port) {
-        return (await this.sandboxApi.getPortPreviewUrl(this.id, port)).data;
-    }
-    /**
-     * Retrieves a signed preview url for the sandbox at the specified port.
-     *
-     * @param {number} port - The port to open the preview link on.
-     * @param {number} [expiresInSeconds] - The number of seconds the signed preview url will be valid for. Defaults to 60 seconds.
-     * @returns {Promise<SignedPortPreviewUrl>} The response object for the signed preview url.
-     */
-    async getSignedPreviewUrl(port, expiresInSeconds) {
-        return (await this.sandboxApi.getSignedPortPreviewUrl(this.id, port, undefined, expiresInSeconds)).data;
-    }
-    /**
-     * Expires a signed preview url for the sandbox at the specified port.
-     *
-     * @param {number} port - The port to expire the signed preview url on.
-     * @param {string} token - The token to expire the signed preview url on.
-     * @returns {Promise<void>}
-     */
-    async expireSignedPreviewUrl(port, token) {
-        await this.sandboxApi.expireSignedPortPreviewUrl(this.id, port, token);
-    }
-    /**
-     * Archives the sandbox, making it inactive and preserving its state. When sandboxes are archived, the entire filesystem
-     * state is moved to cost-effective object storage, making it possible to keep sandboxes available for an extended period.
-     * The tradeoff between archived and stopped states is that starting an archived sandbox takes more time, depending on its size.
-     * Sandbox must be stopped before archiving.
-     */
-    async archive() {
-        await this.sandboxApi.archiveSandbox(this.id);
-        await this.refreshData();
-    }
-    /**
-     * Resizes the Sandbox resources.
-     *
-     * Changes the CPU, memory, or disk allocation for the Sandbox. Hot resize (on running
-     * sandbox) only allows CPU/memory increases. Disk resize requires a stopped sandbox.
-     *
-     * @param {Resources} resources - New resource configuration. Only specified fields will be updated.
-     *   - cpu: Number of CPU cores (minimum: 1). For hot resize, can only be increased.
-     *   - memory: Memory in GiB (minimum: 1). For hot resize, can only be increased.
-     *   - disk: Disk space in GiB (can only be increased, requires stopped sandbox).
-     * @param {number} [timeout=60] - Timeout in seconds for the resize operation. 0 means no timeout.
-     * @returns {Promise<void>}
-     * @throws {DaytonaError} - If hot resize constraints are violated, disk resize attempted on running sandbox,
-     *   disk size decrease is attempted, no resource changes are specified, or resize operation times out.
-     *
-     * @example
-     * // Increase CPU/memory on running sandbox (hot resize)
-     * await sandbox.resize({ cpu: 4, memory: 8 });
-     *
-     * // Change disk (sandbox must be stopped)
-     * await sandbox.stop();
-     * await sandbox.resize({ cpu: 2, memory: 4, disk: 30 });
-     */
-    async resize(resources, timeout = 60) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        const startTime = Date.now();
-        const resizeRequest = {
-            cpu: resources.cpu,
-            memory: resources.memory,
-            disk: resources.disk,
-        };
-        const response = await this.sandboxApi.resizeSandbox(this.id, resizeRequest, this.organizationId, {
-            timeout: timeout * 1000,
-        });
-        this.processSandboxDto(response.data);
-        const timeElapsed = Date.now() - startTime;
-        await this.waitForResizeComplete(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
-    }
-    /**
-     * Waits for the Sandbox resize operation to complete.
-     *
-     * This method polls the Sandbox status until the state is no longer 'resizing'.
-     *
-     * @param {number} [timeout=60] - Maximum time to wait in seconds. 0 means no timeout.
-     * @returns {Promise<void>}
-     * @throws {DaytonaError} - If the sandbox ends up in an error state or resize times out.
-     */
-    async waitForResizeComplete(timeout = 60) {
-        if (timeout < 0) {
-            throw new DaytonaValidationError('Timeout must be a non-negative number');
-        }
-        let checkInterval = 100;
-        const startTime = Date.now();
-        while (this.state === SandboxState.RESIZING) {
-            await this.refreshData();
-            // @ts-expect-error this.refreshData() can modify this.state so this check is fine
-            if (this.state === SandboxState.ERROR || this.state === SandboxState.BUILD_FAILED) {
-                throw new DaytonaError(`Sandbox ${this.id} resize failed with state: ${this.state}, error reason: ${this.errorReason}`);
-            }
-            if (this.state !== SandboxState.RESIZING) {
-                return;
+        /**
+         * Refreshes the Sandbox data from the API.
+         *
+         * @returns {Promise<void>}
+         *
+         * @example
+         * await sandbox.refreshData();
+         * console.log(`Sandbox ${sandbox.id}:`);
+         * console.log(`State: ${sandbox.state}`);
+         * console.log(`Resources: ${sandbox.cpu} CPU, ${sandbox.memory} GiB RAM`);
+         */
+        async refreshData() {
+            const response = await this.sandboxApi.getSandbox(this.id);
+            this.processSandboxDto(response.data);
+        }
+        /**
+         * Refreshes the sandbox activity to reset the timer for automated lifecycle management actions.
+         *
+         * This method updates the sandbox's last activity timestamp without changing its state.
+         * It is useful for keeping long-running sessions alive while there is still user activity.
+         *
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Keep sandbox activity alive
+         * await sandbox.refreshActivity();
+         */
+        async refreshActivity() {
+            await this.sandboxApi.updateLastActivity(this.id);
+        }
+        /**
+         * Set the auto-stop interval for the Sandbox.
+         *
+         * The Sandbox will automatically stop after being idle (no new events) for the specified interval.
+         * Events include any state changes or interactions with the Sandbox through the sdk.
+         * Interactions using Sandbox Previews are not included.
+         *
+         * @param {number} interval - Number of minutes of inactivity before auto-stopping.
+         *                           Set to 0 to disable auto-stop. Default is 15 minutes.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - `DaytonaError` - If interval is not a non-negative integer
+         *
+         * @example
+         * // Auto-stop after 1 hour
+         * await sandbox.setAutostopInterval(60);
+         * // Or disable auto-stop
+         * await sandbox.setAutostopInterval(0);
+         */
+        async setAutostopInterval(interval) {
+            if (!Number.isInteger(interval) || interval < 0) {
+                throw new DaytonaValidationError('autoStopInterval must be a non-negative integer');
             }
-            if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
-                throw new DaytonaTimeoutError('Sandbox resize did not complete within the timeout period');
+            await this.sandboxApi.setAutostopInterval(this.id, interval);
+            this.autoStopInterval = interval;
+        }
+        /**
+         * Set the auto-archive interval for the Sandbox.
+         *
+         * The Sandbox will automatically archive after being continuously stopped for the specified interval.
+         *
+         * @param {number} interval - Number of minutes after which a continuously stopped Sandbox will be auto-archived.
+         *                           Set to 0 for the maximum interval. Default is 7 days.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - `DaytonaError` - If interval is not a non-negative integer
+         *
+         * @example
+         * // Auto-archive after 1 hour
+         * await sandbox.setAutoArchiveInterval(60);
+         * // Or use the maximum interval
+         * await sandbox.setAutoArchiveInterval(0);
+         */
+        async setAutoArchiveInterval(interval) {
+            if (!Number.isInteger(interval) || interval < 0) {
+                throw new DaytonaValidationError('autoArchiveInterval must be a non-negative integer');
             }
-            await new Promise((resolve) => setTimeout(resolve, checkInterval));
-            if (Date.now() - startTime > 5000) {
-                checkInterval = Math.min(checkInterval * 1.1, 1000);
+            await this.sandboxApi.setAutoArchiveInterval(this.id, interval);
+            this.autoArchiveInterval = interval;
+        }
+        /**
+         * Set the auto-delete interval for the Sandbox.
+         *
+         * The Sandbox will automatically delete after being continuously stopped for the specified interval.
+         *
+         * @param {number} interval - Number of minutes after which a continuously stopped Sandbox will be auto-deleted.
+         *                           Set to negative value to disable auto-delete. Set to 0 to delete immediately upon stopping.
+         *                           By default, auto-delete is disabled.
+         * @returns {Promise<void>}
+         *
+         * @example
+         * // Auto-delete after 1 hour
+         * await sandbox.setAutoDeleteInterval(60);
+         * // Or delete immediately upon stopping
+         * await sandbox.setAutoDeleteInterval(0);
+         * // Or disable auto-delete
+         * await sandbox.setAutoDeleteInterval(-1);
+         */
+        async setAutoDeleteInterval(interval) {
+            await this.sandboxApi.setAutoDeleteInterval(this.id, interval);
+            this.autoDeleteInterval = interval;
+        }
+        /**
+         * Updates outbound network policy for this sandbox on the runner (for example block all traffic,
+         * restore general internet access, or apply a CIDR allow list) without stopping the sandbox.
+         *
+         * This maps to the same mechanism as creating a sandbox with `networkBlockAll` / `networkAllowList`:
+         * the runner applies iptables rules to the sandbox container.
+         *
+         * @param {UpdateSandboxNetworkSettings} settings - At least one of `networkBlockAll` or `networkAllowList` must be set.
+         *   Set `networkBlockAll` to `false` to restore outbound access after a block (and clear a stored allow list).
+         *
+         * @example
+         * // Pause internet (outbound blocked)
+         * await sandbox.updateNetworkSettings({ networkBlockAll: true });
+         * // Resume internet
+         * await sandbox.updateNetworkSettings({ networkBlockAll: false });
+         */
+        async updateNetworkSettings(settings) {
+            if (settings.networkBlockAll === undefined && settings.networkAllowList === undefined) {
+                throw new DaytonaValidationError('At least one of networkBlockAll or networkAllowList must be set');
             }
+            const response = await this.sandboxApi.updateNetworkSettings(this.id, settings);
+            this.processSandboxDto(response.data);
         }
-    }
-    /**
-     * Creates an SSH access token for the sandbox.
-     *
-     * @param {number} expiresInMinutes - The number of minutes the SSH access token will be valid for.
-     * @returns {Promise<SshAccessDto>} The SSH access token.
-     */
-    async createSshAccess(expiresInMinutes) {
-        return (await this.sandboxApi.createSshAccess(this.id, undefined, expiresInMinutes)).data;
-    }
-    /**
-     * Revokes an SSH access token for the sandbox.
-     *
-     * @param {string} token - The token to revoke.
-     * @returns {Promise<void>}
-     */
-    async revokeSshAccess(token) {
-        await this.sandboxApi.revokeSshAccess(this.id, undefined, token);
-    }
-    /**
-     * Validates an SSH access token for the sandbox.
-     *
-     * @param {string} token - The token to validate.
-     * @returns {Promise<SshAccessValidationDto>} The SSH access validation result.
-     */
-    async validateSshAccess(token) {
-        return (await this.sandboxApi.validateSshAccess(token)).data;
-    }
-    /**
-     * Assigns the API sandbox data to the Sandbox object.
-     *
-     * @param {SandboxDto} sandboxDto - The API sandbox instance to assign data from
-     * @returns {void}
-     */
-    processSandboxDto(sandboxDto) {
-        this.id = sandboxDto.id;
-        this.name = sandboxDto.name;
-        this.organizationId = sandboxDto.organizationId;
-        this.snapshot = sandboxDto.snapshot;
-        this.user = sandboxDto.user;
-        this.env = sandboxDto.env;
-        this.labels = sandboxDto.labels;
-        this.public = sandboxDto.public;
-        this.target = sandboxDto.target;
-        this.cpu = sandboxDto.cpu;
-        this.gpu = sandboxDto.gpu;
-        this.memory = sandboxDto.memory;
-        this.disk = sandboxDto.disk;
-        this.state = sandboxDto.state;
-        this.errorReason = sandboxDto.errorReason;
-        this.recoverable = sandboxDto.recoverable;
-        this.backupState = sandboxDto.backupState;
-        this.backupCreatedAt = sandboxDto.backupCreatedAt;
-        this.autoStopInterval = sandboxDto.autoStopInterval;
-        this.autoArchiveInterval = sandboxDto.autoArchiveInterval;
-        this.autoDeleteInterval = sandboxDto.autoDeleteInterval;
-        this.volumes = sandboxDto.volumes;
-        this.buildInfo = sandboxDto.buildInfo;
-        this.createdAt = sandboxDto.createdAt;
-        this.updatedAt = sandboxDto.updatedAt;
-        this.lastActivityAt = sandboxDto.lastActivityAt;
-        this.networkBlockAll = sandboxDto.networkBlockAll;
-        this.networkAllowList = sandboxDto.networkAllowList;
-        this.toolboxProxyUrl = sandboxDto.toolboxProxyUrl;
-    }
-    /**
-     * Refreshes the Sandbox data from the API, but does not throw an error if the sandbox has been deleted.
-     * Instead, it sets the state to destroyed.
-     *
-     * @returns {Promise<void>}
-     */
-    async refreshDataSafe() {
-        try {
+        /**
+         * Retrieves the preview link for the sandbox at the specified port. If the port is closed,
+         * it will be opened automatically. For private sandboxes, a token is included to grant access
+         * to the URL.
+         *
+         * @param {number} port - The port to open the preview link on.
+         * @returns {PortPreviewUrl} The response object for the preview link, which includes the `url`
+         * and the `token` (to access private sandboxes).
+         *
+         * @example
+         * const previewLink = await sandbox.getPreviewLink(3000);
+         * console.log(`Preview URL: ${previewLink.url}`);
+         * console.log(`Token: ${previewLink.token}`);
+         */
+        async getPreviewLink(port) {
+            return (await this.sandboxApi.getPortPreviewUrl(this.id, port)).data;
+        }
+        /**
+         * Retrieves a signed preview url for the sandbox at the specified port.
+         *
+         * @param {number} port - The port to open the preview link on.
+         * @param {number} [expiresInSeconds] - The number of seconds the signed preview url will be valid for. Defaults to 60 seconds.
+         * @returns {Promise<SignedPortPreviewUrl>} The response object for the signed preview url.
+         */
+        async getSignedPreviewUrl(port, expiresInSeconds) {
+            return (await this.sandboxApi.getSignedPortPreviewUrl(this.id, port, undefined, expiresInSeconds)).data;
+        }
+        /**
+         * Expires a signed preview url for the sandbox at the specified port.
+         *
+         * @param {number} port - The port to expire the signed preview url on.
+         * @param {string} token - The token to expire the signed preview url on.
+         * @returns {Promise<void>}
+         */
+        async expireSignedPreviewUrl(port, token) {
+            await this.sandboxApi.expireSignedPortPreviewUrl(this.id, port, token);
+        }
+        /**
+         * Archives the sandbox, making it inactive and preserving its state. When sandboxes are archived, the entire filesystem
+         * state is moved to cost-effective object storage, making it possible to keep sandboxes available for an extended period.
+         * The tradeoff between archived and stopped states is that starting an archived sandbox takes more time, depending on its size.
+         * Sandbox must be stopped before archiving.
+         */
+        async archive() {
+            await this.sandboxApi.archiveSandbox(this.id);
             await this.refreshData();
         }
-        catch (error) {
-            if (error instanceof DaytonaNotFoundError) {
-                this.state = SandboxState.DESTROYED;
+        /**
+         * Resizes the Sandbox resources.
+         *
+         * Changes the CPU, memory, or disk allocation for the Sandbox. Hot resize (on running
+         * sandbox) only allows CPU/memory increases. Disk resize requires a stopped sandbox.
+         *
+         * @param {Resources} resources - New resource configuration. Only specified fields will be updated.
+         *   - cpu: Number of CPU cores (minimum: 1). For hot resize, can only be increased.
+         *   - memory: Memory in GiB (minimum: 1). For hot resize, can only be increased.
+         *   - disk: Disk space in GiB (can only be increased, requires stopped sandbox).
+         * @param {number} [timeout=60] - Timeout in seconds for the resize operation. 0 means no timeout.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - If hot resize constraints are violated, disk resize attempted on running sandbox,
+         *   disk size decrease is attempted, no resource changes are specified, or resize operation times out.
+         *
+         * @example
+         * // Increase CPU/memory on running sandbox (hot resize)
+         * await sandbox.resize({ cpu: 4, memory: 8 });
+         *
+         * // Change disk (sandbox must be stopped)
+         * await sandbox.stop();
+         * await sandbox.resize({ cpu: 2, memory: 4, disk: 30 });
+         */
+        async resize(resources, timeout = 60) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
+            }
+            const startTime = Date.now();
+            const resizeRequest = {
+                cpu: resources.cpu,
+                memory: resources.memory,
+                disk: resources.disk,
+            };
+            const response = await this.sandboxApi.resizeSandbox(this.id, resizeRequest, this.organizationId, {
+                timeout: timeout * 1000,
+            });
+            this.processSandboxDto(response.data);
+            const timeElapsed = Date.now() - startTime;
+            await this.waitForResizeComplete(timeout ? Math.max(0.001, timeout - timeElapsed / 1000) : timeout);
+        }
+        /**
+         * Waits for the Sandbox resize operation to complete.
+         *
+         * This method polls the Sandbox status until the state is no longer 'resizing'.
+         *
+         * @param {number} [timeout=60] - Maximum time to wait in seconds. 0 means no timeout.
+         * @returns {Promise<void>}
+         * @throws {DaytonaError} - If the sandbox ends up in an error state or resize times out.
+         */
+        async waitForResizeComplete(timeout = 60) {
+            if (timeout < 0) {
+                throw new DaytonaValidationError('Timeout must be a non-negative number');
+            }
+            let checkInterval = 100;
+            const startTime = Date.now();
+            while (this.state === SandboxState.RESIZING) {
+                await this.refreshData();
+                // @ts-expect-error this.refreshData() can modify this.state so this check is fine
+                if (this.state === SandboxState.ERROR || this.state === SandboxState.BUILD_FAILED) {
+                    throw new DaytonaError(`Sandbox ${this.id} resize failed with state: ${this.state}, error reason: ${this.errorReason}`);
+                }
+                if (this.state !== SandboxState.RESIZING) {
+                    return;
+                }
+                if (timeout !== 0 && Date.now() - startTime > timeout * 1000) {
+                    throw new DaytonaTimeoutError('Sandbox resize did not complete within the timeout period');
+                }
+                await new Promise((resolve) => setTimeout(resolve, checkInterval));
+                if (Date.now() - startTime > 5000) {
+                    checkInterval = Math.min(checkInterval * 1.1, 1000);
+                }
+            }
+        }
+        /**
+         * Creates an SSH access token for the sandbox.
+         *
+         * @param {number} expiresInMinutes - The number of minutes the SSH access token will be valid for.
+         * @returns {Promise<SshAccessDto>} The SSH access token.
+         */
+        async createSshAccess(expiresInMinutes) {
+            return (await this.sandboxApi.createSshAccess(this.id, undefined, expiresInMinutes)).data;
+        }
+        /**
+         * Revokes an SSH access token for the sandbox.
+         *
+         * @param {string} token - The token to revoke.
+         * @returns {Promise<void>}
+         */
+        async revokeSshAccess(token) {
+            await this.sandboxApi.revokeSshAccess(this.id, undefined, token);
+        }
+        /**
+         * Validates an SSH access token for the sandbox.
+         *
+         * @param {string} token - The token to validate.
+         * @returns {Promise<SshAccessValidationDto>} The SSH access validation result.
+         */
+        async validateSshAccess(token) {
+            return (await this.sandboxApi.validateSshAccess(token)).data;
+        }
+        /**
+         * Assigns the API sandbox data to the Sandbox object.
+         *
+         * @param {SandboxDto} sandboxDto - The API sandbox instance to assign data from
+         * @returns {void}
+         */
+        processSandboxDto(sandboxDto) {
+            this.id = sandboxDto.id;
+            this.name = sandboxDto.name;
+            this.organizationId = sandboxDto.organizationId;
+            this.snapshot = sandboxDto.snapshot;
+            this.user = sandboxDto.user;
+            this.env = sandboxDto.env;
+            this.labels = sandboxDto.labels;
+            this.public = sandboxDto.public;
+            this.target = sandboxDto.target;
+            this.cpu = sandboxDto.cpu;
+            this.gpu = sandboxDto.gpu;
+            this.memory = sandboxDto.memory;
+            this.disk = sandboxDto.disk;
+            this.state = sandboxDto.state;
+            this.errorReason = sandboxDto.errorReason;
+            this.recoverable = sandboxDto.recoverable;
+            this.backupState = sandboxDto.backupState;
+            this.backupCreatedAt = sandboxDto.backupCreatedAt;
+            this.autoStopInterval = sandboxDto.autoStopInterval;
+            this.autoArchiveInterval = sandboxDto.autoArchiveInterval;
+            this.autoDeleteInterval = sandboxDto.autoDeleteInterval;
+            this.volumes = sandboxDto.volumes;
+            this.buildInfo = sandboxDto.buildInfo;
+            this.createdAt = sandboxDto.createdAt;
+            this.updatedAt = sandboxDto.updatedAt;
+            this.lastActivityAt = sandboxDto.lastActivityAt;
+            this.networkBlockAll = sandboxDto.networkBlockAll;
+            this.networkAllowList = sandboxDto.networkAllowList;
+            this.toolboxProxyUrl = sandboxDto.toolboxProxyUrl;
+        }
+        /**
+         * Refreshes the Sandbox data from the API, but does not throw an error if the sandbox has been deleted.
+         * Instead, it sets the state to destroyed.
+         *
+         * @returns {Promise<void>}
+         */
+        async refreshDataSafe() {
+            try {
+                await this.refreshData();
+            }
+            catch (error) {
+                if (error instanceof DaytonaNotFoundError) {
+                    this.state = SandboxState.DESTROYED;
+                }
             }
         }
-    }
-}
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "getUserHomeDir", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "getUserRootDir", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "getWorkDir", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "createLspServer", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "setLabels", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "start", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "stop", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "_experimental_fork", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "_experimental_createSnapshot", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "delete", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "waitUntilStarted", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "waitUntilStopped", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "refreshData", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "setAutostopInterval", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "setAutoArchiveInterval", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "setAutoDeleteInterval", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "updateNetworkSettings", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "getPreviewLink", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "archive", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "resize", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "waitForResizeComplete", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Number]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "createSshAccess", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "revokeSshAccess", null);
-__decorate([
-    WithInstrumentation(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], Sandbox.prototype, "validateSshAccess", null);
+    };
+})();
+export { Sandbox };
 //# sourceMappingURL=Sandbox.js.map