@daytonaio/sdk 0.170.0 → 0.171.0-alpha.3

package/esm/README.md

@@ -0,0 +1,180 @@
+# Daytona TypeScript SDK
+
+The official TypeScript SDK for [Daytona](https://daytona.io), an open-source, secure and elastic infrastructure for running AI-generated code. Daytona provides full composable computers — [sandboxes](https://www.daytona.io/docs/en/sandboxes/) — that you can manage programmatically using the Daytona SDK.
+
+The SDK provides an interface for sandbox management, file system operations, Git operations, language server protocol support, process and code execution, and computer use. For more information, see the [documentation](https://www.daytona.io/docs/en/typescript-sdk/).
+
+## Installation
+
+Install the package using **npm**:
+
+```bash
+npm install @daytona/sdk
+```
+
+or using **yarn**:
+
+```bash
+yarn add @daytona/sdk
+```
+
+## Get API key
+
+Generate an API key from the [Daytona Dashboard ↗](https://app.daytona.io/dashboard/keys) to authenticate SDK requests and access Daytona services. For more information, see the [API keys](https://www.daytona.io/docs/en/api-keys/) documentation.
+
+## Configuration
+
+Configure the SDK using [environment variables](https://www.daytona.io/docs/en/configuration/#environment-variables) or by passing a [configuration object](https://www.daytona.io/docs/en/configuration/#configuration-in-code):
+
+- `DAYTONA_API_KEY`: Your Daytona [API key](https://www.daytona.io/docs/en/api-keys/)
+- `DAYTONA_API_URL`: The Daytona [API URL](https://www.daytona.io/docs/en/tools/api/)
+- `DAYTONA_TARGET`: Your target [region](https://www.daytona.io/docs/en/regions/) environment (e.g. `us`, `eu`)
+
+```typescript
+import { Daytona } from '@daytona/sdk'
+
+// Initialize with environment variables
+const daytona = new Daytona();
+
+// Initialize with configuration object
+const daytona = new Daytona({
+  apiKey: 'YOUR_API_KEY',
+  apiUrl: 'YOUR_API_URL',
+  target: 'us',
+});
+```
+
+## Create a sandbox
+
+Create a sandbox to run your code securely in an isolated environment.
+
+```typescript
+import { Daytona } from '@daytona/sdk'
+
+const daytona = new Daytona({apiKey: "YOUR_API_KEY"});
+const sandbox = await daytona.create({
+  language: 'typescript'
+});
+const response = await sandbox.process.codeRun('console.log("Hello World!")');
+console.log(response.result);
+```
+
+## Examples and guides
+
+Daytona provides [examples](https://www.daytona.io/docs/en/getting-started/#examples) and [guides](https://www.daytona.io/docs/en/guides/) for common sandbox operations, best practices, and a wide range of topics, from basic usage to advanced topics, showcasing various types of integrations between Daytona and other tools.
+
+### Create a sandbox with custom resources
+
+Create a sandbox with [custom resources](https://www.daytona.io/docs/en/sandboxes/#resources) (CPU, memory, disk).
+
+```typescript
+import { Daytona, Image } from '@daytona/sdk';
+
+const daytona = new Daytona();
+const sandbox = await daytona.create({
+    image: Image.debianSlim('3.12'),
+    resources: { cpu: 2, memory: 4, disk: 8 }
+});
+```
+
+### Create an ephemeral sandbox
+
+Create an [ephemeral sandbox](https://www.daytona.io/docs/en/sandboxes/#ephemeral-sandboxes) that is automatically deleted when stopped.
+
+```typescript
+import { Daytona } from '@daytona/sdk';
+
+const daytona = new Daytona();
+const sandbox = await daytona.create({
+    ephemeral: true,
+    autoStopInterval: 5
+});
+```
+
+### Create a sandbox from a snapshot
+
+Create a sandbox from a [snapshot](https://www.daytona.io/docs/en/snapshots/).
+
+```typescript
+import { Daytona } from '@daytona/sdk';
+
+const daytona = new Daytona();
+const sandbox = await daytona.create({
+    snapshot: 'my-snapshot-name',
+    language: 'typescript'
+});
+```
+
+### Execute commands
+
+Execute commands in the sandbox.
+
+```typescript
+// Execute a shell command
+const response = await sandbox.process.executeCommand('echo "Hello, World!"')
+console.log(response.result)
+
+// Run TypeScript code
+const response = await sandbox.process.codeRun(`
+const x = 10
+const y = 20
+console.log(\`Sum: \${x + y}\`)
+`)
+console.log(response.result)
+```
+
+### File operations
+
+Upload, download, and search files in the sandbox.
+
+```typescript
+// Upload a file
+await sandbox.fs.uploadFile(Buffer.from('Hello, World!'), 'path/to/file.txt')
+
+// Download a file
+const content = await sandbox.fs.downloadFile('path/to/file.txt')
+
+// Search for files
+const matches = await sandbox.fs.findFiles(root_dir, 'search_pattern')
+```
+
+### Git operations
+
+Clone, list branches, and add files to the sandbox.
+
+```typescript
+// Clone a repository
+await sandbox.git.clone('https://github.com/example/repo', 'path/to/clone')
+
+// List branches
+const branches = await sandbox.git.branches('path/to/repo')
+
+// Add files
+await sandbox.git.add('path/to/repo', ['file1.txt', 'file2.txt'])
+```
+
+### Language server protocol
+
+Create and start a language server to get code completions, document symbols, and more.
+
+```typescript
+// Create and start a language server
+const lsp = await sandbox.createLspServer('typescript', 'path/to/project')
+await lsp.start()
+
+// Notify the lsp for the file
+await lsp.didOpen('path/to/file.ts')
+
+// Get document symbols
+const symbols = await lsp.documentSymbols('path/to/file.ts')
+
+// Get completions
+const completions = await lsp.completions('path/to/file.ts', {
+  line: 10,
+  character: 15,
+})
+```
+
+## Contributing
+
+Daytona is Open Source under the [Apache License 2.0](./LICENSE), and is the [copyright of its contributors](../../NOTICE). If you would like to contribute to the software, read the Developer Certificate of Origin Version 1.1 (https://developercertificate.org/). Afterwards, navigate to the [contributing guide](../../CONTRIBUTING.md) to get started.

package/esm/Sandbox.d.ts

@@ -0,0 +1,476 @@
+import { SandboxState, SandboxApi, Sandbox as SandboxDto, PaginatedSandboxes as PaginatedSandboxesDto, PortPreviewUrl, SandboxVolume, BuildInfo, SandboxBackupStateEnum, Configuration, SshAccessDto, SshAccessValidationDto, SignedPortPreviewUrl, UpdateSandboxNetworkSettings } from '@daytona/api-client';
+import { Resources } from './Daytona.js';
+import { FileSystem } from './FileSystem.js';
+import { Git } from './Git.js';
+import { Process } from './Process.js';
+import { LspLanguageId, LspServer } from './LspServer.js';
+import { ComputerUse } from './ComputerUse.js';
+import { AxiosInstance } from 'axios';
+import { CodeInterpreter } from './CodeInterpreter.js';
+/**
+ * Represents a Daytona Sandbox.
+ *
+ * @property {FileSystem} fs - File system operations interface
+ * @property {Git} git - Git operations interface
+ * @property {Process} process - Process execution interface
+ * @property {CodeInterpreter} codeInterpreter - Stateful interpreter interface for executing code.
+ *   Currently supports only Python. For other languages, use the `process.codeRun` method.
+ * @property {ComputerUse} computerUse - Computer use operations interface for desktop automation
+ * @property {string} id - Unique identifier for the Sandbox
+ * @property {string} organizationId - Organization ID of the Sandbox
+ * @property {string} [snapshot] - Daytona snapshot used to create the Sandbox
+ * @property {string} user - OS user running in the Sandbox
+ * @property {Record<string, string>} env - Environment variables set in the Sandbox
+ * @property {Record<string, string>} labels - Custom labels attached to the Sandbox
+ * @property {boolean} public - Whether the Sandbox is publicly accessible
+ * @property {string} target - Target location of the runner where the Sandbox runs
+ * @property {number} cpu - Number of CPUs allocated to the Sandbox
+ * @property {number} gpu - Number of GPUs allocated to the Sandbox
+ * @property {number} memory - Amount of memory allocated to the Sandbox in GiB
+ * @property {number} disk - Amount of disk space allocated to the Sandbox in GiB
+ * @property {SandboxState} state - Current state of the Sandbox (e.g., "started", "stopped")
+ * @property {string} [errorReason] - Error message if Sandbox is in error state
+ * @property {boolean} [recoverable] - Whether the Sandbox error is recoverable.
+ * @property {SandboxBackupStateEnum} [backupState] - Current state of Sandbox backup
+ * @property {string} [backupCreatedAt] - When the backup was created
+ * @property {number} [autoStopInterval] - Auto-stop interval in minutes
+ * @property {number} [autoArchiveInterval] - Auto-archive interval in minutes
+ * @property {number} [autoDeleteInterval] - Auto-delete interval in minutes
+ * @property {Array<SandboxVolume>} [volumes] - Volumes attached to the Sandbox
+ * @property {BuildInfo} [buildInfo] - Build information for the Sandbox if it was created from dynamic build
+ * @property {string} [createdAt] - When the Sandbox was created
+ * @property {string} [updatedAt] - When the Sandbox was last updated
+ * @property {string} [lastActivityAt] - When the Sandbox last had activity
+ * @property {boolean} networkBlockAll - Whether to block all network access for the Sandbox
+ * @property {string} [networkAllowList] - Comma-separated list of allowed CIDR network addresses for the Sandbox
+ *
+ * @class
+ */
+export declare class Sandbox implements SandboxDto {
+    private readonly clientConfig;
+    private readonly axiosInstance;
+    private readonly sandboxApi;
+    readonly fs: FileSystem;
+    readonly git: Git;
+    readonly process: Process;
+    readonly computerUse: ComputerUse;
+    readonly codeInterpreter: CodeInterpreter;
+    id: string;
+    name: string;
+    organizationId: string;
+    snapshot?: string;
+    user: string;
+    env: Record<string, string>;
+    labels: Record<string, string>;
+    public: boolean;
+    target: string;
+    cpu: number;
+    gpu: number;
+    memory: number;
+    disk: number;
+    state?: SandboxState;
+    errorReason?: string;
+    recoverable?: boolean;
+    backupState?: SandboxBackupStateEnum;
+    backupCreatedAt?: string;
+    autoStopInterval?: number;
+    autoArchiveInterval?: number;
+    autoDeleteInterval?: number;
+    volumes?: Array<SandboxVolume>;
+    buildInfo?: BuildInfo;
+    createdAt?: string;
+    updatedAt?: string;
+    lastActivityAt?: string;
+    networkBlockAll: boolean;
+    networkAllowList?: string;
+    toolboxProxyUrl: string;
+    private infoApi;
+    /**
+     * Creates a new Sandbox instance
+     *
+     * @param {SandboxDto} sandboxDto - The API Sandbox instance
+     */
+    constructor(sandboxDto: SandboxDto, clientConfig: Configuration, axiosInstance: AxiosInstance, sandboxApi: SandboxApi);
+    /**
+     * 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}`);
+     */
+    getUserHomeDir(): Promise<string | undefined>;
+    /**
+     * @deprecated Use `getUserHomeDir` instead. This method will be removed in a future version.
+     */
+    getUserRootDir(): Promise<string | undefined>;
+    /**
+     * 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}`);
+     */
+    getWorkDir(): Promise<string | undefined>;
+    /**
+     * 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');
+     */
+    createLspServer(languageId: LspLanguageId | string, pathToProject: string): Promise<LspServer>;
+    /**
+     * 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'
+     * });
+     */
+    setLabels(labels: Record<string, string>): Promise<Record<string, string>>;
+    /**
+     * 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');
+     */
+    start(timeout?: number): Promise<void>;
+    /**
+     * 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');
+     */
+    recover(timeout?: number): Promise<void>;
+    /**
+     * 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');
+     */
+    stop(timeout?: number, force?: boolean): Promise<void>;
+    /**
+     * 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}`);
+     */
+    _experimental_fork(params?: {
+        name?: string;
+    }, timeout?: number): Promise<Sandbox>;
+    /**
+     * 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');
+     */
+    _experimental_createSnapshot(name: string, timeout?: number): Promise<void>;
+    private waitForSnapshotComplete;
+    /**
+     * Deletes the Sandbox.
+     * @returns {Promise<void>}
+     */
+    delete(timeout?: number): Promise<void>;
+    /**
+     * 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.
+     */
+    waitUntilStarted(timeout?: number): Promise<void>;
+    /**
+     * 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.
+     */
+    waitUntilStopped(timeout?: number): Promise<void>;
+    /**
+     * 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`);
+     */
+    refreshData(): Promise<void>;
+    /**
+     * 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();
+     */
+    refreshActivity(): Promise<void>;
+    /**
+     * 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);
+     */
+    setAutostopInterval(interval: number): Promise<void>;
+    /**
+     * 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);
+     */
+    setAutoArchiveInterval(interval: number): Promise<void>;
+    /**
+     * 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);
+     */
+    setAutoDeleteInterval(interval: number): Promise<void>;
+    /**
+     * 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 });
+     */
+    updateNetworkSettings(settings: UpdateSandboxNetworkSettings): Promise<void>;
+    /**
+     * 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}`);
+     */
+    getPreviewLink(port: number): Promise<PortPreviewUrl>;
+    /**
+     * 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.
+     */
+    getSignedPreviewUrl(port: number, expiresInSeconds?: number): Promise<SignedPortPreviewUrl>;
+    /**
+     * 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>}
+     */
+    expireSignedPreviewUrl(port: number, token: string): Promise<void>;
+    /**
+     * 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.
+     */
+    archive(): Promise<void>;
+    /**
+     * 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 });
+     */
+    resize(resources: Resources, timeout?: number): Promise<void>;
+    /**
+     * 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.
+     */
+    waitForResizeComplete(timeout?: number): Promise<void>;
+    /**
+     * 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.
+     */
+    createSshAccess(expiresInMinutes?: number): Promise<SshAccessDto>;
+    /**
+     * Revokes an SSH access token for the sandbox.
+     *
+     * @param {string} token - The token to revoke.
+     * @returns {Promise<void>}
+     */
+    revokeSshAccess(token: string): Promise<void>;
+    /**
+     * Validates an SSH access token for the sandbox.
+     *
+     * @param {string} token - The token to validate.
+     * @returns {Promise<SshAccessValidationDto>} The SSH access validation result.
+     */
+    validateSshAccess(token: string): Promise<SshAccessValidationDto>;
+    /**
+     * Assigns the API sandbox data to the Sandbox object.
+     *
+     * @param {SandboxDto} sandboxDto - The API sandbox instance to assign data from
+     * @returns {void}
+     */
+    private processSandboxDto;
+    /**
+     * 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>}
+     */
+    private refreshDataSafe;
+}
+export interface PaginatedSandboxes extends Omit<PaginatedSandboxesDto, 'items'> {
+    items: Sandbox[];
+}
+//# sourceMappingURL=Sandbox.d.ts.map

package/esm/Sandbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sandbox.d.ts","sourceRoot":"","sources":["../../../../../libs/sdk-typescript/src/Sandbox.ts"],"names":[],"mappings":"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"}