computesdk 2.0.0 → 2.0.2

package/dist/index.d.mts

@@ -1,41 +1,61 @@
 /**
- * ComputeSDK Types
+ * Universal Sandbox Interface
  *
- * This file contains all the type definitions for the ComputeSDK.
+ * The canonical interface for all ComputeSDK sandboxes.
+ *
+ * Core methods (required):
+ * - runCode, runCommand, getInfo, getUrl, destroy, filesystem
+ *
+ * Advanced features (optional):
+ * - terminal, server, watcher, auth, env, etc.
+ *
+ * Providers can implement as much or as little as makes sense for their platform.
+ * The gateway Sandbox class implements the full specification.
+ *
+ * **Note on naming:** This interface is named "Sandbox" in this file for clarity,
+ * but is exported as "SandboxInterface" from the main computesdk package to avoid
+ * collision with the gateway Sandbox class. The rename happens at export time in
+ * src/index.ts. Providers using @computesdk/provider will only see "SandboxInterface".
+ *
+ * @example Minimal implementation
+ * ```typescript
+ * class MinimalSandbox implements Pick<Sandbox, 'sandboxId' | 'provider' | 'runCode' | 'runCommand' | 'getInfo' | 'getUrl' | 'destroy' | 'filesystem'> {
+ *   // Just implement core methods
+ * }
+ * ```
+ *
+ * @example Full implementation
+ * ```typescript
+ * class FullSandbox implements Sandbox {
+ *   // Implement everything - core + advanced features
+ * }
+ * ```
  */
 /**
  * Supported runtime environments
  */
-type Runtime = 'node' | 'python';
-/**
- * Supported provider types
- */
-type ProviderType = 'e2b' | 'vercel' | 'daytona' | 'auto';
+type Runtime = 'node' | 'python' | 'deno' | 'bun';
 /**
- * Sandbox status types
+ * Code execution result
  */
-type SandboxStatus = 'running' | 'stopped' | 'error';
+interface CodeResult$1 {
+    output: string;
+    exitCode: number;
+    language: string;
+}
 /**
- * Result of code execution
+ * Command execution result
  */
-interface ExecutionResult {
-    /** Standard output from the execution */
+interface CommandResult$1 {
     stdout: string;
-    /** Standard error from the execution */
     stderr: string;
-    /** Exit code from the execution */
     exitCode: number;
-    /** Time taken for execution in milliseconds */
-    executionTime: number;
-    /** ID of the sandbox where the code was executed */
-    sandboxId: string;
-    /** Provider that executed the code */
-    provider: string;
+    durationMs: number;
 }
 /**
- * Information about a sandbox
+ * Sandbox information
  */
-interface SandboxInfo {
+interface SandboxInfo$1 {
     /** Unique identifier for the sandbox */
     id: string;
     /** Provider hosting the sandbox */
@@ -43,7 +63,7 @@ interface SandboxInfo {
     /** Runtime environment in the sandbox */
     runtime: Runtime;
     /** Current status of the sandbox */
-    status: SandboxStatus;
+    status: 'running' | 'stopped' | 'error';
     /** When the sandbox was created */
     createdAt: Date;
     /** Execution timeout in milliseconds */
@@ -52,665 +72,4125 @@ interface SandboxInfo {
     metadata?: Record<string, any>;
 }
 /**
- * Configuration for container-based providers
- */
-interface ContainerConfig {
-    /** Docker image to use */
-    image: string;
-    /** Command to run in the container */
-    command?: string[];
-    /** Environment variables for the container */
-    env?: Record<string, string>;
-    /** Ports to expose from the container */
-    ports?: number[];
-    /** Working directory in the container */
-    workdir?: string;
-}
-/**
- * Configuration for creating a compute sandbox
- */
-interface SandboxConfig {
-    /** Provider to use for execution */
-    provider?: ProviderType;
-    /** Runtime environment to use */
-    runtime?: Runtime;
-    /** Container configuration if using container-based provider */
-    container?: string | ContainerConfig;
-    /** Execution timeout in milliseconds */
-    timeout?: number;
-}
-/**
- * File system entry information
+ * File entry from directory listing
  */
 interface FileEntry {
-    /** File/directory name */
     name: string;
-    /** Full path to the entry */
-    path: string;
-    /** Whether this is a directory */
-    isDirectory: boolean;
-    /** File size in bytes (0 for directories) */
-    size: number;
-    /** Last modified timestamp */
-    lastModified: Date;
+    type: 'file' | 'directory';
+    size?: number;
+    modified?: Date;
 }
 /**
- * Basic terminal session information
+ * Options for running a command
  */
-interface TerminalSession {
-    /** Terminal process ID */
-    pid: number;
-    /** Terminal command */
-    command: string;
-    /** Terminal status */
-    status: 'running' | 'exited';
-    /** Exit code (if exited) */
-    exitCode?: number;
+interface RunCommandOptions {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+    background?: boolean;
 }
 /**
- * File system interface for sandbox operations
+ * Filesystem operations interface
  */
 interface SandboxFileSystem {
-    /** Read file contents */
     readFile(path: string): Promise<string>;
-    /** Write file contents */
     writeFile(path: string, content: string): Promise<void>;
-    /** Create directory */
-    mkdir(path: string): Promise<void>;
-    /** List directory contents */
     readdir(path: string): Promise<FileEntry[]>;
-    /** Check if file/directory exists */
+    mkdir(path: string): Promise<void>;
     exists(path: string): Promise<boolean>;
-    /** Remove file or directory */
     remove(path: string): Promise<void>;
 }
 /**
- * Terminal operations interface for managing terminal sessions in a sandbox
- */
-interface SandboxTerminal {
-    /** Create a new interactive terminal session */
-    create(options?: TerminalCreateOptions): Promise<InteractiveTerminalSession>;
-    /** List active terminal sessions */
-    list(): Promise<InteractiveTerminalSession[]>;
-}
-/**
- * Base provider specification that all providers must implement
+ * Options for creating a sandbox
+ *
+ * Providers can extend this with additional properties specific to their implementation
  */
-interface BaseComputeSpecification {
-    /** Version of the specification */
-    specificationVersion: 'v1';
-    /** Provider identifier */
-    provider: string;
-    /** Sandbox identifier */
-    sandboxId: string;
-    /** Execute code in the sandbox */
-    doExecute(code: string, runtime?: Runtime): Promise<ExecutionResult>;
-    /** Execute code in a runtime environment */
-    runCode(code: string, runtime?: Runtime): Promise<ExecutionResult>;
-    /** Execute shell commands */
-    runCommand(command: string, args?: string[]): Promise<ExecutionResult>;
-    /** Kill the sandbox */
-    doKill(): Promise<void>;
-    /** Get information about the sandbox */
-    doGetInfo(): Promise<SandboxInfo>;
+interface CreateSandboxOptions$1 {
+    runtime?: Runtime;
+    timeout?: number;
+    templateId?: string;
+    metadata?: Record<string, any>;
+    envs?: Record<string, string>;
+    name?: string;
+    namespace?: string;
+    directory?: string;
+    overlays?: SandboxOverlayConfig[];
+    servers?: SandboxServerConfig[];
+    [key: string]: any;
 }
-/**
- * Provider specification with filesystem support
- */
-interface FilesystemComputeSpecification extends BaseComputeSpecification {
-    /** File system operations */
-    readonly filesystem: SandboxFileSystem;
+interface SandboxOverlayConfig {
+    source: string;
+    target: string;
+    ignore?: string[];
+    strategy?: 'copy' | 'smart';
 }
+type SandboxRestartPolicy = 'never' | 'on-failure' | 'always';
 /**
- * Provider specification with terminal support
+ * Health check configuration for servers
  */
-interface TerminalComputeSpecification extends BaseComputeSpecification {
-    /** Terminal operations */
-    readonly terminal: SandboxTerminal;
+interface SandboxHealthCheckConfig {
+    /** Path to poll for health checks (default: "/") */
+    path?: string;
+    /** Interval between health checks in milliseconds (default: 2000) */
+    interval_ms?: number;
+    /** Timeout for each health check request in milliseconds (default: 1500) */
+    timeout_ms?: number;
+    /** Delay before starting health checks after port detection in milliseconds (default: 5000) */
+    delay_ms?: number;
 }
-/**
- * Provider specification with full filesystem and terminal support
- */
-interface FullComputeSpecification extends FilesystemComputeSpecification, TerminalComputeSpecification {
+interface SandboxServerConfig {
+    slug: string;
+    start: string;
+    install?: string;
+    path?: string;
+    port?: number;
+    strict_port?: boolean;
+    autostart?: boolean;
+    env_file?: string;
+    environment?: Record<string, string>;
+    restart_policy?: SandboxRestartPolicy;
+    max_restarts?: number;
+    restart_delay_ms?: number;
+    stop_timeout_ms?: number;
+    depends_on?: string[];
+    overlay?: SandboxOverlayConfig;
+    overlays?: SandboxOverlayConfig[];
+    health_check?: SandboxHealthCheckConfig;
 }
 /**
- * Union type for all possible provider specifications
- */
-type ComputeSpecification = BaseComputeSpecification | FilesystemComputeSpecification | TerminalComputeSpecification | FullComputeSpecification;
-/**
- * Base compute sandbox interface that all providers expose
+ * Universal Sandbox Interface
+ *
+ * All ComputeSDK sandboxes implement this interface.
+ * Core methods are required, advanced features are optional.
+ *
+ * Note: Implementations may use slightly different types for return values
+ * as long as they are structurally compatible. For example, getInfo() might
+ * return additional fields beyond the base SandboxInfo.
  */
-interface BaseComputeSandbox {
-    /** Provider identifier */
-    provider: string;
-    /** Sandbox identifier */
-    sandboxId: string;
+interface Sandbox$1 {
+    /** Unique identifier for the sandbox */
+    readonly sandboxId: string;
+    /** Provider name (e2b, railway, modal, gateway, etc.) */
+    readonly provider: string;
     /** Execute code in the sandbox */
-    execute(code: string, runtime?: Runtime): Promise<ExecutionResult>;
-    /** Execute code in a runtime environment */
-    runCode(code: string, runtime?: Runtime): Promise<ExecutionResult>;
-    /** Execute shell commands */
-    runCommand(command: string, args?: string[]): Promise<ExecutionResult>;
-    /** Kill the sandbox */
-    kill(): Promise<void>;
+    runCode(code: string, runtime?: Runtime): Promise<CodeResult$1>;
+    /**
+     * Execute shell command
+     *
+     * Send raw command string to the sandbox - no preprocessing.
+     * The provider/server handles shell invocation and execution details.
+     */
+    runCommand(command: string, options?: RunCommandOptions): Promise<CommandResult$1>;
     /** Get information about the sandbox */
-    getInfo(): Promise<SandboxInfo>;
-}
-/**
- * Compute sandbox with filesystem support
- */
-interface FilesystemComputeSandbox extends BaseComputeSandbox {
+    getInfo(): Promise<SandboxInfo$1>;
+    /** Get URL for accessing the sandbox on a specific port */
+    getUrl(options: {
+        port: number;
+        protocol?: string;
+    }): Promise<string>;
+    /** Destroy the sandbox and clean up resources */
+    destroy(): Promise<void>;
     /** File system operations */
     readonly filesystem: SandboxFileSystem;
+    /**
+     * Terminal management (interactive PTY and exec modes)
+     * Available in: gateway, e2b (potentially)
+     */
+    readonly terminal?: any;
+    /**
+     * Code and command execution namespace
+     * Available in: gateway
+     */
+    readonly run?: any;
+    /**
+     * Managed server operations
+     * Available in: gateway
+     */
+    readonly server?: any;
+    /**
+     * File watcher with real-time change events
+     * Available in: gateway
+     */
+    readonly watcher?: any;
+    /**
+     * Session token management
+     * Available in: gateway
+     */
+    readonly sessionToken?: any;
+    /**
+     * Magic link authentication
+     * Available in: gateway
+     */
+    readonly magicLink?: any;
+    /**
+     * Signal service for port/error events
+     * Available in: gateway
+     */
+    readonly signal?: any;
+    /**
+     * File operations namespace
+     * Available in: gateway
+     */
+    readonly file?: any;
+    /**
+     * Environment variable management
+     * Available in: gateway
+     */
+    readonly env?: any;
+    /**
+     * Authentication operations
+     * Available in: gateway
+     */
+    readonly auth?: any;
+    /**
+     * Child sandbox management
+     * Available in: gateway
+     */
+    readonly child?: any;
 }
+
 /**
- * Compute sandbox with terminal support
+ * Terminal created notification
  */
-interface TerminalComputeSandbox extends BaseComputeSandbox {
-    /** Terminal operations */
-    readonly terminal: SandboxTerminal;
+interface TerminalCreatedMessage {
+    type: 'terminal:created';
+    channel: string;
+    data: {
+        id: string;
+        status: 'running' | 'stopped';
+    };
 }
 /**
- * Compute sandbox with full filesystem and terminal support
+ * Terminal output data
+ * Note: output field may be base64 encoded depending on encoding field
  */
-interface FullComputeSandbox extends FilesystemComputeSandbox, TerminalComputeSandbox {
+interface TerminalOutputMessage {
+    type: 'terminal:output';
+    channel: string;
+    data: {
+        output: string;
+        encoding?: 'raw' | 'base64';
+    };
 }
 /**
- * Union type for all possible compute sandbox types
+ * Terminal destroyed notification
  */
-type ComputeSandbox = BaseComputeSandbox | FilesystemComputeSandbox | TerminalComputeSandbox | FullComputeSandbox;
+interface TerminalDestroyedMessage {
+    type: 'terminal:destroyed';
+    channel: string;
+    data: {
+        id: string;
+    };
+}
 /**
- * Parameters for the executeSandbox function
+ * Terminal error notification
  */
-interface ExecuteSandboxParams {
-    /** Sandbox to execute in */
-    sandbox: ComputeSandbox;
-    /** Code to execute */
-    code: string;
-    /** Runtime to use */
-    runtime?: Runtime;
+interface TerminalErrorMessage {
+    type: 'terminal:error';
+    channel: string;
+    data: {
+        error: string;
+    };
 }
 /**
- * Provider registry configuration
+ * Command stdout streaming message (exec mode with stream: true)
  */
-interface ProviderRegistry {
-    /** Get a sandbox by ID */
-    sandbox(id: string): ComputeSandbox;
+interface CommandStdoutMessage {
+    type: 'command:stdout';
+    channel: string;
+    data: {
+        terminal_id: string;
+        cmd_id: string;
+        output: string;
+    };
 }
 /**
- * Provider factory function type for base providers
+ * Command stderr streaming message (exec mode with stream: true)
  */
-type BaseProviderFactory = (config?: any) => BaseComputeSandbox;
+interface CommandStderrMessage {
+    type: 'command:stderr';
+    channel: string;
+    data: {
+        terminal_id: string;
+        cmd_id: string;
+        output: string;
+    };
+}
 /**
- * Provider factory function type for filesystem providers
+ * Command exit message (exec mode with stream: true)
  */
-type FilesystemProviderFactory = (config?: any) => FilesystemComputeSandbox;
+interface CommandExitMessage {
+    type: 'command:exit';
+    channel: string;
+    data: {
+        terminal_id: string;
+        cmd_id: string;
+        exit_code: number;
+    };
+}
 /**
- * Provider factory function type for terminal providers
+ * File watcher created notification
  */
-type TerminalProviderFactory = (config?: any) => TerminalComputeSandbox;
+interface WatcherCreatedMessage {
+    type: 'watcher:created';
+    channel: string;
+    data: {
+        id: string;
+        path: string;
+    };
+}
 /**
- * Provider factory function type for full-featured providers
+ * File change event
+ * Note: content field may be base64 encoded depending on encoding field
  */
-type FullProviderFactory = (config?: any) => FullComputeSandbox;
+interface FileChangedMessage {
+    type: 'file:changed';
+    channel: string;
+    data: {
+        event: 'add' | 'change' | 'unlink' | 'addDir' | 'unlinkDir';
+        path: string;
+        content?: string;
+        encoding?: 'raw' | 'base64';
+    };
+}
 /**
- * Union type for all provider factory types
+ * File watcher destroyed notification
  */
-type ProviderFactory = BaseProviderFactory | FilesystemProviderFactory | TerminalProviderFactory | FullProviderFactory;
+interface WatcherDestroyedMessage {
+    type: 'watcher:destroyed';
+    channel: string;
+    data: {
+        id: string;
+    };
+}
 /**
- * Provider registry map type
+ * System signal event
  */
-type ProviderMap = Record<string, ProviderFactory>;
+interface SignalMessage {
+    type: 'signal';
+    channel: 'signals';
+    data: {
+        signal: 'port' | 'error' | 'server-ready';
+        port?: number;
+        url?: string;
+        message?: string;
+    };
+}
 /**
- * Terminal session with PTY (pseudo-terminal) support for interactive use
+ * Sandbox created notification
  */
-interface InteractiveTerminalSession extends TerminalSession {
-    /** Terminal columns */
-    cols: number;
-    /** Terminal rows */
-    rows: number;
-    /** Data stream handler */
-    onData?: (data: Uint8Array) => void;
-    /** Exit handler */
-    onExit?: (exitCode: number) => void;
-    /** Write data to this terminal session */
-    write(data: Uint8Array | string): Promise<void>;
-    /** Resize this terminal session */
-    resize(cols: number, rows: number): Promise<void>;
-    /** Kill this terminal session */
-    kill(): Promise<void>;
+interface SandboxCreatedMessage {
+    type: 'sandbox.created';
+    data: {
+        subdomain: string;
+        url: string;
+    };
 }
 /**
- * Terminal creation options
+ * Sandbox deleted notification
  */
-interface TerminalCreateOptions {
-    /** Command to run (defaults to shell) */
-    command?: string;
-    /** Terminal columns */
-    cols?: number;
-    /** Terminal rows */
-    rows?: number;
-    /** Environment variables */
-    env?: Record<string, string>;
+interface SandboxDeletedMessage {
+    type: 'sandbox.deleted';
+    data: {
+        subdomain: string;
+    };
 }
-
+type WebSocketConstructor$1 = new (url: string) => WebSocket;
+interface WebSocketManagerConfig {
+    /** WebSocket URL (will be generated from client config if not provided) */
+    url: string;
+    /** WebSocket implementation */
+    WebSocket: WebSocketConstructor$1;
+    /** Enable automatic reconnection on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Reconnection delay in milliseconds (default: 1000) */
+    reconnectDelay?: number;
+    /** Maximum reconnection attempts (default: 5, 0 = infinite) */
+    maxReconnectAttempts?: number;
+    /** Enable debug logging (default: false) */
+    debug?: boolean;
+    /** WebSocket protocol: 'binary' (default, recommended) or 'json' (for debugging) */
+    protocol?: 'json' | 'binary';
+}
+type MessageHandler<T = any> = (message: T) => void;
+type ErrorHandler = (error: Event) => void;
+type ConnectionHandler = () => void;
 /**
- * ComputeSDK Error Handling
+ * WebSocket Manager for handling real-time communication
  *
- * This file contains standardized error classes for the ComputeSDK.
- */
-/**
- * Base error class for all ComputeSDK errors
+ * @example
+ * ```typescript
+ * import { ComputeClient } from '@computesdk/client'
+ *
+ * const client = new ComputeClient({ sandboxUrl: 'https://sandbox-123.sandbox.computesdk.com' });
+ * await client.generateToken();
+ *
+ * // Create WebSocket manager
+ * const ws = client.createWebSocketManager();
+ *
+ * // Listen for connection
+ * ws.on('open', () => {
+ *   console.log('Connected!');
+ * });
+ *
+ * // Subscribe to terminal output
+ * ws.subscribe('terminal:term_abc123');
+ * ws.on('terminal:output', (msg) => {
+ *   console.log('Terminal output:', msg.data.output);
+ * });
+ *
+ * // Send terminal input
+ * ws.sendTerminalInput('term_abc123', 'ls -la\n');
+ *
+ * // Subscribe to file changes
+ * ws.subscribe('watcher:watcher_xyz789');
+ * ws.on('file:changed', (msg) => {
+ *   console.log('File changed:', msg.data.path, msg.data.event);
+ * });
+ *
+ * // Subscribe to signals
+ * ws.subscribe('signals');
+ * ws.on('signal', (msg) => {
+ *   console.log('Signal:', msg.data);
+ * });
+ * ```
  */
-declare abstract class ComputeError extends Error {
-    /** Error code identifier */
-    abstract readonly code: string;
-    /** Whether the operation can be retried */
-    abstract readonly isRetryable: boolean;
-    /** Provider where the error occurred */
-    readonly provider: string;
-    /** Sandbox ID where the error occurred */
-    readonly sandboxId?: string;
+declare class WebSocketManager {
+    private config;
+    private ws;
+    private eventHandlers;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private subscribedChannels;
+    private isManualClose;
+    constructor(config: WebSocketManagerConfig);
     /**
-     * Create a new ComputeError
-     *
-     * @param message Error message
-     * @param provider Provider identifier
-     * @param sandboxId Optional sandbox identifier
+     * Connect to WebSocket server
      */
-    constructor(message: string, provider: string, sandboxId?: string);
-}
-/**
- * Error thrown when code execution fails
- */
-declare class ExecutionError extends ComputeError {
-    /** Error code */
-    readonly code = "EXECUTION_ERROR";
-    /** Execution errors are generally not retryable */
-    readonly isRetryable = false;
-    /** Exit code from the failed execution */
-    readonly exitCode: number;
+    connect(): Promise<void>;
     /**
-     * Create a new ExecutionError
-     *
-     * @param message Error message
-     * @param provider Provider identifier
-     * @param exitCode Exit code from the execution
-     * @param sandboxId Optional sandbox identifier
+     * Disconnect from WebSocket server
      */
-    constructor(message: string, provider: string, exitCode: number, sandboxId?: string);
-}
-/**
- * Error thrown when code execution times out
- */
-declare class TimeoutError extends ComputeError {
-    /** Error code */
-    readonly code = "TIMEOUT_ERROR";
-    /** Timeout errors may be retryable with a longer timeout */
-    readonly isRetryable = true;
-    /** Timeout duration in milliseconds */
-    readonly timeoutMs: number;
+    disconnect(): void;
     /**
-     * Create a new TimeoutError
-     *
-     * @param message Error message
-     * @param provider Provider identifier
-     * @param timeoutMs Timeout duration in milliseconds
-     * @param sandboxId Optional sandbox identifier
+     * Check if WebSocket is connected
      */
-    constructor(message: string, provider: string, timeoutMs: number, sandboxId?: string);
-}
-/**
- * Error thrown when provider-specific operations fail
- */
-declare class ProviderError extends ComputeError {
-    /** Error code */
-    readonly code = "PROVIDER_ERROR";
-    /** Provider errors may be retryable */
-    readonly isRetryable = true;
-    /** Original error from the provider */
-    readonly originalError?: Error;
+    isConnected(): boolean;
     /**
-     * Create a new ProviderError
-     *
-     * @param message Error message
-     * @param provider Provider identifier
-     * @param originalError Optional original error from the provider
-     * @param sandboxId Optional sandbox identifier
+     * Attempt to reconnect to WebSocket server
      */
-    constructor(message: string, provider: string, originalError?: Error, sandboxId?: string);
-}
-/**
- * Error thrown when configuration is invalid
- */
-declare class ConfigurationError extends ComputeError {
-    /** Error code */
-    readonly code = "CONFIGURATION_ERROR";
-    /** Configuration errors are not retryable without changes */
-    readonly isRetryable = false;
+    private attemptReconnect;
     /**
-     * Create a new ConfigurationError
-     *
-     * @param message Error message
-     * @param provider Provider identifier
-     * @param sandboxId Optional sandbox identifier
+     * Subscribe to a channel
+     * @param channel - Channel name (e.g., 'terminal:term_abc123', 'watcher:watcher_xyz789', 'signals')
      */
-    constructor(message: string, provider: string, sandboxId?: string);
-}
-/**
- * Error thrown when authentication fails
- */
-declare class AuthenticationError extends ComputeError {
-    /** Error code */
-    readonly code = "AUTHENTICATION_ERROR";
-    /** Authentication errors are not retryable without new credentials */
-    readonly isRetryable = false;
+    subscribe(channel: string): void;
     /**
-     * Create a new AuthenticationError
-     *
-     * @param message Error message
-     * @param provider Provider identifier
-     * @param sandboxId Optional sandbox identifier
+     * Unsubscribe from a channel
      */
-    constructor(message: string, provider: string, sandboxId?: string);
-}
-/**
- * Error thrown when the provider is not available
- */
-declare class ProviderUnavailableError extends ComputeError {
-    /** Error code */
-    readonly code = "PROVIDER_UNAVAILABLE";
-    /** Provider unavailability may be temporary */
-    readonly isRetryable = true;
+    unsubscribe(channel: string): void;
     /**
-     * Create a new ProviderUnavailableError
-     *
-     * @param message Error message
-     * @param provider Provider identifier
-     * @param sandboxId Optional sandbox identifier
+     * Get list of subscribed channels
+     */
+    getSubscribedChannels(): string[];
+    /**
+     * Send raw message to server
+     */
+    private sendRaw;
+    /**
+     * Send input to a terminal (sent as-is, not encoded)
+     */
+    sendTerminalInput(terminalId: string, input: string): void;
+    /**
+     * Resize terminal window
+     */
+    resizeTerminal(terminalId: string, cols: number, rows: number): void;
+    /**
+     * Start a pending streaming command
+     * Used in two-phase streaming flow: HTTP request creates pending command,
+     * then this signal triggers execution after client has subscribed.
+     */
+    startCommand(cmdId: string): void;
+    /**
+     * Register event handler
      */
-    constructor(message: string, provider: string, sandboxId?: string);
+    on(event: 'open', handler: ConnectionHandler): void;
+    on(event: 'close', handler: ConnectionHandler): void;
+    on(event: 'error', handler: ErrorHandler): void;
+    on(event: 'reconnect-failed', handler: ConnectionHandler): void;
+    on(event: 'terminal:created', handler: MessageHandler<TerminalCreatedMessage>): void;
+    on(event: 'terminal:output', handler: MessageHandler<TerminalOutputMessage>): void;
+    on(event: 'terminal:destroyed', handler: MessageHandler<TerminalDestroyedMessage>): void;
+    on(event: 'terminal:error', handler: MessageHandler<TerminalErrorMessage>): void;
+    on(event: 'command:stdout', handler: MessageHandler<CommandStdoutMessage>): void;
+    on(event: 'command:stderr', handler: MessageHandler<CommandStderrMessage>): void;
+    on(event: 'command:exit', handler: MessageHandler<CommandExitMessage>): void;
+    on(event: 'watcher:created', handler: MessageHandler<WatcherCreatedMessage>): void;
+    on(event: 'file:changed', handler: MessageHandler<FileChangedMessage>): void;
+    on(event: 'watcher:destroyed', handler: MessageHandler<WatcherDestroyedMessage>): void;
+    on(event: 'signal', handler: MessageHandler<SignalMessage>): void;
+    on(event: 'sandbox.created', handler: MessageHandler<SandboxCreatedMessage>): void;
+    on(event: 'sandbox.deleted', handler: MessageHandler<SandboxDeletedMessage>): void;
+    /**
+     * Unregister event handler
+     */
+    off(event: string, handler: MessageHandler): void;
+    /**
+     * Unregister all event handlers for an event
+     */
+    offAll(event: string): void;
+    /**
+     * Emit event to registered handlers
+     */
+    private emit;
+    /**
+     * Handle incoming message
+     */
+    private handleMessage;
+    /**
+     * Log debug message if debug mode is enabled
+     */
+    private log;
+    /**
+     * Get current connection state
+     */
+    getState(): 'connecting' | 'open' | 'closing' | 'closed';
+    /**
+     * Get reconnection attempt count
+     */
+    getReconnectAttempts(): number;
 }
 
 /**
- * ComputeSDK Configuration Management
- *
- * This file manages configuration and provider selection logic.
+ * Command - Represents a command execution in a terminal
  */
 
-declare global {
-    var DurableObject: any;
-    var WebSocketPair: any;
-}
-declare const DEFAULT_TIMEOUT = 300000;
 /**
- * Environment variable names for provider API keys
+ * Command execution result with wait capability
  */
-declare const ENV_KEYS: {
-    E2B: string;
-    VERCEL: string;
-    DAYTONA: string;
-};
+declare class Command {
+    readonly id: string;
+    readonly terminalId: string;
+    readonly command: string;
+    private _status;
+    private _stdout;
+    private _stderr;
+    private _exitCode?;
+    private _durationMs?;
+    private _startedAt;
+    private _finishedAt?;
+    private waitHandler?;
+    private retrieveHandler?;
+    constructor(data: {
+        cmdId: string;
+        terminalId: string;
+        command: string;
+        status: 'running' | 'completed' | 'failed';
+        stdout: string;
+        stderr: string;
+        exitCode?: number;
+        durationMs?: number;
+        startedAt: string;
+        finishedAt?: string;
+    });
+    get status(): 'running' | 'completed' | 'failed';
+    get stdout(): string;
+    get stderr(): string;
+    get exitCode(): number | undefined;
+    get durationMs(): number | undefined;
+    get startedAt(): string;
+    get finishedAt(): string | undefined;
+    /**
+     * Set the wait handler (called by TerminalCommands)
+     * @internal
+     */
+    setWaitHandler(handler: (timeout?: number) => Promise<CommandDetailsResponse>): void;
+    /**
+     * Set the retrieve handler (called by TerminalCommands)
+     * @internal
+     */
+    setRetrieveHandler(handler: () => Promise<CommandDetailsResponse>): void;
+    /**
+     * Wait for the command to complete
+     * @param timeout - Optional timeout in seconds (0 = no timeout)
+     * @returns This command with updated status
+     */
+    wait(timeout?: number): Promise<this>;
+    /**
+     * Refresh the command status from the server
+     * @returns This command with updated status
+     */
+    refresh(): Promise<this>;
+    /**
+     * Update internal state from API response
+     */
+    private updateFromResponse;
+}
+
 /**
- * Detect available providers based on environment variables
- *
- * @returns Array of available provider types
+ * TerminalCommand - Resource namespace for terminal commands
  */
-declare function detectAvailableProviders(): ProviderType[];
+
 /**
- * Auto-select the best provider based on available API keys
+ * Command resource namespace for a terminal
  *
- * @returns Selected provider type or undefined if none available
- */
-declare function autoSelectProvider(): ProviderType | undefined;
-/**
- * Validate and normalize container configuration
+ * @example
+ * ```typescript
+ * const terminal = await sandbox.terminal.create({ pty: false });
  *
- * @param container Container configuration or image string
- * @returns Normalized container configuration
- */
-declare function normalizeContainerConfig(container: string | ContainerConfig | undefined): ContainerConfig | undefined;
-/**
- * Get the appropriate runtime based on provider and configuration
+ * // Run a command
+ * const cmd = await terminal.command.run('npm test');
+ * console.log(cmd.stdout);
  *
- * @param provider Provider type
- * @param runtime Optional runtime preference
- * @returns Selected runtime
- */
-declare function getDefaultRuntime(provider: ProviderType, runtime?: Runtime): Runtime;
-/**
- * Validate API key for selected provider
+ * // Run in background and wait
+ * const cmd = await terminal.command.run('npm install', { background: true });
+ * await cmd.wait();
+ * console.log(cmd.exitCode);
  *
- * @param provider Provider type
- * @throws AuthenticationError if API key is missing
- */
-declare function validateProviderApiKey(provider: ProviderType): void;
-/**
- * Normalize and validate sandbox configuration
+ * // List commands
+ * const commands = await terminal.command.list();
  *
- * @param config User-provided configuration
- * @returns Normalized configuration with defaults applied
+ * // Retrieve a specific command
+ * const cmd = await terminal.command.retrieve(cmdId);
+ * ```
  */
-declare function normalizeSandboxConfig(config?: Partial<SandboxConfig>): SandboxConfig;
+declare class TerminalCommand {
+    private terminalId;
+    private runHandler;
+    private listHandler;
+    private retrieveHandler;
+    private waitHandler;
+    constructor(terminalId: string, handlers: {
+        run: (command: string, background?: boolean) => Promise<CommandExecutionResponse>;
+        list: () => Promise<CommandsListResponse>;
+        retrieve: (cmdId: string) => Promise<CommandDetailsResponse>;
+        wait: (cmdId: string, timeout?: number) => Promise<CommandDetailsResponse>;
+    });
+    /**
+     * Run a command in the terminal
+     * @param command - The command to execute
+     * @param options - Execution options
+     * @param options.background - If true, returns immediately without waiting for completion
+     * @returns Command object with results or status
+     */
+    run(command: string, options?: {
+        background?: boolean;
+    }): Promise<Command>;
+    /**
+     * List all commands executed in this terminal
+     * @returns Array of Command objects
+     */
+    list(): Promise<Command[]>;
+    /**
+     * Retrieve a specific command by ID
+     * @param cmdId - The command ID
+     * @returns Command object with full details
+     */
+    retrieve(cmdId: string): Promise<Command>;
+}
 
 /**
- * Utility functions for ComputeSDK
+ * Terminal class for managing terminal sessions with WebSocket integration
  */
 
 /**
- * Execute code in a sandbox
- */
-declare function executeSandbox(params: ExecuteSandboxParams): Promise<ExecutionResult>;
-/**
- * Parameters for the runCode function
+ * Terminal event handlers
  */
-interface RunCodeParams {
-    /** Sandbox to execute in */
-    sandbox: ComputeSandbox;
-    /** Code to execute */
-    code: string;
-    /** Runtime to use */
-    runtime?: Runtime;
-}
-/**
- * Execute code in a runtime environment
- */
-declare function runCode(params: RunCodeParams): Promise<ExecutionResult>;
-/**
- * Parameters for the runCommand function
- */
-interface RunCommandParams {
-    /** Sandbox to execute in */
-    sandbox: ComputeSandbox;
-    /** Command to execute */
-    command: string;
-    /** Command arguments */
-    args?: string[];
-}
-/**
- * Execute shell commands
- */
-declare function runCommand(params: RunCommandParams): Promise<ExecutionResult>;
-/**
- * Options for retry function
- */
-interface RetryOptions {
-    /** Maximum number of attempts (default: 3) */
-    maxAttempts?: number;
-    /** Base delay in milliseconds (default: 1000) */
-    delay?: number;
-    /** Backoff multiplier (default: 2) */
-    backoff?: number;
-    /** Callback called on each retry attempt */
-    onRetry?: (error: Error, attempt: number) => void;
-}
-/**
- * Retry function with exponential backoff
- */
-declare function retry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
-
+type TerminalEventHandler = {
+    output: (data: string) => void;
+    error: (error: string) => void;
+    destroyed: () => void;
+};
 /**
- * ComputeSDK Provider Registry
+ * TerminalInstance - A connected terminal session with WebSocket support
  *
- * This file implements the provider registry for managing multiple providers.
- */
-
-/**
- * Create a provider registry for managing multiple providers
+ * This is the object returned by sandbox.terminal.create()
  *
- * @param providers Map of provider factories
- * @returns Provider registry instance
- */
-declare function createComputeRegistry(providers: ProviderMap): ProviderRegistry;
-
-/**
- * Base implementation of the ComputeSandbox interface
+ * @example
+ * ```typescript
+ * // PTY mode - Interactive shell
+ * const pty = await sandbox.terminal.create({ pty: true });
+ * pty.on('output', (data) => console.log(data));
+ * pty.write('ls -la\n');
+ * await pty.destroy();
+ *
+ * // Exec mode - Command tracking
+ * const exec = await sandbox.terminal.create({ pty: false });
+ * const cmd = await exec.command.run('npm test');
+ * console.log(cmd.exitCode);
  *
- * Provides common functionality and wraps provider-specific implementations.
+ * // Background execution with wait
+ * const cmd = await exec.command.run('npm install', { background: true });
+ * await cmd.wait();
+ * console.log(cmd.stdout);
+ * ```
  */
-declare abstract class BaseProvider implements BaseComputeSandbox, BaseComputeSpecification {
-    /** Specification version */
-    readonly specificationVersion = "v1";
-    /** Provider identifier */
-    readonly provider: string;
-    /** Sandbox identifier */
-    readonly sandboxId: string;
-    /** Execution timeout in milliseconds */
-    protected readonly timeout: number;
+declare class TerminalInstance {
+    private _id;
+    private _pty;
+    private _status;
+    private _channel;
+    private _ws;
+    private _encoding;
+    private _eventHandlers;
     /**
-     * Create a new base provider
-     *
-     * @param provider Provider identifier
-     * @param timeout Execution timeout in milliseconds
+     * Command namespace for exec mode terminals
      */
-    constructor(provider: string, timeout: number);
+    readonly command: TerminalCommand;
+    private _executeHandler?;
+    private _listCommandsHandler?;
+    private _retrieveCommandHandler?;
+    private _waitCommandHandler?;
+    private _destroyHandler?;
+    constructor(id: string, pty: boolean, status: 'running' | 'stopped' | 'active' | 'ready', channel: string | null, ws: WebSocketManager | null, encoding?: 'raw' | 'base64');
     /**
-     * Execute code in the sandbox
-     *
-     * @param code Code to execute
-     * @param runtime Optional runtime to use
-     * @returns Execution result
+     * Set up WebSocket event handlers (PTY mode only)
      */
-    execute(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    private setupWebSocketHandlers;
     /**
-     * Kill the sandbox
-     *
-     * @returns Promise that resolves when the sandbox is killed
+     * Terminal ID
      */
-    kill(): Promise<void>;
+    get id(): string;
     /**
-     * Get information about the sandbox
-     *
-     * @returns Sandbox information
+     * Get terminal ID (deprecated, use .id property)
+     * @deprecated Use .id property instead
      */
-    getInfo(): Promise<SandboxInfo>;
+    getId(): string;
     /**
-     * Execute code in a runtime environment
-     *
-     * @param code Code to execute
-     * @param runtime Optional runtime to use
-     * @returns Execution result
+     * Terminal status
      */
-    runCode(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    get status(): 'running' | 'stopped' | 'active' | 'ready';
     /**
-     * Execute shell commands
-     *
-     * @param command Command to execute
-     * @param args Command arguments
-     * @returns Execution result
+     * Get terminal status (deprecated, use .status property)
+     * @deprecated Use .status property instead
      */
-    runCommand(command: string, args?: string[]): Promise<ExecutionResult>;
+    getStatus(): 'running' | 'stopped' | 'active' | 'ready';
     /**
-     * Provider-specific implementation of code execution
-     *
-     * @param code Code to execute
-     * @param runtime Optional runtime to use
-     * @returns Execution result
+     * Terminal channel (null for exec mode)
      */
-    abstract doExecute(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    get channel(): string | null;
     /**
-     * Provider-specific implementation of sandbox termination
-     *
-     * @returns Promise that resolves when the sandbox is killed
+     * Get terminal channel (deprecated, use .channel property)
+     * @deprecated Use .channel property instead
      */
-    abstract doKill(): Promise<void>;
+    getChannel(): string | null;
     /**
-     * Provider-specific implementation of retrieving sandbox information
-     *
-     * @returns Sandbox information
+     * Whether this is a PTY terminal
      */
-    abstract doGetInfo(): Promise<SandboxInfo>;
+    get pty(): boolean;
     /**
-     * Provider-specific implementation of code execution (optional)
-     *
-     * @param code Code to execute
-     * @param runtime Optional runtime to use
-     * @returns Execution result
+     * Get terminal PTY mode (deprecated, use .pty property)
+     * @deprecated Use .pty property instead
      */
-    doRunCode?(code: string, runtime?: Runtime): Promise<ExecutionResult>;
+    isPTY(): boolean;
     /**
-     * Provider-specific implementation of command execution (optional)
-     *
-     * @param command Command to execute
-     * @param args Command arguments
-     * @returns Execution result
+     * Check if terminal is running
      */
-    doRunCommand?(command: string, args: string[]): Promise<ExecutionResult>;
-}
-/**
- * Helper class for implementing FileSystem with error handling
- */
-declare abstract class BaseFileSystem implements SandboxFileSystem {
-    protected provider: string;
-    protected sandboxId: string;
-    constructor(provider: string, sandboxId: string);
-    readFile(path: string): Promise<string>;
-    writeFile(path: string, content: string): Promise<void>;
-    mkdir(path: string): Promise<void>;
-    readdir(path: string): Promise<FileEntry[]>;
-    exists(path: string): Promise<boolean>;
-    remove(path: string): Promise<void>;
-    protected abstract doReadFile(path: string): Promise<string>;
-    protected abstract doWriteFile(path: string, content: string): Promise<void>;
-    protected abstract doMkdir(path: string): Promise<void>;
-    protected abstract doReaddir(path: string): Promise<FileEntry[]>;
-    protected abstract doExists(path: string): Promise<boolean>;
-    protected abstract doRemove(path: string): Promise<void>;
-}
-/**
- * Helper class for implementing Terminal with error handling
- */
-declare abstract class BaseTerminal implements SandboxTerminal {
-    protected provider: string;
-    protected sandboxId: string;
-    constructor(provider: string, sandboxId: string);
-    create(options?: TerminalCreateOptions): Promise<InteractiveTerminalSession>;
-    list(): Promise<InteractiveTerminalSession[]>;
-    protected abstract doCreate(options?: TerminalCreateOptions): Promise<InteractiveTerminalSession>;
-    protected abstract doList(): Promise<InteractiveTerminalSession[]>;
-}
-
-declare class ComputeSDK {
+    isRunning(): boolean;
     /**
-     * Create a new sandbox with the specified configuration
-     *
-     * @param config Optional sandbox configuration
-     * @returns Configured sandbox instance
+     * Write input to the terminal (PTY mode only)
      */
-    static createSandbox(config?: Partial<SandboxConfig>): ComputeSandbox;
+    write(input: string): void;
     /**
-     * Detect available providers based on environment variables
-     *
-     * @returns Array of available provider types
+     * Resize terminal window (PTY mode only)
      */
-    static detectProviders(): ProviderType[];
-}
-
-/**
- * ComputeSDK Core
- *
- * A unified abstraction layer for executing code in secure,
- * isolated sandboxed environments across multiple cloud providers.
- */
+    resize(cols: number, rows: number): void;
+    /**
+     * Set execute command handler (called by Sandbox)
+     * @internal
+     */
+    setExecuteHandler(handler: (command: string, background?: boolean) => Promise<CommandExecutionResponse>): void;
+    /**
+     * Set list commands handler (called by Sandbox)
+     * @internal
+     */
+    setListCommandsHandler(handler: () => Promise<CommandsListResponse>): void;
+    /**
+     * Set retrieve command handler (called by Sandbox)
+     * @internal
+     */
+    setRetrieveCommandHandler(handler: (cmdId: string) => Promise<CommandDetailsResponse>): void;
+    /**
+     * Set wait command handler (called by Sandbox)
+     * @internal
+     */
+    setWaitCommandHandler(handler: (cmdId: string, timeout?: number) => Promise<CommandDetailsResponse>): void;
+    /**
+     * Set destroy handler (called by Sandbox)
+     * @internal
+     */
+    setDestroyHandler(handler: () => Promise<void>): void;
+    /**
+     * Execute a command in the terminal (deprecated, use command.run())
+     * @deprecated Use terminal.command.run() instead
+     */
+    execute(command: string, options?: {
+        background?: boolean;
+    }): Promise<CommandExecutionResponse>;
+    /**
+     * Destroy the terminal
+     */
+    destroy(): Promise<void>;
+    /**
+     * Clean up resources
+     */
+    private cleanup;
+    /**
+     * Register event handler
+     */
+    on<K extends keyof TerminalEventHandler>(event: K, handler: TerminalEventHandler[K]): void;
+    /**
+     * Unregister event handler
+     */
+    off<K extends keyof TerminalEventHandler>(event: K, handler: TerminalEventHandler[K]): void;
+    /**
+     * Emit event to registered handlers
+     */
+    private emit;
+}
+
+/**
+ * FileWatcher class for monitoring file system changes with WebSocket integration
+ */
+
+/**
+ * File change event data
+ */
+interface FileChangeEvent {
+    event: 'add' | 'change' | 'unlink' | 'addDir' | 'unlinkDir';
+    path: string;
+    content?: string;
+}
+/**
+ * FileWatcher event handlers
+ */
+type FileWatcherEventHandler = {
+    change: (event: FileChangeEvent) => void;
+    destroyed: () => void;
+};
+/**
+ * FileWatcher class for monitoring file system changes
+ *
+ * @example
+ * ```typescript
+ * const client = new ComputeClient({ sandboxUrl: '...' });
+ * await client.generateToken();
+ *
+ * const watcher = await client.createWatcher('/home/project', {
+ *   ignored: ['node_modules', '.git']
+ * });
+ *
+ * watcher.on('change', (event) => {
+ *   console.log(`File ${event.event}: ${event.path}`);
+ * });
+ *
+ * await watcher.destroy();
+ * ```
+ */
+declare class FileWatcher {
+    private id;
+    private path;
+    private status;
+    private channel;
+    private includeContent;
+    private ignored;
+    private encoding;
+    private ws;
+    private eventHandlers;
+    constructor(id: string, path: string, status: 'active' | 'stopped', channel: string, includeContent: boolean, ignored: string[], ws: WebSocketManager, encoding?: 'raw' | 'base64');
+    /**
+     * Set up WebSocket event handlers
+     */
+    private setupWebSocketHandlers;
+    /**
+     * Get watcher ID
+     */
+    getId(): string;
+    /**
+     * Get watched path
+     */
+    getPath(): string;
+    /**
+     * Get watcher status
+     */
+    getStatus(): 'active' | 'stopped';
+    /**
+     * Get watcher channel
+     */
+    getChannel(): string;
+    /**
+     * Check if content is included in events
+     */
+    isIncludingContent(): boolean;
+    /**
+     * Get ignored patterns
+     */
+    getIgnoredPatterns(): string[];
+    /**
+     * Check if watcher is active
+     */
+    isActive(): boolean;
+    /**
+     * Destroy the watcher (uses REST API, not WebSocket)
+     */
+    private destroyWatcher?;
+    /**
+     * Set destroy handler (called by client)
+     */
+    setDestroyHandler(handler: () => Promise<void>): void;
+    /**
+     * Destroy the watcher
+     */
+    destroy(): Promise<void>;
+    /**
+     * Clean up resources
+     */
+    private cleanup;
+    /**
+     * Register event handler
+     */
+    on<K extends keyof FileWatcherEventHandler>(event: K, handler: FileWatcherEventHandler[K]): void;
+    /**
+     * Unregister event handler
+     */
+    off<K extends keyof FileWatcherEventHandler>(event: K, handler: FileWatcherEventHandler[K]): void;
+    /**
+     * Emit event to registered handlers
+     */
+    private emit;
+}
+
+/**
+ * SignalService class for monitoring system signals with WebSocket integration
+ */
+
+/**
+ * Port signal data
+ */
+interface PortSignalEvent {
+    signal: 'port' | 'server-ready';
+    port: number;
+    url: string;
+    type?: 'open' | 'close';
+}
+/**
+ * Error signal data
+ */
+interface ErrorSignalEvent {
+    signal: 'error';
+    message: string;
+}
+/**
+ * Generic signal event (union type)
+ */
+type SignalEvent = PortSignalEvent | ErrorSignalEvent;
+/**
+ * SignalService event handlers
+ */
+type SignalServiceEventHandler = {
+    port: (event: PortSignalEvent) => void;
+    error: (event: ErrorSignalEvent) => void;
+    signal: (event: SignalEvent) => void;
+};
+/**
+ * SignalService class for monitoring system signals and events
+ *
+ * @example
+ * ```typescript
+ * const client = new ComputeClient({ sandboxUrl: '...' });
+ * await client.generateToken();
+ *
+ * const signals = await client.startSignals();
+ *
+ * signals.on('port', (event) => {
+ *   console.log(`Port ${event.port} ${event.type}: ${event.url}`);
+ * });
+ *
+ * signals.on('error', (event) => {
+ *   console.error(`Error: ${event.message}`);
+ * });
+ *
+ * await signals.stop();
+ * ```
+ */
+declare class SignalService {
+    private status;
+    private channel;
+    private ws;
+    private eventHandlers;
+    constructor(status: 'active' | 'stopped', channel: string, ws: WebSocketManager);
+    /**
+     * Set up WebSocket event handlers
+     */
+    private setupWebSocketHandlers;
+    /**
+     * Get service status
+     */
+    getStatus(): 'active' | 'stopped';
+    /**
+     * Get service channel
+     */
+    getChannel(): string;
+    /**
+     * Check if service is active
+     */
+    isActive(): boolean;
+    /**
+     * Stop the signal service (uses REST API, not WebSocket)
+     */
+    private stopService?;
+    /**
+     * Set stop handler (called by client)
+     */
+    setStopHandler(handler: () => Promise<void>): void;
+    /**
+     * Stop the signal service
+     */
+    stop(): Promise<void>;
+    /**
+     * Clean up resources
+     */
+    private cleanup;
+    /**
+     * Register event handler
+     */
+    on<K extends keyof SignalServiceEventHandler>(event: K, handler: SignalServiceEventHandler[K]): void;
+    /**
+     * Unregister event handler
+     */
+    off<K extends keyof SignalServiceEventHandler>(event: K, handler: SignalServiceEventHandler[K]): void;
+    /**
+     * Emit event to registered handlers
+     */
+    private emit;
+}
+
+/**
+ * Terminal - Resource namespace for terminal management
+ */
+
+/**
+ * Terminal resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Create a PTY terminal (interactive shell)
+ * const pty = await sandbox.terminal.create({ pty: true, shell: '/bin/bash' });
+ * pty.on('output', (data) => console.log(data));
+ * pty.write('ls -la\n');
+ *
+ * // Create an exec terminal (command tracking)
+ * const exec = await sandbox.terminal.create({ pty: false });
+ * const cmd = await exec.command.run('npm test');
+ * console.log(cmd.exitCode);
+ *
+ * // List all terminals
+ * const terminals = await sandbox.terminal.list();
+ *
+ * // Retrieve a specific terminal
+ * const terminal = await sandbox.terminal.retrieve(id);
+ *
+ * // Destroy a terminal
+ * await sandbox.terminal.destroy(id);
+ * ```
+ */
+declare class Terminal {
+    private createHandler;
+    private listHandler;
+    private retrieveHandler;
+    private destroyHandler;
+    constructor(handlers: {
+        create: (options?: {
+            shell?: string;
+            encoding?: 'raw' | 'base64';
+            pty?: boolean;
+        }) => Promise<TerminalInstance>;
+        list: () => Promise<TerminalResponse[]>;
+        retrieve: (id: string) => Promise<TerminalInstance>;
+        destroy: (id: string) => Promise<void>;
+    });
+    /**
+     * Create a new terminal session
+     *
+     * @param options - Terminal creation options
+     * @param options.shell - Shell to use (e.g., '/bin/bash') - PTY mode only
+     * @param options.encoding - Encoding: 'raw' (default) or 'base64' (binary-safe)
+     * @param options.pty - Terminal mode: true = PTY (interactive), false = exec (command tracking)
+     * @returns TerminalInstance
+     */
+    create(options?: {
+        shell?: string;
+        encoding?: 'raw' | 'base64';
+        pty?: boolean;
+    }): Promise<TerminalInstance>;
+    /**
+     * List all active terminals
+     * @returns Array of terminal responses
+     */
+    list(): Promise<TerminalResponse[]>;
+    /**
+     * Retrieve a specific terminal by ID
+     * @param id - The terminal ID
+     * @returns Terminal instance
+     */
+    retrieve(id: string): Promise<TerminalInstance>;
+    /**
+     * Destroy a terminal by ID
+     * @param id - The terminal ID
+     */
+    destroy(id: string): Promise<void>;
+}
+
+/**
+ * Overlay - Resource namespace for filesystem overlay operations
+ *
+ * Overlays enable instant sandbox setup from template directories by copying
+ * files directly for isolation, with heavy directories copied in the background.
+ */
+/**
+ * Options for waiting for overlay copy completion
+ */
+interface WaitForCompletionOptions {
+    /** Maximum number of retry attempts (default: 60) */
+    maxRetries?: number;
+    /** Initial delay between retries in milliseconds (default: 500) */
+    initialDelayMs?: number;
+    /** Maximum delay between retries in milliseconds (default: 5000) */
+    maxDelayMs?: number;
+    /** Backoff multiplier for exponential backoff (default: 1.5) */
+    backoffFactor?: number;
+}
+/**
+ * Strategy for creating an overlay
+ * - 'copy': Full copy of all files (standard behavior)
+ * - 'smart': Use symlinks for immutable packages (e.g. node_modules) for instant creation
+ */
+type OverlayStrategy = 'copy' | 'smart';
+/**
+ * Options for creating an overlay
+ */
+interface CreateOverlayOptions {
+    /** Absolute path to source directory (template) */
+    source: string;
+    /** Relative path in sandbox where overlay will be mounted */
+    target: string;
+    /** Glob patterns to ignore (e.g., ["node_modules", "*.log"]) */
+    ignore?: string[];
+    /** Strategy to use (default: 'smart') */
+    strategy?: OverlayStrategy;
+    /** If true, wait for background copy to complete before returning (default: false) */
+    waitForCompletion?: boolean | WaitForCompletionOptions;
+}
+/**
+ * Copy status for overlay background operations
+ */
+type OverlayCopyStatus = 'pending' | 'in_progress' | 'complete' | 'failed';
+/**
+ * Statistics about an overlay
+ */
+interface OverlayStats {
+    /** Number of copied files */
+    copiedFiles: number;
+    /** Number of copied directories (heavy dirs copied in background) */
+    copiedDirs: number;
+    /** Paths that were skipped (e.g., .git, ignored patterns) */
+    skipped: string[];
+}
+/**
+ * Overlay information (client-side normalized type)
+ */
+interface OverlayInfo {
+    /** Unique overlay identifier */
+    id: string;
+    /** Absolute path to source directory */
+    source: string;
+    /** Relative path in sandbox */
+    target: string;
+    /** Strategy used for the overlay */
+    strategy: OverlayStrategy;
+    /** When the overlay was created */
+    createdAt: string;
+    /** Statistics about the overlay */
+    stats: OverlayStats;
+    /** Copy status for background operations */
+    copyStatus: OverlayCopyStatus;
+    /** Error message if copy failed */
+    copyError?: string;
+}
+/**
+ * API response for overlay operations (snake_case from server)
+ */
+interface OverlayResponse {
+    id: string;
+    source: string;
+    target: string;
+    strategy?: string;
+    created_at: string;
+    stats: {
+        copied_files: number;
+        copied_dirs: number;
+        skipped: string[];
+    };
+    copy_status: string;
+    copy_error?: string;
+}
+/**
+ * API response for listing overlays
+ */
+interface OverlayListResponse {
+    overlays: OverlayResponse[];
+}
+/**
+ * Overlay resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Create an overlay from a template directory
+ * const overlay = await sandbox.filesystem.overlay.create({
+ *   source: '/templates/nextjs',
+ *   target: 'project',
+ * });
+ * console.log(overlay.copyStatus); // 'pending' | 'in_progress' | 'complete' | 'failed'
+ *
+ * // Create an overlay and wait for background copy to complete
+ * const overlay = await sandbox.filesystem.overlay.create({
+ *   source: '/templates/nextjs',
+ *   target: 'project',
+ *   waitForCompletion: true, // blocks until copy is complete
+ * });
+ *
+ * // Wait for an existing overlay's copy to complete
+ * const overlay = await sandbox.filesystem.overlay.waitForCompletion('overlay-id');
+ *
+ * // List all overlays
+ * const overlays = await sandbox.filesystem.overlay.list();
+ *
+ * // Get a specific overlay (useful for polling copy status)
+ * const overlay = await sandbox.filesystem.overlay.retrieve('overlay-id');
+ * if (overlay.copyStatus === 'complete') {
+ *   console.log('Background copy finished!');
+ * }
+ *
+ * // Delete an overlay
+ * await sandbox.filesystem.overlay.destroy('overlay-id');
+ * ```
+ */
+declare class Overlay {
+    private createHandler;
+    private listHandler;
+    private retrieveHandler;
+    private destroyHandler;
+    constructor(handlers: {
+        create: (options: CreateOverlayOptions) => Promise<OverlayResponse>;
+        list: () => Promise<OverlayListResponse>;
+        retrieve: (id: string) => Promise<OverlayResponse>;
+        destroy: (id: string) => Promise<void>;
+    });
+    /**
+     * Create a new overlay from a template directory
+     *
+     * The overlay copies files from the source directory into the target path
+     * for better isolation. Heavy directories (node_modules, .venv, etc.) are
+     * copied in the background. Use the `ignore` option to exclude files/directories.
+     *
+     * @param options - Overlay creation options
+     * @param options.source - Absolute path to source directory
+     * @param options.target - Relative path in sandbox
+     * @param options.ignore - Glob patterns to ignore (e.g., ["node_modules", "*.log"])
+     * @param options.strategy - Strategy to use ('copy' or 'smart')
+     * @param options.waitForCompletion - If true or options object, wait for background copy to complete
+     * @returns Overlay info with copy status
+     */
+    create(options: CreateOverlayOptions): Promise<OverlayInfo>;
+    /**
+     * List all overlays for the current sandbox
+     * @returns Array of overlay info
+     */
+    list(): Promise<OverlayInfo[]>;
+    /**
+     * Retrieve a specific overlay by ID
+     *
+     * Useful for polling the copy status of an overlay.
+     *
+     * @param id - Overlay ID
+     * @returns Overlay info
+     */
+    retrieve(id: string): Promise<OverlayInfo>;
+    /**
+     * Destroy (delete) an overlay
+     * @param id - Overlay ID
+     */
+    destroy(id: string): Promise<void>;
+    /**
+     * Wait for an overlay's background copy to complete
+     *
+     * Polls the overlay status with exponential backoff until the copy
+     * is complete or fails. Throws an error if the copy fails or times out.
+     *
+     * @param id - Overlay ID
+     * @param options - Polling options
+     * @returns Overlay info with final copy status
+     * @throws Error if copy fails or times out
+     */
+    waitForCompletion(id: string, options?: WaitForCompletionOptions): Promise<OverlayInfo>;
+    /**
+     * Convert API response to OverlayInfo
+     */
+    private toOverlayInfo;
+    /**
+     * Validate and return strategy, defaulting to 'copy' for unknown/missing values (legacy support)
+     */
+    private validateStrategy;
+    /**
+     * Validate and return copy status, defaulting to 'pending' for unknown values
+     */
+    private validateCopyStatus;
+}
+
+/**
+ * Server - Resource namespace for managed server operations
+ */
+
+/**
+ * Options for starting a managed server
+ */
+interface ServerStartOptions {
+    /** Unique server identifier (URL-safe) */
+    slug: string;
+    /** Install command to run before starting (optional, runs blocking, e.g., "npm install") */
+    install?: string;
+    /** Command to start the server (e.g., "npm run dev") */
+    start: string;
+    /** Working directory (optional) */
+    path?: string;
+    /** Path to .env file relative to path (optional) */
+    env_file?: string;
+    /** Inline environment variables (merged with env_file if both provided) */
+    environment?: Record<string, string>;
+    /** Requested port number (preallocated before start) */
+    port?: number;
+    /** If true, fail instead of auto-incrementing when port is taken */
+    strict_port?: boolean;
+    /** Whether to auto-start the server on daemon boot (default: true) */
+    autostart?: boolean;
+    /** Inline overlay to create before starting the server */
+    overlay?: Omit<CreateOverlayOptions, 'waitForCompletion'>;
+    /** Additional overlays to create before starting the server */
+    overlays?: Array<Omit<CreateOverlayOptions, 'waitForCompletion'>>;
+    /** Overlay IDs this server depends on (waits for copy completion) */
+    depends_on?: string[];
+    /**
+     * When to automatically restart the server:
+     * - `never`: No automatic restart (default)
+     * - `on-failure`: Restart only on non-zero exit code
+     * - `always`: Always restart on exit (including exit code 0)
+     */
+    restart_policy?: RestartPolicy;
+    /** Maximum restart attempts (0 = unlimited, default: 0) */
+    max_restarts?: number;
+    /** Delay between restart attempts in milliseconds (default: 1000) */
+    restart_delay_ms?: number;
+    /** Graceful shutdown timeout in milliseconds - SIGTERM → wait → SIGKILL (default: 10000) */
+    stop_timeout_ms?: number;
+    /**
+     * Health check configuration for monitoring server availability
+     * When configured, the server will be polled to verify it's responding to requests
+     */
+    health_check?: HealthCheckConfig;
+}
+/**
+ * Server resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Start a basic server
+ * const server = await sandbox.server.start({
+ *   slug: 'api',
+ *   start: 'npm start',
+ *   path: '/app',
+ * });
+ *
+ * // Start with install command (runs before start)
+ * const server = await sandbox.server.start({
+ *   slug: 'web',
+ *   install: 'npm install',
+ *   start: 'npm run dev',
+ *   path: '/app',
+ * });
+ *
+ * // Start with supervisor settings (auto-restart on failure)
+ * const server = await sandbox.server.start({
+ *   slug: 'web',
+ *   start: 'node server.js',
+ *   path: '/app',
+ *   environment: { NODE_ENV: 'production', PORT: '3000' },
+ *   restart_policy: 'on-failure',
+ *   max_restarts: 5,
+ *   restart_delay_ms: 2000,
+ * });
+ *
+ * // Start with inline overlay dependencies
+ * const server = await sandbox.server.start({
+ *   slug: 'web',
+ *   start: 'npm run dev',
+ *   path: '/app',
+ *   overlay: {
+ *     source: '/templates/nextjs',
+ *     target: 'app',
+ *     strategy: 'smart',
+ *   },
+ * });
+ *
+ * // List all servers
+ * const servers = await sandbox.server.list();
+ *
+ * // Retrieve a specific server
+ * const server = await sandbox.server.retrieve('api');
+ *
+ * // Stop a server (graceful shutdown with SIGTERM → SIGKILL)
+ * await sandbox.server.stop('api');
+ *
+ * // Delete a server config
+ * await sandbox.server.delete('api');
+ *
+ * // Restart a server
+ * await sandbox.server.restart('api');
+ * ```
+ */
+/**
+ * Options for retrieving server logs
+ */
+interface ServerLogsOptions {
+    /** Which output stream to return: 'stdout', 'stderr', or 'combined' (default) */
+    stream?: ServerLogStream;
+}
+/**
+ * Server logs info returned from the logs method
+ */
+interface ServerLogsInfo {
+    /** Server slug identifier */
+    slug: string;
+    /** Which stream was returned */
+    stream: ServerLogStream;
+    /** The captured logs */
+    logs: string;
+}
+declare class Server {
+    private startHandler;
+    private listHandler;
+    private retrieveHandler;
+    private stopHandler;
+    private deleteHandler;
+    private restartHandler;
+    private updateStatusHandler;
+    private logsHandler;
+    constructor(handlers: {
+        start: (options: ServerStartOptions) => Promise<ServerResponse>;
+        list: () => Promise<ServersListResponse>;
+        retrieve: (slug: string) => Promise<ServerResponse>;
+        stop: (slug: string) => Promise<ServerStopResponse | void>;
+        delete: (slug: string) => Promise<void>;
+        restart: (slug: string) => Promise<ServerResponse>;
+        updateStatus: (slug: string, status: ServerStatus) => Promise<void>;
+        logs: (slug: string, options?: ServerLogsOptions) => Promise<ServerLogsResponse>;
+    });
+    /**
+     * Start a new managed server with optional supervisor settings
+     *
+     * **Install Phase:**
+     * If `install` is provided, it runs blocking before `start` (e.g., "npm install").
+     * The server status will be `installing` during this phase.
+     *
+     * **Restart Policies:**
+     * - `never` (default): No automatic restart on exit
+     * - `on-failure`: Restart only on non-zero exit code
+     * - `always`: Always restart on exit (including exit code 0)
+     *
+     * **Graceful Shutdown:**
+     * When stopping a server, it first sends SIGTERM and waits for `stop_timeout_ms`
+     * before sending SIGKILL if the process hasn't exited.
+     *
+     * @param options - Server configuration
+     * @returns Server info
+     *
+     * @example
+     * ```typescript
+     * // Basic server
+     * const server = await sandbox.server.start({
+     *   slug: 'web',
+     *   start: 'npm run dev',
+     *   path: '/app',
+     * });
+     *
+     * // With install command
+     * const server = await sandbox.server.start({
+     *   slug: 'api',
+     *   install: 'npm install',
+     *   start: 'node server.js',
+     *   environment: { NODE_ENV: 'production' },
+     *   restart_policy: 'always',
+     *   max_restarts: 0, // unlimited
+     * });
+     * ```
+     */
+    start(options: ServerStartOptions): Promise<ServerInfo>;
+    /**
+     * List all managed servers
+     * @returns Array of server info
+     */
+    list(): Promise<ServerInfo[]>;
+    /**
+     * Retrieve a specific server by slug
+     * @param slug - The server slug
+     * @returns Server info
+     */
+    retrieve(slug: string): Promise<ServerInfo>;
+    /**
+     * Stop a server by slug (non-destructive)
+     * @param slug - The server slug
+     */
+    stop(slug: string): Promise<void>;
+    /**
+     * Delete a server config by slug (stops + removes persistence)
+     * @param slug - The server slug
+     */
+    delete(slug: string): Promise<void>;
+    /**
+     * Restart a server by slug
+     * @param slug - The server slug
+     * @returns Server info
+     */
+    restart(slug: string): Promise<ServerInfo>;
+    /**
+     * Update server status (internal use)
+     * @param slug - The server slug
+     * @param status - New status
+     */
+    updateStatus(slug: string, status: ServerStatus): Promise<void>;
+    /**
+     * Retrieve captured output (logs) for a managed server
+     * @param slug - The server slug
+     * @param options - Options for log retrieval
+     * @returns Server logs info
+     *
+     * @example
+     * ```typescript
+     * // Get combined logs (default)
+     * const logs = await sandbox.server.logs('api');
+     * console.log(logs.logs);
+     *
+     * // Get only stdout
+     * const stdout = await sandbox.server.logs('api', { stream: 'stdout' });
+     *
+     * // Get only stderr
+     * const stderr = await sandbox.server.logs('api', { stream: 'stderr' });
+     * ```
+     */
+    logs(slug: string, options?: ServerLogsOptions): Promise<ServerLogsInfo>;
+}
+
+/**
+ * Watcher - Resource namespace for file watcher operations
+ */
+
+/**
+ * Watcher resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Create a file watcher
+ * const watcher = await sandbox.watcher.create('/project', {
+ *   ignored: ['node_modules', '.git'],
+ *   includeContent: true,
+ * });
+ * watcher.on('change', (event) => {
+ *   console.log(`${event.event}: ${event.path}`);
+ * });
+ *
+ * // List all watchers
+ * const watchers = await sandbox.watcher.list();
+ *
+ * // Retrieve a specific watcher
+ * const watcher = await sandbox.watcher.retrieve(id);
+ *
+ * // Destroy a watcher
+ * await sandbox.watcher.destroy(id);
+ * ```
+ */
+declare class Watcher {
+    private createHandler;
+    private listHandler;
+    private retrieveHandler;
+    private destroyHandler;
+    constructor(handlers: {
+        create: (path: string, options?: {
+            includeContent?: boolean;
+            ignored?: string[];
+            encoding?: 'raw' | 'base64';
+        }) => Promise<FileWatcher>;
+        list: () => Promise<WatchersListResponse>;
+        retrieve: (id: string) => Promise<WatcherResponse>;
+        destroy: (id: string) => Promise<void>;
+    });
+    /**
+     * Create a new file watcher
+     * @param path - Path to watch
+     * @param options - Watcher options
+     * @param options.includeContent - Include file content in change events
+     * @param options.ignored - Patterns to ignore
+     * @param options.encoding - Encoding: 'raw' (default) or 'base64' (binary-safe)
+     * @returns FileWatcher instance
+     */
+    create(path: string, options?: {
+        includeContent?: boolean;
+        ignored?: string[];
+        encoding?: 'raw' | 'base64';
+    }): Promise<FileWatcher>;
+    /**
+     * List all active file watchers
+     * @returns Array of watcher info
+     */
+    list(): Promise<WatcherInfo[]>;
+    /**
+     * Retrieve a specific watcher by ID
+     * @param id - The watcher ID
+     * @returns Watcher info
+     */
+    retrieve(id: string): Promise<WatcherInfo>;
+    /**
+     * Destroy a watcher by ID
+     * @param id - The watcher ID
+     */
+    destroy(id: string): Promise<void>;
+}
+
+/**
+ * SessionToken - Resource namespace for session token management
+ */
+
+/**
+ * Session token info
+ */
+interface SessionTokenInfo {
+    id: string;
+    token?: string;
+    description?: string;
+    createdAt: string;
+    expiresAt: string;
+    lastUsedAt?: string;
+}
+/**
+ * SessionToken resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Create a session token (requires access token)
+ * const token = await sandbox.sessionToken.create({
+ *   description: 'My Application',
+ *   expiresIn: 604800, // 7 days
+ * });
+ * console.log(token.token);
+ *
+ * // List all session tokens
+ * const tokens = await sandbox.sessionToken.list();
+ *
+ * // Retrieve a specific token
+ * const token = await sandbox.sessionToken.retrieve(id);
+ *
+ * // Revoke a token
+ * await sandbox.sessionToken.revoke(id);
+ * ```
+ */
+declare class SessionToken {
+    private createHandler;
+    private listHandler;
+    private retrieveHandler;
+    private revokeHandler;
+    constructor(handlers: {
+        create: (options?: {
+            description?: string;
+            expiresIn?: number;
+        }) => Promise<SessionTokenResponse>;
+        list: () => Promise<SessionTokenListResponse>;
+        retrieve: (id: string) => Promise<SessionTokenResponse>;
+        revoke: (id: string) => Promise<void>;
+    });
+    /**
+     * Create a new session token (requires access token)
+     * @param options - Token configuration
+     * @param options.description - Description for the token
+     * @param options.expiresIn - Expiration time in seconds (default: 7 days)
+     * @returns Session token info including the token value
+     */
+    create(options?: {
+        description?: string;
+        expiresIn?: number;
+    }): Promise<SessionTokenInfo>;
+    /**
+     * List all session tokens
+     * @returns Array of session token info
+     */
+    list(): Promise<SessionTokenInfo[]>;
+    /**
+     * Retrieve a specific session token by ID
+     * @param id - The token ID
+     * @returns Session token info
+     */
+    retrieve(id: string): Promise<SessionTokenInfo>;
+    /**
+     * Revoke a session token
+     * @param id - The token ID to revoke
+     */
+    revoke(id: string): Promise<void>;
+}
+
+/**
+ * MagicLink - Resource namespace for magic link operations
+ */
+
+/**
+ * Magic link info
+ */
+interface MagicLinkInfo {
+    url: string;
+    expiresAt: string;
+    redirectUrl: string;
+}
+/**
+ * MagicLink resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Create a magic link (requires access token)
+ * const link = await sandbox.magicLink.create({
+ *   redirectUrl: '/dashboard',
+ * });
+ * console.log(link.url);
+ * ```
+ */
+declare class MagicLink {
+    private createHandler;
+    constructor(handlers: {
+        create: (options?: {
+            redirectUrl?: string;
+        }) => Promise<MagicLinkResponse>;
+    });
+    /**
+     * Create a magic link for browser authentication (requires access token)
+     *
+     * Magic links are one-time URLs that automatically create a session token
+     * and set it as a cookie in the user's browser.
+     *
+     * @param options - Magic link configuration
+     * @param options.redirectUrl - URL to redirect to after authentication
+     * @returns Magic link info including the URL
+     */
+    create(options?: {
+        redirectUrl?: string;
+    }): Promise<MagicLinkInfo>;
+}
+
+/**
+ * Signal - Resource namespace for signal service operations
+ */
+
+/**
+ * Signal service status info
+ */
+interface SignalStatusInfo {
+    status: 'active' | 'stopped';
+    channel: string;
+    wsUrl: string;
+}
+/**
+ * Signal resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Start the signal service
+ * const signals = await sandbox.signal.start();
+ * signals.on('port', (event) => {
+ *   console.log(`Port ${event.port} opened: ${event.url}`);
+ * });
+ *
+ * // Get signal service status
+ * const status = await sandbox.signal.status();
+ *
+ * // Emit signals
+ * await sandbox.signal.emitPort(3000, 'open', 'http://localhost:3000');
+ * await sandbox.signal.emitError('Something went wrong');
+ *
+ * // Stop the signal service
+ * await sandbox.signal.stop();
+ * ```
+ */
+declare class Signal {
+    private startHandler;
+    private statusHandler;
+    private stopHandler;
+    private emitPortHandler;
+    private emitErrorHandler;
+    private emitServerReadyHandler;
+    constructor(handlers: {
+        start: () => Promise<SignalService>;
+        status: () => Promise<SignalServiceResponse>;
+        stop: () => Promise<void>;
+        emitPort: (port: number, type: 'open' | 'close', url: string) => Promise<PortSignalResponse>;
+        emitError: (message: string) => Promise<GenericSignalResponse>;
+        emitServerReady: (port: number, url: string) => Promise<PortSignalResponse>;
+    });
+    /**
+     * Start the signal service
+     * @returns SignalService instance with event handling
+     */
+    start(): Promise<SignalService>;
+    /**
+     * Get the signal service status
+     * @returns Signal service status info
+     */
+    status(): Promise<SignalStatusInfo>;
+    /**
+     * Stop the signal service
+     */
+    stop(): Promise<void>;
+    /**
+     * Emit a port signal
+     * @param port - Port number
+     * @param type - Signal type ('open' or 'close')
+     * @param url - URL associated with the port
+     */
+    emitPort(port: number, type: 'open' | 'close', url: string): Promise<void>;
+    /**
+     * Emit an error signal
+     * @param message - Error message
+     */
+    emitError(message: string): Promise<void>;
+    /**
+     * Emit a server ready signal
+     * @param port - Port number
+     * @param url - Server URL
+     */
+    emitServerReady(port: number, url: string): Promise<void>;
+}
+
+/**
+ * File - Resource namespace for file operations
+ */
+
+/**
+ * File resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Create a file
+ * const file = await sandbox.file.create('/project/hello.txt', 'Hello, World!');
+ *
+ * // List files in a directory
+ * const files = await sandbox.file.list('/project');
+ *
+ * // Retrieve file content
+ * const content = await sandbox.file.retrieve('/project/hello.txt');
+ *
+ * // Destroy (delete) a file
+ * await sandbox.file.destroy('/project/hello.txt');
+ *
+ * // Batch write multiple files
+ * const results = await sandbox.file.batchWrite([
+ *   { path: '/project/a.txt', operation: 'write', content: 'A' },
+ *   { path: '/project/b.txt', operation: 'write', content: 'B' },
+ * ]);
+ *
+ * // Batch delete files
+ * const results = await sandbox.file.batchWrite([
+ *   { path: '/project/old.txt', operation: 'delete' },
+ * ]);
+ * ```
+ */
+declare class File {
+    private createHandler;
+    private listHandler;
+    private retrieveHandler;
+    private destroyHandler;
+    private batchWriteHandler;
+    private existsHandler;
+    constructor(handlers: {
+        create: (path: string, content?: string) => Promise<FileResponse>;
+        list: (path: string) => Promise<FilesListResponse>;
+        retrieve: (path: string) => Promise<string>;
+        destroy: (path: string) => Promise<void>;
+        batchWrite: (files: Array<{
+            path: string;
+            operation: BatchFileOperation;
+            content?: string;
+        }>) => Promise<BatchWriteResponse>;
+        exists: (path: string) => Promise<boolean>;
+    });
+    /**
+     * Create a new file with optional content
+     * @param path - File path
+     * @param content - File content (optional)
+     * @returns File info
+     */
+    create(path: string, content?: string): Promise<FileInfo>;
+    /**
+     * List files at the specified path
+     * @param path - Directory path (default: '/')
+     * @returns Array of file info
+     */
+    list(path?: string): Promise<FileInfo[]>;
+    /**
+     * Retrieve file content
+     * @param path - File path
+     * @returns File content as string
+     */
+    retrieve(path: string): Promise<string>;
+    /**
+     * Destroy (delete) a file or directory
+     * @param path - File or directory path
+     */
+    destroy(path: string): Promise<void>;
+    /**
+     * Batch file operations (write or delete multiple files)
+     *
+     * Features:
+     * - Deduplication: Last operation wins per path
+     * - File locking: Prevents race conditions
+     * - Deterministic ordering: Alphabetical path sorting
+     * - Partial failure handling: Returns per-file results
+     *
+     * @param files - Array of file operations
+     * @returns Results for each file operation
+     */
+    batchWrite(files: Array<{
+        path: string;
+        operation: BatchFileOperation;
+        content?: string;
+    }>): Promise<BatchWriteResult[]>;
+    /**
+     * Check if a file exists
+     * @param path - File path
+     * @returns True if file exists
+     */
+    exists(path: string): Promise<boolean>;
+}
+
+/**
+ * Env - Resource namespace for environment variable operations
+ */
+
+/**
+ * Env resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Retrieve environment variables
+ * const vars = await sandbox.env.retrieve('.env');
+ * console.log(vars);
+ *
+ * // Update environment variables (merges with existing)
+ * await sandbox.env.update('.env', {
+ *   API_KEY: 'secret',
+ *   DEBUG: 'true',
+ * });
+ *
+ * // Remove environment variables
+ * await sandbox.env.remove('.env', ['OLD_KEY', 'DEPRECATED']);
+ * ```
+ */
+declare class Env {
+    private retrieveHandler;
+    private updateHandler;
+    private removeHandler;
+    private existsHandler;
+    constructor(handlers: {
+        retrieve: (file: string) => Promise<EnvGetResponse>;
+        update: (file: string, variables: Record<string, string>) => Promise<EnvSetResponse>;
+        remove: (file: string, keys: string[]) => Promise<EnvDeleteResponse>;
+        exists: (file: string) => Promise<boolean>;
+    });
+    /**
+     * Retrieve environment variables from a file
+     * @param file - Path to the .env file (relative to sandbox root)
+     * @returns Key-value map of environment variables
+     */
+    retrieve(file: string): Promise<Record<string, string>>;
+    /**
+     * Update (merge) environment variables in a file
+     * @param file - Path to the .env file (relative to sandbox root)
+     * @param variables - Key-value pairs to set
+     * @returns Keys that were updated
+     */
+    update(file: string, variables: Record<string, string>): Promise<string[]>;
+    /**
+     * Remove environment variables from a file
+     * @param file - Path to the .env file (relative to sandbox root)
+     * @param keys - Keys to remove
+     * @returns Keys that were removed
+     */
+    remove(file: string, keys: string[]): Promise<string[]>;
+    /**
+     * Check if an environment file exists
+     * @param file - Path to the .env file (relative to sandbox root)
+     * @returns True if file exists
+     */
+    exists(file: string): Promise<boolean>;
+}
+
+/**
+ * Auth - Resource namespace for authentication info
+ */
+
+/**
+ * Authentication status info
+ */
+interface AuthStatusInfo {
+    authenticated: boolean;
+    tokenType?: 'access_token' | 'session_token';
+    expiresAt?: string;
+}
+/**
+ * Authentication endpoints info
+ */
+interface AuthEndpointsInfo {
+    createSessionToken: string;
+    listSessionTokens: string;
+    getSessionToken: string;
+    revokeSessionToken: string;
+    createMagicLink: string;
+    authStatus: string;
+    authInfo: string;
+}
+/**
+ * Authentication info
+ */
+interface AuthInfo {
+    message: string;
+    instructions: string;
+    endpoints: AuthEndpointsInfo;
+}
+/**
+ * Auth resource namespace
+ *
+ * @example
+ * ```typescript
+ * // Check authentication status
+ * const status = await sandbox.auth.status();
+ * console.log(status.authenticated);
+ * console.log(status.tokenType);
+ *
+ * // Get authentication info and instructions
+ * const info = await sandbox.auth.info();
+ * console.log(info.instructions);
+ * ```
+ */
+declare class Auth {
+    private statusHandler;
+    private infoHandler;
+    constructor(handlers: {
+        status: () => Promise<AuthStatusResponse>;
+        info: () => Promise<AuthInfoResponse>;
+    });
+    /**
+     * Check authentication status
+     * @returns Authentication status info
+     */
+    status(): Promise<AuthStatusInfo>;
+    /**
+     * Get authentication information and usage instructions
+     * @returns Authentication info
+     */
+    info(): Promise<AuthInfo>;
+}
+
+/**
+ * Run - Resource namespace for code and command execution
+ */
+/**
+ * Code execution result
+ */
+interface CodeResult {
+    output: string;
+    exitCode: number;
+    language: string;
+}
+/**
+ * Command execution result
+ */
+interface CommandResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    durationMs: number;
+    /** Command ID (present for background commands) */
+    cmdId?: string;
+    /** Terminal ID (present for background commands) */
+    terminalId?: string;
+    /** Command status (present for background commands) */
+    status?: 'running' | 'completed' | 'failed';
+}
+/**
+ * Supported languages for code execution
+ */
+type CodeLanguage = 'python' | 'python3' | 'node' | 'javascript' | 'js' | 'bash' | 'sh' | 'ruby';
+/**
+ * Code execution options
+ */
+interface CodeRunOptions {
+    /** Programming language (optional - will auto-detect if not specified) */
+    language?: CodeLanguage;
+}
+/**
+ * Options for waiting for command completion
+ */
+interface CommandWaitOptions {
+    /** Timeout in seconds to wait for command completion (default: 300, max: 300) */
+    timeoutSeconds?: number;
+}
+/**
+ * Command execution options
+ */
+interface CommandRunOptions {
+    /** Shell to use (optional) */
+    shell?: string;
+    /** Run in background (optional) */
+    background?: boolean;
+    /** Working directory for the command (optional) */
+    cwd?: string;
+    /** Environment variables (optional) */
+    env?: Record<string, string>;
+    /** If true, wait for background command to complete before returning (default: false) */
+    waitForCompletion?: boolean | CommandWaitOptions;
+}
+/**
+ * Run - Resource namespace for executing code and commands
+ *
+ * @example
+ * ```typescript
+ * // Run code with auto-detection
+ * const result = await sandbox.run.code('print("Hello from Python")');
+ * console.log(result.output); // "Hello from Python\n"
+ * console.log(result.language); // "python"
+ *
+ * // Run code with explicit language
+ * const result = await sandbox.run.code('console.log("Hello")', { language: 'node' });
+ *
+ * // Run a command
+ * const result = await sandbox.run.command('ls -la');
+ * console.log(result.stdout);
+ * console.log(result.exitCode);
+ *
+ * // Run a command in background and wait for completion
+ * const result = await sandbox.run.command('npm install', {
+ *   background: true,
+ *   waitForCompletion: true, // blocks until command completes
+ * });
+ * console.log(result.exitCode);
+ *
+ * // Run in background without waiting (fire-and-forget)
+ * const result = await sandbox.run.command('npm install', { background: true });
+ * console.log(result.cmdId); // command ID for manual tracking
+ * console.log(result.terminalId); // terminal ID for manual tracking
+ * ```
+ */
+declare class Run {
+    private codeHandler;
+    private commandHandler;
+    private waitHandler?;
+    constructor(handlers: {
+        code: (code: string, options?: CodeRunOptions) => Promise<CodeResult>;
+        command: (command: string, options?: CommandRunOptions) => Promise<CommandResult>;
+        wait?: (terminalId: string, cmdId: string, options?: CommandWaitOptions) => Promise<CommandResult>;
+    });
+    /**
+     * Execute code with automatic language detection
+     *
+     * Supports: python, python3, node, javascript, js, bash, sh, ruby
+     *
+     * @param code - The code to execute
+     * @param options - Execution options
+     * @param options.language - Programming language (auto-detected if not specified)
+     * @returns Code execution result with output, exit code, and detected language
+     */
+    code(code: string, options?: CodeRunOptions): Promise<CodeResult>;
+    /**
+     * Execute a shell command
+     *
+     * @param command - The command to execute
+     * @param options - Execution options
+     * @param options.shell - Shell to use (optional)
+     * @param options.background - Run in background (optional)
+     * @param options.cwd - Working directory for the command (optional)
+     * @param options.env - Environment variables (optional)
+     * @param options.waitForCompletion - If true (with background), wait for command to complete
+     * @returns Command execution result with stdout, stderr, exit code, and duration
+     */
+    command(command: string, options?: CommandRunOptions): Promise<CommandResult>;
+    /**
+     * Wait for a background command to complete
+     *
+     * Uses the configured wait handler to block until the command
+     * is complete or fails (typically via server-side long-polling).
+     * Throws an error if the command fails or times out.
+     *
+     * @param terminalId - Terminal ID from background command result
+     * @param cmdId - Command ID from background command result
+     * @param options - Wait options passed to the handler
+     * @returns Command result with final status
+     * @throws Error if command fails or times out
+     */
+    waitForCompletion(terminalId: string, cmdId: string, options?: CommandWaitOptions): Promise<CommandResult>;
+}
+
+/**
+ * Client Types
+ *
+ * Types specific to the gateway Sandbox client implementation.
+ * Core universal types are imported from ../types/universal-sandbox
+ */
+
+/**
+ * Sandbox status types (client-specific, more limited than universal)
+ */
+type SandboxStatus = 'running' | 'stopped' | 'error';
+/**
+ * Provider-agnostic sandbox info (alias for SandboxInfo for backward compatibility)
+ */
+interface ProviderSandboxInfo {
+    /** Unique identifier for the sandbox */
+    id: string;
+    /** Provider hosting the sandbox */
+    provider: string;
+    /** Runtime environment in the sandbox */
+    runtime: Runtime;
+    /** Current status of the sandbox */
+    status: SandboxStatus;
+    /** When the sandbox was created */
+    createdAt: Date;
+    /** Execution timeout in milliseconds */
+    timeout: number;
+    /** Additional provider-specific metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Error thrown when a command exits with a non-zero status
+ */
+declare class CommandExitError extends Error {
+    result: {
+        exitCode: number;
+        stdout: string;
+        stderr: string;
+        error: boolean;
+    };
+    name: string;
+    constructor(result: {
+        exitCode: number;
+        stdout: string;
+        stderr: string;
+        error: boolean;
+    });
+}
+/**
+ * Type guard to check if an error is a CommandExitError
+ */
+declare function isCommandExitError(error: unknown): error is CommandExitError;
+
+/**
+ * Child - Resource namespace for child sandbox operations
+ */
+
+/**
+ * Child resource namespace for managing child sandboxes
+ *
+ * Child sandboxes are isolated environments within the parent sandbox,
+ * each with their own filesystem. Available only in multi-tenant mode.
+ *
+ * @example
+ * ```typescript
+ * // Create a new child sandbox
+ * const child = await sandbox.child.create({
+ *   directory: '/custom/path',
+ *   overlays: [
+ *     {
+ *       source: '/templates/nextjs',
+ *       target: 'app',
+ *       strategy: 'smart',
+ *     },
+ *   ],
+ *   servers: [
+ *     {
+ *       slug: 'web',
+ *       start: 'npm run dev',
+ *       path: '/app',
+ *     },
+ *   ],
+ * });
+ * console.log(child.url); // https://sandbox-12345.sandbox.computesdk.com
+ *
+ * // List all children
+ * const all = await sandbox.child.list();
+ *
+ * // Get a specific child
+ * const info = await sandbox.child.retrieve('sandbox-12345');
+ *
+ * // Delete a child sandbox
+ * await sandbox.child.destroy('sandbox-12345');
+ *
+ * // Delete child and its files
+ * await sandbox.child.destroy('sandbox-12345', { deleteFiles: true });
+ * ```
+ */
+declare class Child {
+    private createHandler;
+    private listHandler;
+    private retrieveHandler;
+    private destroyHandler;
+    constructor(handlers: {
+        create: (options?: CreateSandboxOptions$1) => Promise<SandboxInfo>;
+        list: () => Promise<SandboxesListResponse>;
+        retrieve: (subdomain: string) => Promise<SandboxInfo>;
+        destroy: (subdomain: string, deleteFiles: boolean) => Promise<void>;
+    });
+    /**
+     * Create a new child sandbox
+     * @returns Child sandbox info including URL and subdomain
+     */
+    create(options?: CreateSandboxOptions$1): Promise<SandboxInfo>;
+    /**
+     * List all child sandboxes
+     * @returns Array of child sandbox info
+     */
+    list(): Promise<SandboxInfo[]>;
+    /**
+     * Retrieve a specific child sandbox by subdomain
+     * @param subdomain - The child subdomain (e.g., 'sandbox-12345')
+     * @returns Child sandbox info
+     */
+    retrieve(subdomain: string): Promise<SandboxInfo>;
+    /**
+     * Destroy (delete) a child sandbox
+     * @param subdomain - The child subdomain
+     * @param options - Destroy options
+     * @param options.deleteFiles - Whether to delete the child's files (default: false)
+     */
+    destroy(subdomain: string, options?: {
+        deleteFiles?: boolean;
+    }): Promise<void>;
+}
+
+/**
+ * Binary WebSocket Protocol Implementation
+ *
+ * Implements the ComputeSDK binary protocol for WebSocket communication.
+ * Provides 50-90% size reduction compared to JSON protocol.
+ *
+ * Binary Message Format:
+ * [1 byte: message type]
+ * [2 bytes: channel length (uint16, big-endian)]
+ * [N bytes: channel string (UTF-8)]
+ * [2 bytes: msg type length (uint16, big-endian)]
+ * [N bytes: msg type string (UTF-8)]
+ * [4 bytes: data length (uint32, big-endian)]
+ * [N bytes: data (key-value encoded for complex objects, raw bytes for binary data)]
+ *
+ * Key-Value Encoding Format:
+ * [2 bytes: num_fields (uint16, big-endian)]
+ * For each field:
+ *   [2 bytes: key_length (uint16, big-endian)]
+ *   [N bytes: key string (UTF-8)]
+ *   [1 byte: value_type (0x01=string, 0x02=number, 0x03=boolean, 0x04=bytes)]
+ *   [4 bytes: value_length (uint32, big-endian)]
+ *   [N bytes: value data]
+ */
+declare enum MessageType {
+    Subscribe = 1,
+    Unsubscribe = 2,
+    Data = 3,
+    Error = 4,
+    Connected = 5
+}
+/**
+ * Encode a WebSocket message to binary format
+ * @param message - The message object to encode
+ * @returns ArrayBuffer containing the encoded binary message
+ */
+declare function encodeBinaryMessage(message: any): ArrayBuffer;
+/**
+ * Decode a binary WebSocket message
+ * @param buffer - The binary data to decode (ArrayBuffer or Uint8Array)
+ * @returns Decoded message object
+ */
+declare function decodeBinaryMessage(buffer: ArrayBuffer | Uint8Array): any;
+
+/**
+ * ComputeSDK Client - Universal Sandbox Implementation
+ *
+ * This package provides a Sandbox for interacting with ComputeSDK sandboxes
+ * through API endpoints at ${sandboxId}.sandbox.computesdk.com
+ *
+ * Works in browser, Node.js, and edge runtimes.
+ * Browser: Uses native WebSocket and fetch
+ * Node.js: Pass WebSocket implementation (e.g., 'ws' library)
+ */
+
+/**
+ * Extended filesystem interface with overlay support
+ */
+interface ExtendedFileSystem extends SandboxFileSystem {
+    /** Overlay operations for template directories */
+    readonly overlay: Overlay;
+}
+
+/**
+ * WebSocket constructor type
+ */
+type WebSocketConstructor = new (url: string) => WebSocket;
+/**
+ * Configuration options for creating a Sandbox
+ */
+interface SandboxConfig {
+    /** API endpoint URL (e.g., https://sandbox-123.sandbox.computesdk.com). Optional in browser - can be auto-detected from URL query param or localStorage */
+    sandboxUrl?: string;
+    /** Sandbox ID */
+    sandboxId: string;
+    /** Provider name (e.g., 'e2b', 'gateway') */
+    provider: string;
+    /** Access token or session token for authentication. Optional in browser - can be auto-detected from URL query param or localStorage */
+    token?: string;
+    /** Optional headers to include with all requests */
+    headers?: Record<string, string>;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** WebSocket implementation (optional, uses global WebSocket if not provided) */
+    WebSocket?: WebSocketConstructor;
+    /** WebSocket protocol: 'binary' (default, recommended) or 'json' (for debugging) */
+    protocol?: 'json' | 'binary';
+    /** Optional metadata associated with the sandbox */
+    metadata?: Record<string, unknown>;
+    /**
+     * Handler called when destroy() is invoked.
+     * If provided, this is called to destroy the sandbox (e.g., via gateway API).
+     * If not provided, destroy() only disconnects the WebSocket.
+     * @internal
+     */
+    destroyHandler?: () => Promise<void>;
+}
+/**
+ * Health check response
+ */
+interface HealthResponse {
+    status: string;
+    timestamp: string;
+}
+/**
+ * Server info response
+ */
+interface InfoResponse {
+    message: string;
+    data: {
+        auth_enabled: boolean;
+        main_subdomain: string;
+        sandbox_count: number;
+        sandbox_url: string;
+        version: string;
+    };
+}
+/**
+ * Session token response
+ */
+interface SessionTokenResponse {
+    id: string;
+    token: string;
+    description?: string;
+    createdAt: string;
+    expiresAt: string;
+    expiresIn: number;
+}
+/**
+ * Session token list response
+ */
+interface SessionTokenListResponse {
+    message: string;
+    data: {
+        tokens: Array<{
+            id: string;
+            description?: string;
+            created_at: string;
+            expires_at: string;
+            last_used_at?: string;
+        }>;
+    };
+}
+/**
+ * Magic link response
+ */
+interface MagicLinkResponse {
+    message: string;
+    data: {
+        magic_url: string;
+        expires_at: string;
+        redirect_url: string;
+    };
+}
+/**
+ * Authentication status response
+ */
+interface AuthStatusResponse {
+    message: string;
+    data: {
+        authenticated: boolean;
+        token_type?: 'access_token' | 'session_token';
+        expires_at?: string;
+    };
+}
+/**
+ * Authentication information response
+ */
+interface AuthInfoResponse {
+    message: string;
+    data: {
+        message: string;
+        instructions: string;
+        endpoints: {
+            create_session_token: string;
+            list_session_tokens: string;
+            get_session_token: string;
+            revoke_session_token: string;
+            create_magic_link: string;
+            auth_status: string;
+            auth_info: string;
+        };
+    };
+}
+/**
+ * File information
+ */
+interface FileInfo {
+    name: string;
+    path: string;
+    size: number;
+    is_dir: boolean;
+    modified_at: string;
+}
+/**
+ * Files list response
+ */
+interface FilesListResponse {
+    message: string;
+    data: {
+        files: FileInfo[];
+        path: string;
+    };
+}
+/**
+ * File response
+ */
+interface FileResponse {
+    message: string;
+    data: {
+        file: FileInfo;
+        content?: string;
+    };
+}
+/**
+ * Command execution response (used by both /run/command and /terminals/{id}/execute)
+ */
+interface CommandExecutionResponse {
+    message: string;
+    data: {
+        terminal_id?: string;
+        cmd_id?: string;
+        command: string;
+        stdout: string;
+        stderr: string;
+        exit_code?: number;
+        duration_ms?: number;
+        status?: 'running' | 'completed' | 'failed';
+        channel?: string;
+        pty?: boolean;
+    };
+}
+/**
+ * Command details response
+ */
+interface CommandDetailsResponse {
+    message: string;
+    data: {
+        cmd_id: string;
+        command: string;
+        status: 'running' | 'completed' | 'failed';
+        stdout: string;
+        stderr: string;
+        started_at: string;
+        finished_at?: string;
+        duration_ms?: number;
+        exit_code?: number;
+    };
+}
+/**
+ * Command list item
+ */
+interface CommandListItem {
+    cmd_id: string;
+    command: string;
+    status: 'running' | 'completed' | 'failed';
+    started_at: string;
+    finished_at?: string;
+    duration_ms?: number;
+    exit_code?: number;
+}
+/**
+ * Commands list response
+ */
+interface CommandsListResponse {
+    message: string;
+    data: {
+        commands: CommandListItem[];
+        count: number;
+    };
+}
+/**
+ * Code execution response (POST /run/code)
+ */
+interface CodeExecutionResponse {
+    data: {
+        output: string;
+        exit_code: number;
+        language: string;
+    };
+}
+/**
+ * File watcher information
+ */
+interface WatcherInfo {
+    id: string;
+    path: string;
+    includeContent: boolean;
+    ignored: string[];
+    status: 'active' | 'stopped';
+    channel: string;
+    encoding?: 'raw' | 'base64';
+}
+/**
+ * File watcher response
+ */
+interface WatcherResponse {
+    message: string;
+    data: WatcherInfo & {
+        ws_url: string;
+    };
+}
+/**
+ * File watchers list response
+ */
+interface WatchersListResponse {
+    message: string;
+    data: {
+        watchers: WatcherInfo[];
+    };
+}
+/**
+ * Signal service response
+ */
+interface SignalServiceResponse {
+    message: string;
+    data: {
+        status: 'active' | 'stopped';
+        channel: string;
+        ws_url: string;
+    };
+}
+/**
+ * Port signal response
+ */
+interface PortSignalResponse {
+    message: string;
+    data: {
+        port: number;
+        type: 'open' | 'close';
+        url: string;
+    };
+}
+/**
+ * Generic signal response
+ */
+interface GenericSignalResponse {
+    message: string;
+    data: {
+        message: string;
+    };
+}
+/**
+ * Sandbox information
+ */
+interface SandboxInfo {
+    subdomain: string;
+    directory: string;
+    is_main: boolean;
+    created_at: string;
+    url: string;
+    overlays?: SandboxOverlayInfo[];
+    servers?: SandboxServerInfo[];
+}
+/**
+ * Sandboxes list response
+ */
+interface SandboxesListResponse {
+    sandboxes: SandboxInfo[];
+}
+/**
+ * Terminal response
+ */
+interface TerminalResponse {
+    message: string;
+    data: {
+        id: string;
+        pty: boolean;
+        status: 'running' | 'stopped' | 'ready' | 'active';
+        channel?: string;
+        ws_url?: string;
+        encoding?: 'raw' | 'base64';
+    };
+}
+/**
+ * Terminal response
+ */
+interface TerminalResponse {
+    message: string;
+    data: {
+        id: string;
+        pty: boolean;
+        status: 'running' | 'stopped' | 'ready' | 'active';
+        channel?: string;
+        ws_url?: string;
+        encoding?: 'raw' | 'base64';
+    };
+}
+/**
+ * Server status types
+ *
+ * - `installing`: Running install command (e.g., npm install) before starting
+ * - `starting`: Initial startup of the server process
+ * - `running`: Server process is running
+ * - `ready`: Server is running and ready to accept traffic
+ * - `failed`: Server failed to start or encountered a fatal error
+ * - `stopped`: Server was intentionally stopped
+ * - `restarting`: Server is being automatically restarted by the supervisor
+ */
+type ServerStatus = 'installing' | 'starting' | 'running' | 'ready' | 'failed' | 'stopped' | 'restarting';
+/**
+ * Server restart policy
+ * - `never`: No automatic restart (default)
+ * - `on-failure`: Restart only on non-zero exit code
+ * - `always`: Always restart on exit (including exit code 0)
+ */
+type RestartPolicy = 'never' | 'on-failure' | 'always';
+/**
+ * Health check configuration for servers
+ * Polls the server to verify it's responding to requests
+ */
+interface HealthCheckConfig {
+    /** Path to poll for health checks (default: "/") */
+    path?: string;
+    /** Interval between health checks in milliseconds (default: 2000) */
+    interval_ms?: number;
+    /** Timeout for each health check request in milliseconds (default: 1500) */
+    timeout_ms?: number;
+    /** Delay before starting health checks after port detection in milliseconds (default: 5000) */
+    delay_ms?: number;
+}
+/**
+ * Health check status information returned from server
+ */
+interface HealthCheckStatus {
+    /** When the last health check was performed (ISO 8601) */
+    last_check?: string;
+    /** HTTP status code from the last health check */
+    last_status?: number;
+    /** Number of consecutive failed health checks */
+    consecutive_failures: number;
+}
+/**
+ * Server information
+ */
+interface ServerInfo {
+    /** Unique server identifier */
+    slug: string;
+    /** Install command (optional, runs blocking before start) */
+    install?: string;
+    /** Command used to start the server */
+    start: string;
+    /** Working directory path */
+    path: string;
+    /** Original path before resolution */
+    original_path?: string;
+    /** Path to .env file */
+    env_file?: string;
+    /** Inline environment variables */
+    environment?: Record<string, string>;
+    /** Whether to auto-start the server on daemon boot */
+    autostart?: boolean;
+    /** If true, port allocation is strict (no auto-increment) */
+    strict_port?: boolean;
+    /** Overlay IDs this server depends on */
+    depends_on?: string[];
+    /** Auto-detected port number (populated when port monitor detects listening port) */
+    port?: number;
+    /** Generated URL from subdomain + port (populated when port is detected) */
+    url?: string;
+    /** Server lifecycle status */
+    status: ServerStatus;
+    /** Process ID (direct process, not shell wrapper) */
+    pid?: number;
+    /** Configured restart policy */
+    restart_policy?: RestartPolicy;
+    /** Maximum restart attempts (0 = unlimited) */
+    max_restarts?: number;
+    /** Delay between restarts in nanoseconds (input uses milliseconds via restart_delay_ms) */
+    restart_delay?: number;
+    /** Graceful shutdown timeout in nanoseconds (input uses milliseconds via stop_timeout_ms) */
+    stop_timeout?: number;
+    /** Number of times the server has been automatically restarted */
+    restart_count?: number;
+    /** Last exit code (null if process is still running) */
+    exit_code?: number | null;
+    /** Health check configuration (if configured) */
+    health_check?: HealthCheckConfig;
+    /** Whether the server is healthy (only present if health_check is configured) */
+    healthy?: boolean;
+    /** Health check status details (only present if health_check is configured) */
+    health_status?: HealthCheckStatus;
+    /** When the server was created */
+    created_at: string;
+    /** When the server was last updated */
+    updated_at: string;
+}
+/**
+ * Sandbox server info returned by setup flows
+ */
+interface SandboxServerInfo {
+    slug: string;
+    port?: number;
+    url?: string;
+    status: ServerStatus;
+    /** Whether the server is healthy (only present if health_check is configured) */
+    healthy?: boolean;
+    /** Health check status details (only present if health_check is configured) */
+    health_check?: HealthCheckStatus;
+}
+/**
+ * Sandbox overlay info returned by setup flows
+ */
+interface SandboxOverlayInfo {
+    id: string;
+    source: string;
+    target: string;
+    copy_status: string;
+}
+/**
+ * Ready response (public endpoint)
+ */
+interface ReadyResponse {
+    /** Whether all servers have ports allocated (URLs available) */
+    ready: boolean;
+    /** Whether all servers with health checks are passing */
+    healthy?: boolean;
+    servers: SandboxServerInfo[];
+    overlays: SandboxOverlayInfo[];
+}
+/**
+ * Servers list response
+ */
+interface ServersListResponse {
+    status: string;
+    message: string;
+    data: {
+        servers: ServerInfo[];
+    };
+}
+/**
+ * Server response
+ */
+interface ServerResponse {
+    status: string;
+    message: string;
+    data: {
+        server: ServerInfo;
+    };
+}
+/**
+ * Server stop response
+ */
+interface ServerStopResponse {
+    status: string;
+    message: string;
+    data: {
+        slug: string;
+    };
+}
+/**
+ * Server logs stream type
+ */
+type ServerLogStream = 'stdout' | 'stderr' | 'combined';
+/**
+ * Server logs response
+ */
+interface ServerLogsResponse {
+    status: string;
+    message: string;
+    data: {
+        slug: string;
+        stream: ServerLogStream;
+        logs: string;
+    };
+}
+/**
+ * Server status update response
+ */
+interface ServerStatusUpdateResponse {
+    status: string;
+    message: string;
+    data: {
+        slug: string;
+        status: ServerStatus;
+    };
+}
+/**
+ * Environment variables response
+ */
+interface EnvGetResponse {
+    status: string;
+    message: string;
+    data: {
+        file: string;
+        variables: Record<string, string>;
+    };
+}
+/**
+ * Environment set response
+ */
+interface EnvSetResponse {
+    status: string;
+    message: string;
+    data: {
+        file: string;
+        keys: string[];
+    };
+}
+/**
+ * Environment delete response
+ */
+interface EnvDeleteResponse {
+    status: string;
+    message: string;
+    data: {
+        file: string;
+        keys: string[];
+    };
+}
+/**
+ * Batch file operation type
+ */
+type BatchFileOperation = 'write' | 'delete';
+/**
+ * Batch file operation result
+ */
+interface BatchWriteResult {
+    path: string;
+    success: boolean;
+    error?: string;
+    file?: FileInfo;
+}
+/**
+ * Batch file operation response
+ */
+interface BatchWriteResponse {
+    message: string;
+    data: {
+        results: BatchWriteResult[];
+    };
+}
+/**
+ * Sandbox - Full-featured gateway sandbox implementation
+ *
+ * Provides complete feature set including:
+ * - Interactive terminals (PTY and exec modes)
+ * - Managed servers
+ * - File watchers with real-time events
+ * - Authentication (session tokens, magic links)
+ * - Environment management
+ * - Signal service for port/error events
+ * - Child sandbox creation
+ *
+ * This is the most feature-rich implementation available.
+ *
+ * @example
+ * ```typescript
+ * import { Sandbox } from 'computesdk'
+ *
+ * // Pattern 1: Admin operations (requires access token)
+ * const sandbox = new Sandbox({
+ *   sandboxUrl: 'https://sandbox-123.sandbox.computesdk.com',
+ *   token: accessToken, // From edge service
+ * });
+ *
+ * // Create session token for delegated operations
+ * const sessionToken = await sandbox.createSessionToken({
+ *   description: 'My Application',
+ *   expiresIn: 604800, // 7 days
+ * });
+ *
+ * // Pattern 2: Delegated operations (binary protocol by default)
+ * const sandbox2 = new Sandbox({
+ *   sandboxUrl: 'https://sandbox-123.sandbox.computesdk.com',
+ *   token: sessionToken.data.token,
+ *   // protocol: 'binary' is the default (50-90% size reduction)
+ * });
+ *
+ * // Execute a one-off command
+ * const result = await sandbox.execute({ command: 'ls -la' });
+ * console.log(result.data.stdout);
+ *
+ * // Run code
+ * const codeResult = await sandbox.runCode('console.log("Hello!")', 'node');
+ *
+ * // Work with files
+ * const files = await sandbox.listFiles('/home/project');
+ * await sandbox.writeFile('/home/project/test.txt', 'Hello, World!');
+ * const content = await sandbox.readFile('/home/project/test.txt');
+ *
+ * // Create a PTY terminal with real-time output (interactive shell)
+ * const terminal = await sandbox.createTerminal({ pty: true });
+ * terminal.on('output', (data) => console.log(data));
+ * terminal.write('ls -la\n');
+ * await terminal.destroy();
+ *
+ * // Create an exec terminal for command tracking
+ * const execTerminal = await sandbox.createTerminal({ pty: false });
+ * const result = await execTerminal.execute('npm install', { background: true });
+ * const cmd = await sandbox.getCommand(execTerminal.getId(), result.data.cmd_id);
+ * console.log(cmd.data.status); // "running" | "completed" | "failed"
+ * await execTerminal.destroy();
+ *
+ * // Watch for file changes
+ * const watcher = await sandbox.createWatcher('/home/project', {
+ *   ignored: ['node_modules', '.git']
+ * });
+ * watcher.on('change', (event) => {
+ *   console.log(`${event.event}: ${event.path}`);
+ * });
+ * await watcher.destroy();
+ *
+ * // Monitor system signals
+ * const signals = await sandbox.startSignals();
+ * signals.on('port', (event) => {
+ *   console.log(`Port ${event.port} opened: ${event.url}`);
+ * });
+ * await signals.stop();
+ *
+ * // Clean up
+ * await sandbox.disconnect();
+ * ```
+ */
+declare class Sandbox {
+    readonly sandboxId: string;
+    readonly provider: string;
+    readonly filesystem: ExtendedFileSystem;
+    readonly terminal: Terminal;
+    readonly run: Run;
+    readonly server: Server;
+    readonly watcher: Watcher;
+    readonly sessionToken: SessionToken;
+    readonly magicLink: MagicLink;
+    readonly signal: Signal;
+    readonly file: File;
+    readonly env: Env;
+    readonly auth: Auth;
+    readonly child: Child;
+    private config;
+    private _token;
+    private _ws;
+    private WebSocketImpl;
+    private _terminals;
+    constructor(config: SandboxConfig);
+    /**
+     * Get or create internal WebSocket manager
+     */
+    private ensureWebSocket;
+    /**
+     * Create and configure a TerminalInstance from response data
+     */
+    private hydrateTerminal;
+    private request;
+    /**
+     * Check service health
+     */
+    health(): Promise<HealthResponse>;
+    /**
+     * Create a session token (requires access token)
+     *
+     * Session tokens are delegated credentials that can authenticate API requests
+     * without exposing your access token. Only access tokens can create session tokens.
+     *
+     * @param options - Token configuration
+     * @throws {Error} 403 Forbidden if called with a session token
+     */
+    createSessionToken(options?: {
+        description?: string;
+        expiresIn?: number;
+    }): Promise<SessionTokenResponse>;
+    /**
+     * List all session tokens (requires access token)
+     *
+     * @throws {Error} 403 Forbidden if called with a session token
+     */
+    listSessionTokens(): Promise<SessionTokenListResponse>;
+    /**
+     * Get details of a specific session token (requires access token)
+     *
+     * @param tokenId - The token ID
+     * @throws {Error} 403 Forbidden if called with a session token
+     */
+    getSessionToken(tokenId: string): Promise<SessionTokenResponse>;
+    /**
+     * Revoke a session token (requires access token)
+     *
+     * @param tokenId - The token ID to revoke
+     * @throws {Error} 403 Forbidden if called with a session token
+     */
+    revokeSessionToken(tokenId: string): Promise<void>;
+    /**
+     * Generate a magic link for browser authentication (requires access token)
+     *
+     * Magic links are one-time URLs that automatically create a session token
+     * and set it as a cookie in the user's browser. This provides an easy way
+     * to authenticate users in browser-based applications.
+     *
+     * The generated link:
+     * - Expires after 5 minutes or first use (whichever comes first)
+     * - Automatically creates a new session token (7 day expiry)
+     * - Sets the session token as an HttpOnly cookie
+     * - Redirects to the specified URL
+     *
+     * @param options - Magic link configuration
+     * @throws {Error} 403 Forbidden if called with a session token
+     */
+    createMagicLink(options?: {
+        redirectUrl?: string;
+    }): Promise<MagicLinkResponse>;
+    /**
+     * Check authentication status
+     * Does not require authentication
+     */
+    getAuthStatus(): Promise<AuthStatusResponse>;
+    /**
+     * Get authentication information and usage instructions
+     * Does not require authentication
+     */
+    getAuthInfo(): Promise<AuthInfoResponse>;
+    /**
+     * Set authentication token manually
+     * @param token - Access token or session token
+     */
+    setToken(token: string): void;
+    /**
+     * Get current authentication token
+     */
+    getToken(): string | null;
+    /**
+     * Get current sandbox URL
+     */
+    getSandboxUrl(): string;
+    /**
+     * Execute a one-off command without creating a persistent terminal
+     *
+     * @example
+     * ```typescript
+     * // Synchronous execution (waits for completion)
+     * const result = await sandbox.execute({ command: 'npm test' });
+     * console.log(result.data.exit_code);
+     *
+     * // Background execution (returns immediately)
+     * const result = await sandbox.execute({
+     *   command: 'npm install',
+     *   background: true
+     * });
+     * // Use result.data.terminal_id and result.data.cmd_id to track
+     * const cmd = await sandbox.getCommand(result.data.terminal_id!, result.data.cmd_id!);
+     * ```
+     */
+    execute(options: {
+        command: string;
+        shell?: string;
+        background?: boolean;
+    }): Promise<CommandExecutionResponse>;
+    /**
+     * Execute code with automatic language detection (POST /run/code)
+     *
+     * @param code - The code to execute
+     * @param language - Programming language (optional - auto-detects if not specified)
+     * @returns Code execution result with output, exit code, and detected language
+     *
+     * @example
+     * ```typescript
+     * // Auto-detect language
+     * const result = await sandbox.runCodeRequest('print("Hello")');
+     * console.log(result.data.output); // "Hello\n"
+     * console.log(result.data.language); // "python"
+     *
+     * // Explicit language
+     * const result = await sandbox.runCodeRequest('console.log("Hi")', 'node');
+     * ```
+     */
+    runCodeRequest(code: string, language?: string): Promise<CodeExecutionResponse>;
+    /**
+     * Execute a command and get the result
+     * Lower-level method that returns the raw API response
+     *
+     * @param options.command - Command to execute
+     * @param options.shell - Shell to use (optional)
+     * @param options.background - Run in background (optional)
+     * @param options.cwd - Working directory for the command (optional)
+     * @param options.env - Environment variables (optional)
+     * @returns Command execution result
+     *
+     * @example
+     * ```typescript
+     * const result = await sandbox.runCommandRequest({ command: 'ls -la' });
+     * console.log(result.data.stdout);
+     * ```
+     */
+    runCommandRequest(options: {
+        command: string;
+        shell?: string;
+        background?: boolean;
+        stream?: boolean;
+        cwd?: string;
+        env?: Record<string, string>;
+    }): Promise<CommandExecutionResponse>;
+    /**
+     * List files at the specified path
+     */
+    listFiles(path?: string): Promise<FilesListResponse>;
+    /**
+     * Create a new file with optional content
+     */
+    createFile(path: string, content?: string): Promise<FileResponse>;
+    /**
+     * Get file metadata (without content)
+     */
+    getFile(path: string): Promise<FileResponse>;
+    /**
+     * Encode a file path for use in URLs
+     * Strips leading slash and encodes each segment separately to preserve path structure
+     */
+    private encodeFilePath;
+    /**
+     * Read file content
+     */
+    readFile(path: string): Promise<string>;
+    /**
+     * Write file content (creates or updates)
+     */
+    writeFile(path: string, content: string): Promise<FileResponse>;
+    /**
+     * Delete a file or directory
+     */
+    deleteFile(path: string): Promise<void>;
+    /**
+     * Check if a file exists (HEAD request)
+     * @returns true if file exists, false otherwise
+     */
+    checkFileExists(path: string): Promise<boolean>;
+    /**
+     * Batch file operations (write or delete multiple files)
+     *
+     * Features:
+     * - Deduplication: Last operation wins per path
+     * - File locking: Prevents race conditions
+     * - Deterministic ordering: Alphabetical path sorting
+     * - Partial failure handling: Returns 207 Multi-Status with per-file results
+     *
+     * @param files - Array of file operations
+     * @returns Results for each file operation
+     *
+     * @example
+     * ```typescript
+     * // Write multiple files
+     * const results = await sandbox.batchWriteFiles([
+     *   { path: '/app/file1.txt', operation: 'write', content: 'Hello' },
+     *   { path: '/app/file2.txt', operation: 'write', content: 'World' },
+     * ]);
+     *
+     * // Mixed operations (write and delete)
+     * const results = await sandbox.batchWriteFiles([
+     *   { path: '/app/new.txt', operation: 'write', content: 'New file' },
+     *   { path: '/app/old.txt', operation: 'delete' },
+     * ]);
+     * ```
+     */
+    batchWriteFiles(files: Array<{
+        path: string;
+        operation: 'write' | 'delete';
+        content?: string;
+    }>): Promise<BatchWriteResponse>;
+    /**
+     * Create a new filesystem overlay from a template directory
+     *
+     * Overlays enable instant sandbox setup by symlinking template files first,
+     * then copying heavy directories (node_modules, .venv, etc.) in the background.
+     *
+     * @param options - Overlay creation options
+     * @param options.source - Absolute path to source directory (template)
+     * @param options.target - Relative path in sandbox where overlay will be mounted
+     * @returns Overlay response with copy status
+     *
+     * @example
+     * ```typescript
+     * // Prefer using sandbox.filesystem.overlay.create() for camelCase response
+     * const overlay = await sandbox.filesystem.overlay.create({
+     *   source: '/templates/nextjs',
+     *   target: 'project',
+     * });
+     * console.log(overlay.copyStatus); // 'pending' | 'in_progress' | 'complete' | 'failed'
+     * ```
+     */
+    createOverlay(options: CreateOverlayOptions): Promise<OverlayResponse>;
+    /**
+     * List all filesystem overlays for the current sandbox
+     * @returns List of overlays with their copy status
+     */
+    listOverlays(): Promise<OverlayListResponse>;
+    /**
+     * Get a specific filesystem overlay by ID
+     *
+     * Useful for polling the copy status of an overlay.
+     *
+     * @param id - Overlay ID
+     * @returns Overlay details with current copy status
+     */
+    getOverlay(id: string): Promise<OverlayResponse>;
+    /**
+     * Delete a filesystem overlay
+     * @param id - Overlay ID
+     */
+    deleteOverlay(id: string): Promise<void>;
+    /**
+     * Create a new persistent terminal session
+     *
+     * Terminal Modes:
+     * - **PTY mode** (pty: true): Interactive shell with real-time WebSocket streaming
+     *   - Use for: Interactive shells, vim/nano, real-time output
+     *   - Methods: write(), resize(), on('output')
+     *
+     * - **Exec mode** (pty: false, default): Command tracking with HTTP polling
+     *   - Use for: CI/CD, automation, command tracking, exit codes
+     *   - Methods: execute(), getCommand(), listCommands(), waitForCommand()
+     *
+     * @example
+     * ```typescript
+     * // PTY mode - Interactive shell
+     * const pty = await sandbox.createTerminal({ pty: true, shell: '/bin/bash' });
+     * pty.on('output', (data) => console.log(data));
+     * pty.write('npm install\n');
+     *
+     * // Exec mode - Command tracking
+     * const exec = await sandbox.createTerminal({ pty: false });
+     * const result = await exec.execute('npm test', { background: true });
+     * const cmd = await sandbox.waitForCommand(exec.getId(), result.data.cmd_id);
+     * console.log(cmd.data.exit_code);
+     *
+     * // Backward compatible - creates PTY terminal
+     * const terminal = await sandbox.createTerminal('/bin/bash');
+     * ```
+     *
+     * @param options - Terminal creation options
+     * @param options.shell - Shell to use (e.g., '/bin/bash', '/bin/sh') - PTY mode only
+     * @param options.encoding - Encoding for terminal I/O: 'raw' (default) or 'base64' (binary-safe)
+     * @param options.pty - Terminal mode: true = PTY (interactive shell), false = exec (command tracking, default)
+     * @returns Terminal instance with event handling
+     */
+    createTerminal(shellOrOptions?: string | {
+        shell?: string;
+        encoding?: 'raw' | 'base64';
+        pty?: boolean;
+    }, encoding?: 'raw' | 'base64'): Promise<TerminalInstance>;
+    /**
+     * List all active terminals (fetches from API)
+     */
+    listTerminals(): Promise<TerminalResponse[]>;
+    /**
+     * Get terminal by ID
+     */
+    getTerminal(id: string): Promise<TerminalInstance>;
+    /**
+     * List all commands executed in a terminal (exec mode only)
+     * @param terminalId - The terminal ID
+     * @returns List of all commands with their status
+     * @throws {Error} If terminal is in PTY mode (command tracking not available)
+     */
+    listCommands(terminalId: string): Promise<CommandsListResponse>;
+    /**
+     * Get details of a specific command execution (exec mode only)
+     * @param terminalId - The terminal ID
+     * @param cmdId - The command ID
+     * @returns Command execution details including stdout, stderr, and exit code
+     * @throws {Error} If terminal is in PTY mode or command not found
+     */
+    getCommand(terminalId: string, cmdId: string): Promise<CommandDetailsResponse>;
+    /**
+     * Wait for a command to complete (HTTP long-polling, exec mode only)
+     * @param terminalId - The terminal ID
+     * @param cmdId - The command ID
+     * @param timeout - Optional timeout in seconds (0 = no timeout)
+     * @returns Command execution details when completed
+     * @throws {Error} If terminal is in PTY mode, command not found, or timeout occurs
+     */
+    waitForCommand(terminalId: string, cmdId: string, timeout?: number): Promise<CommandDetailsResponse>;
+    /**
+     * Wait for a background command to complete using long-polling
+     *
+     * Uses the server's long-polling endpoint with configurable timeout.
+     * The tunnel supports up to 5 minutes (300 seconds) via X-Request-Timeout header.
+     *
+     * @param terminalId - The terminal ID
+     * @param cmdId - The command ID
+     * @param options - Wait options (timeoutSeconds, default 300)
+     * @returns Command result with final status
+     * @throws Error if command fails or times out
+     * @internal
+     */
+    private waitForCommandCompletion;
+    /**
+     * Wait for a command with extended timeout support
+     * Uses X-Request-Timeout header for tunnel timeout configuration
+     * @internal
+     */
+    private waitForCommandWithTimeout;
+    /**
+     * Create a new file watcher with WebSocket integration
+     * @param path - Path to watch
+     * @param options - Watcher options
+     * @param options.includeContent - Include file content in change events
+     * @param options.ignored - Patterns to ignore
+     * @param options.encoding - Encoding for file content: 'raw' (default) or 'base64' (binary-safe)
+     * @returns FileWatcher instance with event handling
+     */
+    createWatcher(path: string, options?: {
+        includeContent?: boolean;
+        ignored?: string[];
+        encoding?: 'raw' | 'base64';
+    }): Promise<FileWatcher>;
+    /**
+     * List all active file watchers (fetches from API)
+     */
+    listWatchers(): Promise<WatchersListResponse>;
+    /**
+     * Get file watcher by ID
+     */
+    getWatcher(id: string): Promise<WatcherResponse>;
+    /**
+     * Start the signal service with WebSocket integration
+     * @returns SignalService instance with event handling
+     */
+    startSignals(): Promise<SignalService>;
+    /**
+     * Get the signal service status (fetches from API)
+     */
+    getSignalStatus(): Promise<SignalServiceResponse>;
+    /**
+     * Emit a port signal
+     */
+    emitPortSignal(port: number, type: 'open' | 'close', url: string): Promise<PortSignalResponse>;
+    /**
+     * Emit a port signal (alternative endpoint using path parameters)
+     */
+    emitPortSignalAlt(port: number, type: 'open' | 'close'): Promise<PortSignalResponse>;
+    /**
+     * Emit an error signal
+     */
+    emitErrorSignal(message: string): Promise<GenericSignalResponse>;
+    /**
+     * Emit a server ready signal
+     */
+    emitServerReadySignal(port: number, url: string): Promise<PortSignalResponse>;
+    /**
+     * Get environment variables from a .env file
+     * @param file - Path to the .env file (relative to sandbox root)
+     */
+    getEnv(file: string): Promise<EnvGetResponse>;
+    /**
+     * Set (merge) environment variables in a .env file
+     * @param file - Path to the .env file (relative to sandbox root)
+     * @param variables - Key-value pairs to set
+     */
+    setEnv(file: string, variables: Record<string, string>): Promise<EnvSetResponse>;
+    /**
+     * Delete environment variables from a .env file
+     * @param file - Path to the .env file (relative to sandbox root)
+     * @param keys - Keys to delete
+     */
+    deleteEnv(file: string, keys: string[]): Promise<EnvDeleteResponse>;
+    /**
+     * Check if an environment file exists (HEAD request)
+     * @param file - Path to the .env file (relative to sandbox root)
+     * @returns true if file exists, false otherwise
+     */
+    checkEnvFile(file: string): Promise<boolean>;
+    /**
+     * List all managed servers
+     */
+    listServers(): Promise<ServersListResponse>;
+    /**
+     * Start a new managed server with optional supervisor settings
+     *
+     * @param options - Server configuration
+     * @param options.slug - Unique server identifier
+     * @param options.install - Install command (optional, runs blocking before start, e.g., "npm install")
+     * @param options.start - Command to start the server (e.g., "npm run dev")
+     * @param options.path - Working directory (optional)
+     * @param options.env_file - Path to .env file relative to path (optional)
+     * @param options.environment - Inline environment variables (merged with env_file if both provided)
+     * @param options.port - Requested port (preallocated before start)
+     * @param options.strict_port - If true, fail instead of auto-incrementing when port is taken
+     * @param options.autostart - Auto-start on daemon boot (default: true)
+     * @param options.overlay - Inline overlay to create before starting
+     * @param options.overlays - Additional overlays to create before starting
+     * @param options.depends_on - Overlay IDs this server depends on
+     * @param options.restart_policy - When to automatically restart: 'never' (default), 'on-failure', 'always'
+     * @param options.max_restarts - Maximum restart attempts, 0 = unlimited (default: 0)
+     * @param options.restart_delay_ms - Delay between restart attempts in milliseconds (default: 1000)
+     * @param options.stop_timeout_ms - Graceful shutdown timeout in milliseconds (default: 10000)
+     *
+     * @example
+     * ```typescript
+     * // Basic server
+     * await sandbox.startServer({
+     *   slug: 'web',
+     *   start: 'npm run dev',
+     *   path: '/app',
+     * });
+     *
+     * // With install command and supervisor settings
+     * await sandbox.startServer({
+     *   slug: 'api',
+     *   install: 'npm install',
+     *   start: 'node server.js',
+     *   path: '/app',
+     *   environment: { NODE_ENV: 'production', PORT: '3000' },
+     *   restart_policy: 'on-failure',
+     *   max_restarts: 5,
+     *   restart_delay_ms: 2000,
+     *   stop_timeout_ms: 5000,
+     * });
+     *
+     * // With inline overlay dependencies
+     * await sandbox.startServer({
+     *   slug: 'web',
+     *   start: 'npm run dev',
+     *   path: '/app',
+     *   overlay: {
+     *     source: '/templates/nextjs',
+     *     target: 'app',
+     *     strategy: 'smart',
+     *   },
+     * });
+     * ```
+     */
+    startServer(options: {
+        slug: string;
+        install?: string;
+        start: string;
+        path?: string;
+        env_file?: string;
+        environment?: Record<string, string>;
+        port?: number;
+        strict_port?: boolean;
+        autostart?: boolean;
+        overlay?: Omit<CreateOverlayOptions, 'waitForCompletion'>;
+        overlays?: Array<Omit<CreateOverlayOptions, 'waitForCompletion'>>;
+        depends_on?: string[];
+        restart_policy?: RestartPolicy;
+        max_restarts?: number;
+        restart_delay_ms?: number;
+        stop_timeout_ms?: number;
+    }): Promise<ServerResponse>;
+    /**
+     * Get information about a specific server
+     * @param slug - Server slug
+     */
+    getServer(slug: string): Promise<ServerResponse>;
+    /**
+     * Stop a managed server (non-destructive)
+     * @param slug - Server slug
+     */
+    stopServer(slug: string): Promise<ServerStopResponse>;
+    /**
+     * Delete a managed server configuration
+     * @param slug - Server slug
+     */
+    deleteServer(slug: string): Promise<void>;
+    /**
+     * Restart a managed server
+     * @param slug - Server slug
+     */
+    restartServer(slug: string): Promise<ServerResponse>;
+    /**
+     * Get logs for a managed server
+     * @param slug - Server slug
+     * @param options - Options for log retrieval
+     */
+    getServerLogs(slug: string, options?: {
+        stream?: ServerLogStream;
+    }): Promise<ServerLogsResponse>;
+    /**
+     * Update server status (internal use)
+     * @param slug - Server slug
+     * @param status - New server status
+     */
+    updateServerStatus(slug: string, status: ServerStatus): Promise<ServerStatusUpdateResponse>;
+    /**
+     * Get readiness status for autostarted servers and overlays
+     */
+    ready(): Promise<ReadyResponse>;
+    /**
+     * Create a new sandbox environment
+     */
+    createSandbox(options?: CreateSandboxOptions$1): Promise<SandboxInfo>;
+    /**
+     * List all sandboxes
+     */
+    listSandboxes(): Promise<SandboxesListResponse>;
+    /**
+     * Get sandbox details
+     */
+    getSandbox(subdomain: string): Promise<SandboxInfo>;
+    /**
+     * Delete a sandbox
+     */
+    deleteSandbox(subdomain: string, deleteFiles?: boolean): Promise<void>;
+    /**
+     * Get WebSocket URL for real-time communication
+     * @private
+     */
+    private getWebSocketUrl;
+    /**
+     * Execute code in the sandbox (convenience method)
+     *
+     * Delegates to sandbox.run.code() - prefer using that directly for new code.
+     *
+     * @param code - The code to execute
+     * @param language - Programming language (auto-detected if not specified)
+     * @returns Code execution result
+     */
+    runCode(code: string, language?: 'node' | 'python'): Promise<{
+        output: string;
+        exitCode: number;
+        language: string;
+    }>;
+    /**
+     * Execute shell command in the sandbox
+     *
+     * Sends clean command string to server - no preprocessing or shell wrapping.
+     * The server handles shell invocation, working directory, and backgrounding.
+     *
+     * @param command - The command to execute (raw string, e.g., "npm install")
+     * @param options - Execution options
+     * @param options.background - Run in background (server uses goroutines)
+     * @param options.cwd - Working directory (server uses cmd.Dir)
+     * @param options.env - Environment variables (server uses cmd.Env)
+     * @param options.onStdout - Callback for streaming stdout data
+     * @param options.onStderr - Callback for streaming stderr data
+     * @returns Command execution result
+     *
+     * @example
+     * ```typescript
+     * // Simple command
+     * await sandbox.runCommand('ls -la')
+     *
+     * // With working directory
+     * await sandbox.runCommand('npm install', { cwd: '/app' })
+     *
+     * // Background with env vars
+     * await sandbox.runCommand('node server.js', {
+     *   background: true,
+     *   env: { PORT: '3000' }
+     * })
+     *
+     * // With streaming output
+     * await sandbox.runCommand('npm install', {
+     *   onStdout: (data) => console.log(data),
+     *   onStderr: (data) => console.error(data),
+     * })
+     * ```
+     */
+    runCommand(command: string, options?: {
+        background?: boolean;
+        cwd?: string;
+        env?: Record<string, string>;
+        onStdout?: (data: string) => void;
+        onStderr?: (data: string) => void;
+    }): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        durationMs: number;
+    }>;
+    /**
+     * Get server information
+     * Returns details about the server including auth status, main subdomain, sandbox count, and version
+     */
+    getServerInfo(): Promise<InfoResponse>;
+    /**
+     * Get sandbox information
+     */
+    getInfo(): Promise<{
+        id: string;
+        provider: string;
+        runtime: 'node' | 'python';
+        status: 'running' | 'stopped' | 'error';
+        createdAt: Date;
+        timeout: number;
+        metadata?: Record<string, any>;
+    }>;
+    /**
+     * Get URL for accessing sandbox on a specific port (Sandbox interface method)
+     */
+    getUrl(options: {
+        port: number;
+        protocol?: string;
+    }): Promise<string>;
+    /**
+     * Get provider instance
+     * Note: Not available when using Sandbox directly - only available through gateway provider
+     */
+    getProvider(): never;
+    /**
+     * Get native provider instance
+     * Returns the Sandbox itself since this IS the sandbox implementation
+     */
+    getInstance(): this;
+    /**
+     * Destroy the sandbox (Sandbox interface method)
+     *
+     * If a destroyHandler was provided (e.g., from gateway), calls it to destroy
+     * the sandbox on the backend. Otherwise, only disconnects the WebSocket.
+     */
+    destroy(): Promise<void>;
+    /**
+     * Disconnect WebSocket
+     *
+     * Note: This only disconnects the WebSocket. Terminals, watchers, and signals
+     * will continue running on the server until explicitly destroyed via their
+     * respective destroy() methods or the DELETE endpoints.
+     */
+    disconnect(): Promise<void>;
+}
+
+/**
+ * Helpers for building setup payloads used by COMPUTESDK_SETUP_B64 or POST /sandboxes
+ */
+
+type SetupOverlayConfig = Omit<CreateOverlayOptions, 'waitForCompletion'>;
+interface SetupPayload {
+    overlays?: SetupOverlayConfig[];
+    servers?: ServerStartOptions[];
+}
+interface BuildSetupPayloadOptions {
+    overlays?: CreateOverlayOptions[];
+    servers?: ServerStartOptions[];
+}
+/**
+ * Build a setup payload for COMPUTESDK_SETUP_B64 or POST /sandboxes
+ */
+declare const buildSetupPayload: (options: BuildSetupPayloadOptions) => SetupPayload;
+/**
+ * Build and base64-encode a setup payload for COMPUTESDK_SETUP_B64
+ */
+declare const encodeSetupPayload: (options: BuildSetupPayloadOptions) => string;
+
+/**
+ * Unified Provider Configuration
+ *
+ * Single source of truth for all provider auth requirements.
+ * Used by both explicit mode (computesdk) and magic mode (workbench).
+ */
+/**
+ * Provider auth requirements
+ *
+ * Structure: { provider: [[option1_vars], [option2_vars], ...] }
+ * - Outer array: OR conditions (any option can satisfy auth)
+ * - Inner arrays: AND conditions (all vars in option must be present)
+ *
+ * Example: vercel: [['OIDC_TOKEN'], ['TOKEN', 'TEAM_ID', 'PROJECT_ID']]
+ *   -> Ready if OIDC_TOKEN is set, OR if all three traditional vars are set
+ */
+declare const PROVIDER_AUTH: {
+    readonly e2b: readonly [readonly ["E2B_API_KEY"]];
+    readonly modal: readonly [readonly ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"]];
+    readonly railway: readonly [readonly ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"]];
+    readonly render: readonly [readonly ["RENDER_API_KEY", "RENDER_OWNER_ID"]];
+    readonly daytona: readonly [readonly ["DAYTONA_API_KEY"]];
+    readonly vercel: readonly [readonly ["VERCEL_OIDC_TOKEN"], readonly ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"]];
+    readonly runloop: readonly [readonly ["RUNLOOP_API_KEY"]];
+    readonly cloudflare: readonly [readonly ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"]];
+    readonly codesandbox: readonly [readonly ["CSB_API_KEY"]];
+    readonly blaxel: readonly [readonly ["BL_API_KEY", "BL_WORKSPACE"]];
+    readonly namespace: readonly [readonly ["NSC_TOKEN"]];
+};
+/**
+ * All supported provider names (excluding gateway which is special)
+ */
+declare const PROVIDER_NAMES: ProviderName[];
+/**
+ * Provider name type derived from PROVIDER_AUTH
+ */
+type ProviderName = keyof typeof PROVIDER_AUTH;
+/**
+ * Header mapping for each provider
+ * Maps config field names to HTTP header names
+ */
+declare const PROVIDER_HEADERS: Record<ProviderName, Record<string, string>>;
+/**
+ * Environment variable to config field mapping for each provider
+ */
+declare const PROVIDER_ENV_MAP: Record<ProviderName, Record<string, string>>;
+/**
+ * Dashboard URLs for each provider (for error messages)
+ */
+declare const PROVIDER_DASHBOARD_URLS: Record<ProviderName, string>;
+/**
+ * Check if a provider name is valid
+ */
+declare function isValidProvider(name: string): name is ProviderName;
+/**
+ * Build headers from provider config
+ */
+declare function buildProviderHeaders(provider: ProviderName, config: Record<string, string | undefined>): Record<string, string>;
+/**
+ * Get provider config from environment variables
+ */
+declare function getProviderConfigFromEnv(provider: ProviderName): Record<string, string>;
+/**
+ * Check if provider has complete auth from environment
+ */
+declare function isProviderAuthComplete(provider: ProviderName): boolean;
+/**
+ * Get missing env vars for a provider (returns the option closest to completion)
+ */
+declare function getMissingEnvVars(provider: ProviderName): string[];
+
+/**
+ * Compute API - Gateway HTTP Implementation
+ *
+ * Provides the unified compute.* API using direct HTTP calls to the gateway.
+ * The `compute` export works as both a singleton and a callable function:
+ *
+ * - Singleton: `compute.sandbox.create()` (auto-detects from env vars)
+ * - Callable: `compute({ provider: 'e2b', ... }).sandbox.create()` (explicit config)
+ */
+
+/**
+ * Explicit compute configuration for callable mode
+ */
+interface ExplicitComputeConfig {
+    /** Provider name to use */
+    provider: ProviderName;
+    /**
+     * ComputeSDK API key (required for gateway mode)
+     * @deprecated Use `computesdkApiKey` for clarity
+     */
+    apiKey?: string;
+    /** ComputeSDK API key (required for gateway mode) */
+    computesdkApiKey?: string;
+    /** Optional gateway URL override */
+    gatewayUrl?: string;
+    /** HTTP request timeout for gateway calls in milliseconds */
+    requestTimeoutMs?: number;
+    /**
+     * WebSocket implementation for environments without native WebSocket support.
+     * In Node.js < 22, pass the 'ws' package: `import WebSocket from 'ws'`
+     */
+    WebSocket?: WebSocketConstructor;
+    /** Provider-specific configurations */
+    e2b?: {
+        apiKey?: string;
+        projectId?: string;
+        templateId?: string;
+    };
+    modal?: {
+        tokenId?: string;
+        tokenSecret?: string;
+    };
+    railway?: {
+        apiToken?: string;
+        projectId?: string;
+        environmentId?: string;
+    };
+    render?: {
+        apiKey?: string;
+        serviceId?: string;
+    };
+    daytona?: {
+        apiKey?: string;
+    };
+    vercel?: {
+        oidcToken?: string;
+        token?: string;
+        teamId?: string;
+        projectId?: string;
+    };
+    runloop?: {
+        apiKey?: string;
+    };
+    cloudflare?: {
+        apiToken?: string;
+        accountId?: string;
+    };
+    codesandbox?: {
+        apiKey?: string;
+    };
+    blaxel?: {
+        apiKey?: string;
+        workspace?: string;
+    };
+    namespace?: {
+        token?: string;
+    };
+}
+/**
+ * Options for creating a sandbox via the gateway
+ *
+ * Note: Runtime is determined by the provider, not specified at creation time.
+ * Use sandbox.runCode(code, runtime) to specify which runtime to use for execution.
+ */
+interface CreateSandboxOptions {
+    timeout?: number;
+    templateId?: string;
+    metadata?: Record<string, any>;
+    envs?: Record<string, string>;
+    name?: string;
+    namespace?: string;
+    directory?: string;
+    overlays?: SetupOverlayConfig[];
+    servers?: ServerStartOptions[];
+    /** Docker image to use for the sandbox (for infrastructure providers like Railway) */
+    image?: string;
+    /** Provider-specific snapshot to create from (e.g., Vercel snapshots) */
+    snapshotId?: string;
+}
+/**
+ * Options for finding or creating a named sandbox
+ */
+interface FindOrCreateSandboxOptions extends CreateSandboxOptions {
+    name: string;
+    namespace?: string;
+}
+/**
+ * Options for finding a named sandbox
+ */
+interface FindSandboxOptions {
+    name: string;
+    namespace?: string;
+}
+/**
+ * Options for extending sandbox timeout
+ */
+interface ExtendTimeoutOptions {
+    duration?: number;
+}
+/**
+ * Compute singleton implementation
+ */
+declare class ComputeManager {
+    private config;
+    private autoConfigured;
+    /**
+     * Lazy auto-configure from environment if not explicitly configured
+     */
+    private ensureConfigured;
+    /**
+     * Get gateway config, throwing if not configured
+     */
+    private getGatewayConfig;
+    /**
+     * Explicitly configure the compute singleton
+     *
+     * @example
+     * ```typescript
+     * import { compute } from 'computesdk';
+     *
+     * compute.setConfig({
+     *   provider: 'e2b',
+     *   apiKey: 'computesdk_xxx',
+     *   e2b: { apiKey: 'e2b_xxx' }
+     * });
+     *
+     * const sandbox = await compute.sandbox.create();
+     * ```
+     */
+    setConfig(config: ExplicitComputeConfig): void;
+    sandbox: {
+        /**
+         * Create a new sandbox
+         *
+         * @example
+         * ```typescript
+         * const sandbox = await compute.sandbox.create({
+         *   directory: '/custom/path',
+         *   overlays: [
+         *     {
+         *       source: '/templates/nextjs',
+         *       target: 'app',
+         *       strategy: 'smart',
+         *     },
+         *   ],
+         *   servers: [
+         *     {
+         *       slug: 'web',
+         *       start: 'npm run dev',
+         *       path: '/app',
+         *     },
+         *   ],
+         * });
+         * ```
+         */
+        create: (options?: CreateSandboxOptions) => Promise<Sandbox>;
+        /**
+         * Get an existing sandbox by ID
+         */
+        getById: (sandboxId: string) => Promise<Sandbox | null>;
+        /**
+         * List all active sandboxes
+         */
+        list: () => Promise<Sandbox[]>;
+        /**
+         * Destroy a sandbox
+         */
+        destroy: (sandboxId: string) => Promise<void>;
+        /**
+         * Find existing or create new sandbox by (namespace, name)
+         */
+        findOrCreate: (options: FindOrCreateSandboxOptions) => Promise<Sandbox>;
+        /**
+         * Find existing sandbox by (namespace, name) without creating
+         */
+        find: (options: FindSandboxOptions) => Promise<Sandbox | null>;
+        /**
+         * Extend sandbox timeout/expiration
+         */
+        extendTimeout: (sandboxId: string, options?: ExtendTimeoutOptions) => Promise<void>;
+    };
+}
+/**
+ * Callable compute interface - dual nature as both singleton and factory
+ *
+ * This interface represents the compute export's two modes:
+ * 1. As a ComputeManager singleton (accessed via properties like compute.sandbox)
+ * 2. As a factory function (called with config to create new instances)
+ */
+interface CallableCompute extends ComputeManager {
+    /** Create a new compute instance with explicit configuration */
+    (config: ExplicitComputeConfig): ComputeManager;
+    /** Explicitly configure the singleton */
+    setConfig(config: ExplicitComputeConfig): void;
+}
+/**
+ * Callable compute - works as both singleton and factory function
+ *
+ * @example
+ * ```typescript
+ * import { compute } from 'computesdk';
+ *
+ * // Singleton mode (auto-detects from env vars)
+ * const sandbox1 = await compute.sandbox.create();
+ *
+ * // Callable mode (explicit config)
+ * const sandbox2 = await compute({
+ *   provider: 'e2b',
+ *   apiKey: 'computesdk_xxx',
+ *   e2b: { apiKey: 'e2b_xxx' }
+ * }).sandbox.create();
+ * ```
+ */
+declare const compute: CallableCompute;
+
+/**
+ * Auto-Detection Module
+ *
+ * Automatically detects gateway mode and provider from environment variables.
+ * Enables zero-config usage of ComputeSDK.
+ */
+
+/**
+ * Check if gateway mode is enabled
+ * Gateway mode requires COMPUTESDK_API_KEY to be set
+ */
+declare function isGatewayModeEnabled(): boolean;
+/**
+ * Detect which provider to use from environment variables
+ *
+ * Detection order:
+ * 1. Check for explicit COMPUTESDK_PROVIDER override
+ * 2. Auto-detect based on PROVIDER_PRIORITY order
+ *
+ * @returns Provider name or null if none detected
+ */
+declare function detectProvider(): string | null;
+/**
+ * Build provider-specific headers from environment variables
+ * These headers are passed through to the gateway
+ */
+declare function getProviderHeaders(provider: string): Record<string, string>;
+/**
+ * Gateway configuration object
+ */
+interface GatewayConfig {
+    apiKey: string;
+    gatewayUrl: string;
+    provider: string;
+    providerHeaders: Record<string, string>;
+    requestTimeoutMs?: number;
+    WebSocket?: WebSocketConstructor;
+}
+/**
+ * Main auto-configuration function
+ * Returns gateway configuration or null if auto-detection not possible
+ *
+ * @throws Error if COMPUTESDK_API_KEY is set but no provider detected
+ */
+declare function autoConfigureCompute(): GatewayConfig | null;
+
+/**
+ * ComputeSDK Constants
+ *
+ * Default configuration values and provider definitions
+ */
+
+/**
+ * Default gateway URL for sandbox lifecycle operations
+ */
+declare const GATEWAY_URL = "https://gateway.computesdk.com";
+/**
+ * Provider detection priority order
+ * When multiple provider credentials are detected, use the first one in this list
+ */
+declare const PROVIDER_PRIORITY: readonly ["e2b", "railway", "render", "daytona", "modal", "runloop", "vercel", "cloudflare", "codesandbox", "blaxel", "namespace"];
+/**
+ * Required environment variables for each provider
+ * @deprecated Use PROVIDER_AUTH from provider-config instead
+ */
+declare const PROVIDER_ENV_VARS: {
+    readonly e2b: readonly ["E2B_API_KEY"];
+    readonly railway: readonly ["RAILWAY_API_KEY", "RAILWAY_PROJECT_ID", "RAILWAY_ENVIRONMENT_ID"];
+    readonly render: readonly ["RENDER_API_KEY", "RENDER_OWNER_ID"];
+    readonly daytona: readonly ["DAYTONA_API_KEY"];
+    readonly modal: readonly ["MODAL_TOKEN_ID", "MODAL_TOKEN_SECRET"];
+    readonly runloop: readonly ["RUNLOOP_API_KEY"];
+    readonly vercel: readonly ["VERCEL_TOKEN", "VERCEL_TEAM_ID", "VERCEL_PROJECT_ID"];
+    readonly cloudflare: readonly ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"];
+    readonly codesandbox: readonly ["CSB_API_KEY"];
+    readonly blaxel: readonly ["BL_API_KEY", "BL_WORKSPACE"];
+    readonly namespace: readonly ["NSC_TOKEN"];
+};
 
-export { AuthenticationError, type BaseComputeSandbox, type BaseComputeSpecification, BaseFileSystem, BaseProvider, type BaseProviderFactory, BaseTerminal, ComputeError, ComputeSDK, type ComputeSandbox, type ComputeSpecification, ConfigurationError, type ContainerConfig, DEFAULT_TIMEOUT, ENV_KEYS, type ExecuteSandboxParams, ExecutionError, type ExecutionResult, type FileEntry, type FilesystemComputeSandbox, type FilesystemComputeSpecification, type FilesystemProviderFactory, type FullComputeSandbox, type FullComputeSpecification, type FullProviderFactory, type InteractiveTerminalSession, ProviderError, type ProviderFactory, type ProviderMap, type ProviderRegistry, type ProviderType, ProviderUnavailableError, type Runtime, type SandboxConfig, type SandboxFileSystem, type SandboxInfo, type SandboxStatus, type SandboxTerminal, type TerminalComputeSandbox, type TerminalComputeSpecification, type TerminalCreateOptions, type TerminalProviderFactory, type TerminalSession, TimeoutError, autoSelectProvider, createComputeRegistry, ComputeSDK as default, detectAvailableProviders, executeSandbox, getDefaultRuntime, normalizeContainerConfig, normalizeSandboxConfig, retry, runCode, runCommand, validateProviderApiKey };
+export { type CallableCompute, type CodeResult$1 as CodeResult, CommandExitError, type CommandResult$1 as CommandResult, type CreateSandboxOptions$1 as CreateSandboxOptions, type ExplicitComputeConfig, type FileEntry, FileWatcher, GATEWAY_URL, Sandbox as GatewaySandbox, MessageType, PROVIDER_AUTH, PROVIDER_DASHBOARD_URLS, PROVIDER_ENV_MAP, PROVIDER_ENV_VARS, PROVIDER_HEADERS, PROVIDER_NAMES, PROVIDER_PRIORITY, type ProviderName, type ProviderSandboxInfo, type RunCommandOptions, type Runtime, Sandbox, type SandboxFileSystem, type SandboxInfo$1 as SandboxInfo, type Sandbox$1 as SandboxInterface, type SandboxStatus, type SetupOverlayConfig, type SetupPayload, SignalService, TerminalInstance, type WebSocketConstructor, autoConfigureCompute, buildProviderHeaders, buildSetupPayload, compute, decodeBinaryMessage, detectProvider, encodeBinaryMessage, encodeSetupPayload, getMissingEnvVars, getProviderConfigFromEnv, getProviderHeaders, isCommandExitError, isGatewayModeEnabled, isProviderAuthComplete, isValidProvider };