@labring/devbox-sdk 1.1.0

package/dist/index.d.cts

@@ -0,0 +1,875 @@
+import { ListFilesResponse } from 'devbox-shared/types';
+
+declare enum DevboxRuntime {
+    NUXT3 = "nuxt3",
+    ANGULAR = "angular",
+    QUARKUS = "quarkus",
+    UBUNTU = "ubuntu",
+    FLASK = "flask",
+    JAVA = "java",
+    CHI = "chi",
+    NET = "net",
+    IRIS = "iris",
+    HEXO = "hexo",
+    PYTHON = "python",
+    DOCUSAURUS = "docusaurus",
+    VITEPRESS = "vitepress",
+    CPP = "cpp",
+    VUE = "vue",
+    NGINX = "nginx",
+    ROCKET = "rocket",
+    DEBIAN_SSH = "debian-ssh",
+    VERT_X = "vert.x",
+    EXPRESS_JS = "express.js",
+    DJANGO = "django",
+    NEXT_JS = "next.js",
+    SEALAF = "sealaf",
+    GO = "go",
+    REACT = "react",
+    PHP = "php",
+    SVELTE = "svelte",
+    C = "c",
+    ASTRO = "astro",
+    UMI = "umi",
+    GIN = "gin",
+    NODE_JS = "node.js",
+    ECHO = "echo",
+    RUST = "rust",
+    TEST_AGENT = "node-expt-agent"
+}
+interface APIClientConfig {
+    kubeconfig: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+    rejectUnauthorized?: boolean;
+}
+interface APIResponse<T = unknown> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+}
+interface PortConfig$1 {
+    number: number;
+    protocol?: 'HTTP' | 'GRPC' | 'WS';
+    exposesPublicDomain?: boolean;
+    customDomain?: string;
+    portName?: string;
+}
+interface EnvVar {
+    name: string;
+    value?: string;
+    valueFrom?: {
+        secretKeyRef: {
+            name: string;
+            key: string;
+        };
+    };
+}
+interface CreateDevboxRequest {
+    name: string;
+    runtime: DevboxRuntime;
+    resource: {
+        cpu: number;
+        memory: number;
+    };
+    ports?: PortConfig$1[];
+    env?: EnvVar[];
+    autostart?: boolean;
+}
+interface UpdateDevboxRequest {
+    resource?: {
+        cpu: number;
+        memory: number;
+    };
+    ports?: PortConfig$1[];
+}
+interface DevboxListItem {
+    name: string;
+    uid: string;
+    resourceType: 'devbox';
+    runtime: DevboxRuntime;
+    status: string;
+    resources: {
+        cpu: number;
+        memory: number;
+    };
+}
+interface DevboxListApiResponse {
+    data: DevboxListItem[];
+}
+interface AgentServer {
+    url: string;
+    token: string;
+}
+interface DevboxDetail {
+    name: string;
+    uid: string;
+    resourceType: 'devbox';
+    runtime: string | DevboxRuntime;
+    image: string;
+    status: string;
+    resources: {
+        cpu: number;
+        memory: number;
+    };
+    ssh: {
+        host: string;
+        port: number;
+        user: string;
+        workingDir: string;
+        privateKey?: string;
+    };
+    env?: EnvVar[];
+    ports: Array<{
+        number: number;
+        portName: string;
+        protocol: string;
+        serviceName: string;
+        privateAddress: string;
+        privateHost: string;
+        networkName: string;
+        publicHost?: string;
+        publicAddress?: string;
+        customDomain?: string;
+    }>;
+    pods?: Array<{
+        name: string;
+        status: string;
+    }>;
+    agentServer?: AgentServer;
+}
+interface DevboxDetailApiResponse {
+    data: DevboxDetail;
+}
+interface RuntimeTemplate {
+    uid: string;
+    iconId: string | null;
+    name: string;
+    kind: 'FRAMEWORK' | 'OS' | 'LANGUAGE' | 'SERVICE' | 'CUSTOM';
+    description: string | null;
+    isPublic: boolean;
+}
+interface TemplateConfig {
+    templateUid: string;
+    templateName: string;
+    runtimeUid: string;
+    runtime: DevboxRuntime | null;
+    config: {
+        appPorts?: Array<{
+            name: string;
+            port: number;
+            protocol: string;
+        }>;
+        ports?: Array<{
+            containerPort: number;
+            name: string;
+            protocol: string;
+        }>;
+        releaseCommand?: string[];
+        releaseArgs?: string[];
+        user?: string;
+        workingDir?: string;
+    };
+}
+interface TemplatesApiResponse {
+    data: {
+        runtime: RuntimeTemplate[];
+        config: TemplateConfig[];
+    };
+}
+interface ReleaseStatus {
+    value: string;
+    label: string;
+}
+interface Release {
+    id: string;
+    name: string;
+    devboxName: string;
+    createTime: string;
+    tag: string;
+    status: ReleaseStatus;
+    description: string;
+    image: string;
+}
+interface ReleaseListApiResponse {
+    data: Release[];
+}
+interface MonitorDataApiPoint {
+    timestamp: number;
+    readableTime: string;
+    cpu: number;
+    memory: number;
+}
+interface MonitorDataApiResponse {
+    code: 200;
+    data: MonitorDataApiPoint[];
+}
+interface CreateReleaseRequest {
+    tag: string;
+    releaseDes?: string;
+}
+interface ConfigureAutostartRequest {
+    execCommand?: string;
+}
+
+interface DevboxSDKConfig {
+    kubeconfig: string;
+    baseUrl?: string;
+    mockServerUrl?: string;
+    http?: HttpClientConfig;
+}
+interface HttpClientConfig {
+    timeout?: number;
+    retries?: number;
+    proxy?: string;
+    rejectUnauthorized?: boolean;
+}
+
+interface DevboxCreateConfig {
+    name: string;
+    runtime: DevboxRuntime;
+    resource: ResourceInfo;
+    ports?: PortConfig[];
+    env?: Record<string, string>;
+}
+interface DevboxCreateOptions {
+    waitUntilReady?: boolean;
+    timeout?: number;
+    checkInterval?: number;
+    useExponentialBackoff?: boolean;
+    initialCheckInterval?: number;
+    maxCheckInterval?: number;
+    backoffMultiplier?: number;
+}
+interface WaitForReadyOptions {
+    timeout?: number;
+    checkInterval?: number;
+    useExponentialBackoff?: boolean;
+    initialCheckInterval?: number;
+    maxCheckInterval?: number;
+    backoffMultiplier?: number;
+}
+interface ResourceInfo {
+    cpu: number;
+    memory: number;
+}
+interface PortConfig {
+    number: number;
+    protocol: string;
+}
+interface DevboxInfo {
+    name: string;
+    status: string;
+    runtime: DevboxRuntime;
+    resources: ResourceInfo;
+    podIP?: string;
+    ssh?: SSHInfo;
+    ports?: Array<{
+        number: number;
+        portName: string;
+        protocol: string;
+        serviceName: string;
+        privateAddress: string;
+        privateHost: string;
+        networkName: string;
+        publicHost?: string;
+        publicAddress?: string;
+        customDomain?: string;
+    }>;
+    agentServer?: {
+        url: string;
+        token: string;
+    };
+}
+interface SSHInfo {
+    host: string;
+    port: number;
+    user: string;
+    privateKey: string;
+}
+interface FileMap {
+    [path: string]: Buffer | string;
+}
+interface WriteOptions {
+    encoding?: string;
+    mode?: number;
+    createDirs?: boolean;
+}
+interface ReadOptions {
+    encoding?: string;
+    offset?: number;
+    length?: number;
+}
+interface BatchUploadOptions {
+    concurrency?: number;
+    chunkSize?: number;
+    onProgress?: (progress: TransferProgress) => void;
+}
+interface TransferProgress {
+    processed: number;
+    total: number;
+    bytesTransferred: number;
+    totalBytes: number;
+    progress: number;
+}
+interface TransferResult {
+    success: boolean;
+    results: Array<{
+        path: string;
+        success: boolean;
+        size?: number;
+        error?: string;
+    }>;
+    totalFiles: number;
+    successCount: number;
+}
+interface TransferError {
+    path: string;
+    error: string;
+    code: string;
+}
+interface MoveFileOptions {
+    source: string;
+    destination: string;
+    overwrite?: boolean;
+}
+type MoveFileResponse = Record<string, never>;
+interface RenameFileOptions {
+    oldPath: string;
+    newPath: string;
+}
+type RenameFileResponse = Record<string, never>;
+interface DownloadFileOptions {
+    paths: string[];
+    format?: 'tar.gz' | 'tar' | 'multipart' | 'direct';
+}
+interface SearchFilesOptions {
+    dir?: string;
+    pattern: string;
+}
+interface SearchFilesResponse {
+    files: string[];
+}
+interface FindInFilesOptions {
+    dir?: string;
+    keyword: string;
+}
+interface FindInFilesResponse {
+    files: string[];
+}
+interface ReplaceInFilesOptions {
+    files: string[];
+    from: string;
+    to: string;
+}
+interface ReplaceResult {
+    file: string;
+    status: 'success' | 'error' | 'skipped';
+    replacements: number;
+    error?: string;
+}
+interface ReplaceInFilesResponse {
+    results: ReplaceResult[];
+}
+interface PortsResponse {
+    ports: number[];
+    lastUpdatedAt: number;
+}
+interface PortPreviewUrl {
+    url: string;
+    port: number;
+    protocol: string;
+}
+interface TimeRange {
+    start: number;
+    end: number;
+    step?: string;
+}
+interface MonitorData {
+    cpu: number;
+    memory: number;
+    network: {
+        bytesIn: number;
+        bytesOut: number;
+    };
+    disk: {
+        used: number;
+        total: number;
+    };
+    timestamp: number;
+}
+interface ProcessExecOptions {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string>;
+    shell?: string;
+    timeout?: number;
+}
+interface CodeRunOptions {
+    language?: 'node' | 'python';
+    argv?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    timeout?: number;
+}
+interface ProcessExecResponse {
+    success: boolean;
+    processId: string;
+    pid: number;
+    processStatus: string;
+    exitCode?: number;
+}
+interface SyncExecutionResponse {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode?: number;
+    durationMs: number;
+    startTime: number;
+    endTime: number;
+}
+interface ProcessInfo {
+    processId: string;
+    pid: number;
+    command: string;
+    processStatus: string;
+    startTime: number;
+    endTime?: number;
+    exitCode?: number;
+}
+interface ListProcessesResponse {
+    success: boolean;
+    processes: ProcessInfo[];
+}
+interface GetProcessStatusResponse {
+    success: boolean;
+    processId: string;
+    pid: number;
+    processStatus: string;
+}
+interface GetProcessLogsResponse {
+    success: boolean;
+    processId: string;
+    logs: string[];
+}
+interface KillProcessOptions {
+    signal?: 'SIGTERM' | 'SIGKILL' | 'SIGINT';
+}
+interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    duration: number;
+    pid?: number;
+}
+interface ProcessStatus {
+    pid: number;
+    state: 'running' | 'completed' | 'failed' | 'unknown';
+    exitCode?: number;
+    cpu?: number;
+    memory?: number;
+    startTime: number;
+    runningTime: number;
+}
+type DevboxStatus = 'Creating' | 'Running' | 'Stopped' | 'Error' | 'Deleting' | 'Unknown';
+interface GitAuth {
+    username?: string;
+    password?: string;
+    token?: string;
+    sshKey?: string;
+}
+interface GitCloneOptions {
+    url: string;
+    targetDir?: string;
+    branch?: string;
+    commit?: string;
+    depth?: number;
+    auth?: GitAuth;
+}
+interface GitPullOptions {
+    remote?: string;
+    branch?: string;
+    auth?: GitAuth;
+}
+interface GitPushOptions {
+    remote?: string;
+    branch?: string;
+    auth?: GitAuth;
+    force?: boolean;
+}
+interface GitBranchInfo {
+    name: string;
+    isCurrent: boolean;
+    isRemote: boolean;
+    commit: string;
+    ahead?: number;
+    behind?: number;
+}
+interface GitStatus {
+    currentBranch: string;
+    isClean: boolean;
+    ahead: number;
+    behind: number;
+    staged: string[];
+    modified: string[];
+    untracked: string[];
+    deleted: string[];
+}
+
+declare class DevboxAPI {
+    private httpClient;
+    private authenticator;
+    private endpoints;
+    constructor(config: APIClientConfig);
+    createDevbox(config: DevboxCreateConfig): Promise<DevboxInfo>;
+    getDevbox(name: string): Promise<DevboxInfo>;
+    listDevboxes(): Promise<DevboxInfo[]>;
+    startDevbox(name: string): Promise<void>;
+    pauseDevbox(name: string): Promise<void>;
+    restartDevbox(name: string): Promise<void>;
+    deleteDevbox(name: string): Promise<void>;
+    updateDevbox(name: string, config: UpdateDevboxRequest): Promise<void>;
+    shutdownDevbox(name: string): Promise<void>;
+    getTemplates(): Promise<TemplatesApiResponse['data']>;
+    updatePorts(name: string, ports: PortConfig$1[]): Promise<void>;
+    configureAutostart(name: string, config?: ConfigureAutostartRequest): Promise<void>;
+    listReleases(name: string): Promise<Release[]>;
+    createRelease(name: string, config: CreateReleaseRequest): Promise<void>;
+    deleteRelease(name: string, tag: string): Promise<void>;
+    deployRelease(name: string, tag: string): Promise<void>;
+    getMonitorData(name: string, timeRange?: TimeRange): Promise<MonitorData[]>;
+    testAuth(): Promise<boolean>;
+    private transformSSHInfoToDevboxInfo;
+    private transformListItemToDevboxInfo;
+    private stringToRuntime;
+    private transformCreateResponseToDevboxInfo;
+    private transformDetailToDevboxInfo;
+    private transformGetResponseToDevboxInfo;
+    private transformMonitorData;
+    private handleAPIError;
+}
+
+interface RequestOptions {
+    headers?: Record<string, string>;
+    body?: unknown;
+    params?: Record<string, string | number | boolean | undefined>;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+interface HTTPResponse<T = unknown> {
+    data: T;
+    status: number;
+    headers: Record<string, string>;
+    url: string;
+}
+
+declare class DevboxContainerClient {
+    private baseUrl;
+    private timeout;
+    private token;
+    constructor(baseUrl: string, timeout: number, token: string);
+    get<T = unknown>(path: string, options?: RequestOptions): Promise<HTTPResponse<T>>;
+    post<T = unknown>(path: string, options?: RequestOptions): Promise<HTTPResponse<T>>;
+    put<T = unknown>(path: string, options?: RequestOptions): Promise<HTTPResponse<T>>;
+    delete<T = unknown>(path: string, options?: RequestOptions): Promise<HTTPResponse<T>>;
+    private request;
+}
+
+interface IDevboxAPIClient {
+    getDevbox(name: string): Promise<DevboxInfo>;
+}
+declare class ContainerUrlResolver {
+    private apiClient?;
+    private cache;
+    private readonly CACHE_TTL;
+    private mockServerUrl?;
+    readonly baseUrl: string;
+    private timeout;
+    constructor(config: DevboxSDKConfig);
+    setAPIClient(apiClient: IDevboxAPIClient): void;
+    executeWithConnection<T>(devboxName: string, operation: (client: DevboxContainerClient) => Promise<T>): Promise<T>;
+    getServerUrl(devboxName: string): Promise<string>;
+    private getConfiguredServerUrl;
+    private resolveServerUrlFromAPI;
+    private extractUrlFromDevboxInfo;
+    private getDevboxInfo;
+    private getFromCache;
+    private setCache;
+    clearCache(): void;
+    closeAllConnections(): Promise<void>;
+    checkDevboxHealth(devboxName: string): Promise<boolean>;
+}
+
+interface GitDependencies {
+    execSync: (options: ProcessExecOptions) => Promise<SyncExecutionResponse>;
+}
+declare class Git {
+    private deps;
+    constructor(deps: GitDependencies);
+    private buildAuthUrl;
+    private setupGitAuth;
+    private parseGitBranches;
+    private parseGitStatus;
+    clone(options: GitCloneOptions): Promise<void>;
+    pull(repoPath: string, options?: GitPullOptions): Promise<void>;
+    push(repoPath: string, options?: GitPushOptions): Promise<void>;
+    branches(repoPath: string): Promise<GitBranchInfo[]>;
+    createBranch(repoPath: string, branchName: string, checkout?: boolean): Promise<void>;
+    deleteBranch(repoPath: string, branchName: string, force?: boolean, remote?: boolean): Promise<void>;
+    checkoutBranch(repoPath: string, branchName: string, create?: boolean): Promise<void>;
+    private normalizePath;
+    add(repoPath: string, files?: string | string[]): Promise<void>;
+    commit(repoPath: string, message: string, author: string, email: string, allowEmpty?: boolean): Promise<void>;
+    status(repoPath: string): Promise<GitStatus>;
+}
+
+declare class DevboxInstance {
+    private info;
+    private sdk;
+    readonly git: Git;
+    constructor(info: DevboxInfo, sdk: DevboxSDK);
+    get name(): string;
+    get status(): string;
+    get runtime(): DevboxRuntime;
+    get resources(): ResourceInfo;
+    get serverUrl(): string;
+    start(): Promise<void>;
+    pause(): Promise<void>;
+    restart(): Promise<void>;
+    shutdown(): Promise<void>;
+    delete(): Promise<void>;
+    refreshInfo(): Promise<void>;
+    writeFile(path: string, content: string | Buffer, options?: WriteOptions): Promise<void>;
+    readFile(path: string, options?: ReadOptions): Promise<Buffer>;
+    private validatePath;
+    deleteFile(path: string): Promise<void>;
+    listFiles(path: string): Promise<ListFilesResponse>;
+    uploadFiles(files: FileMap, options?: BatchUploadOptions & {
+        targetDir?: string;
+    }): Promise<TransferResult>;
+    moveFile(source: string, destination: string, overwrite?: boolean): Promise<MoveFileResponse>;
+    renameFile(oldPath: string, newPath: string): Promise<RenameFileResponse>;
+    searchFiles(options: SearchFilesOptions): Promise<SearchFilesResponse>;
+    findInFiles(options: FindInFilesOptions): Promise<FindInFilesResponse>;
+    replaceInFiles(options: ReplaceInFilesOptions): Promise<ReplaceInFilesResponse>;
+    downloadFile(path: string): Promise<Buffer>;
+    downloadFiles(paths: string[], options?: {
+        format?: 'tar.gz' | 'tar' | 'multipart' | 'direct';
+    }): Promise<Buffer>;
+    getPorts(): Promise<PortsResponse>;
+    getPreviewLink(port: number): Promise<PortPreviewUrl>;
+    executeCommand(options: ProcessExecOptions): Promise<ProcessExecResponse>;
+    execSync(options: ProcessExecOptions): Promise<SyncExecutionResponse>;
+    codeRun(code: string, options?: CodeRunOptions): Promise<SyncExecutionResponse>;
+    private detectLanguage;
+    private buildCodeCommand;
+    execSyncStream(options: ProcessExecOptions): Promise<ReadableStream>;
+    listProcesses(): Promise<ListProcessesResponse>;
+    getProcessStatus(processId: string): Promise<GetProcessStatusResponse>;
+    killProcess(processId: string, options?: KillProcessOptions): Promise<void>;
+    getProcessLogs(processId: string, stream?: boolean): Promise<GetProcessLogsResponse>;
+    getMonitorData(timeRange?: TimeRange): Promise<MonitorData[]>;
+    isHealthy(): Promise<boolean>;
+    waitForReady(timeoutOrOptions?: number | WaitForReadyOptions, checkInterval?: number): Promise<void>;
+    getDetailedInfo(): Promise<DevboxInfo>;
+}
+
+declare class DevboxSDK {
+    private apiClient;
+    private urlResolver;
+    constructor(config: DevboxSDKConfig);
+    createDevboxAsync(config: DevboxCreateConfig): Promise<DevboxInstance>;
+    createDevbox(config: DevboxCreateConfig, options?: DevboxCreateOptions): Promise<DevboxInstance>;
+    getDevbox(name: string): Promise<DevboxInstance>;
+    listDevboxes(): Promise<DevboxInstance[]>;
+    getMonitorData(devboxName: string, timeRange?: TimeRange): Promise<MonitorData[]>;
+    close(): Promise<void>;
+    getAPIClient(): DevboxAPI;
+    getUrlResolver(): ContainerUrlResolver;
+}
+
+declare const DEFAULT_CONFIG: {
+    readonly BASE_URL: "https://devbox.usw.sealos.io/v1";
+    readonly CONTAINER_HTTP_PORT: 3000;
+    readonly MOCK_SERVER: {
+        readonly DEFAULT_URL: "http://localhost:9757";
+        readonly ENV_VAR: "MOCK_SERVER_URL";
+    };
+    readonly HTTP_CLIENT: {
+        readonly TIMEOUT: 30000;
+        readonly RETRIES: 3;
+    };
+    readonly FILE_LIMITS: {
+        readonly MAX_FILE_SIZE: number;
+        readonly MAX_BATCH_SIZE: 50;
+        readonly CHUNK_SIZE: number;
+    };
+    readonly PERFORMANCE: {
+        readonly SMALL_FILE_LATENCY_MS: 50;
+        readonly LARGE_FILE_THROUGHPUT_MBPS: 15;
+        readonly CONNECTION_REUSE_RATE: 0.98;
+        readonly STARTUP_TIME_MS: 100;
+    };
+};
+declare const API_ENDPOINTS: {
+    readonly DEVBOX: {
+        readonly LIST: "/api/v1/devbox";
+        readonly CREATE: "/api/v1/devbox";
+        readonly GET: "/api/v1/devbox/{name}";
+        readonly UPDATE: "/api/v1/devbox/{name}";
+        readonly DELETE: "/api/v1/devbox/{name}/delete";
+        readonly START: "/api/v1/devbox/{name}/start";
+        readonly PAUSE: "/api/v1/devbox/{name}/pause";
+        readonly RESTART: "/api/v1/devbox/{name}/restart";
+        readonly SHUTDOWN: "/api/v1/devbox/{name}/shutdown";
+        readonly MONITOR: "/api/v1/devbox/{name}/monitor";
+        readonly TEMPLATES: "/api/v1/devbox/templates";
+        readonly PORTS: "/api/v1/devbox/{name}/ports";
+        readonly AUTOSTART: "/api/v1/devbox/{name}/autostart";
+        readonly RELEASE: {
+            readonly LIST: "/api/v1/devbox/{name}/release";
+            readonly CREATE: "/api/v1/devbox/{name}/release";
+            readonly DELETE: "/api/v1/devbox/{name}/release/{tag}";
+            readonly DEPLOY: "/api/v1/devbox/{name}/release/{tag}/deploy";
+        };
+    };
+    readonly CONTAINER: {
+        readonly HEALTH: "/health";
+        readonly FILES: {
+            readonly WRITE: "/api/v1/files/write";
+            readonly READ: "/api/v1/files/read";
+            readonly LIST: "/api/v1/files/list";
+            readonly DELETE: "/api/v1/files/delete";
+            readonly MOVE: "/api/v1/files/move";
+            readonly RENAME: "/api/v1/files/rename";
+            readonly DOWNLOAD: "/api/v1/files/download";
+            readonly BATCH_UPLOAD: "/api/v1/files/batch-upload";
+            readonly BATCH_DOWNLOAD: "/api/v1/files/batch-download";
+            readonly SEARCH: "/api/v1/files/search";
+            readonly FIND: "/api/v1/files/find";
+            readonly REPLACE: "/api/v1/files/replace";
+        };
+        readonly PROCESS: {
+            readonly EXEC: "/api/v1/process/exec";
+            readonly EXEC_SYNC: "/api/v1/process/exec-sync";
+            readonly EXEC_SYNC_STREAM: "/api/v1/process/sync-stream";
+            readonly LIST: "/api/v1/process/list";
+            readonly STATUS: "/api/v1/process/{process_id}/status";
+            readonly KILL: "/api/v1/process/{process_id}/kill";
+            readonly LOGS: "/api/v1/process/{process_id}/logs";
+        };
+        readonly PORTS: "/api/v1/ports";
+    };
+};
+declare const ERROR_CODES: {
+    readonly AUTHENTICATION_FAILED: "AUTHENTICATION_FAILED";
+    readonly INVALID_KUBECONFIG: "INVALID_KUBECONFIG";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly INVALID_TOKEN: "INVALID_TOKEN";
+    readonly TOKEN_EXPIRED: "TOKEN_EXPIRED";
+    readonly INSUFFICIENT_PERMISSIONS: "INSUFFICIENT_PERMISSIONS";
+    readonly CONNECTION_FAILED: "CONNECTION_FAILED";
+    readonly CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT";
+    readonly DEVBOX_NOT_FOUND: "DEVBOX_NOT_FOUND";
+    readonly DEVBOX_NOT_READY: "DEVBOX_NOT_READY";
+    readonly DEVBOX_CREATION_FAILED: "DEVBOX_CREATION_FAILED";
+    readonly DEVBOX_OPERATION_FAILED: "DEVBOX_OPERATION_FAILED";
+    readonly INVALID_REQUEST: "INVALID_REQUEST";
+    readonly MISSING_REQUIRED_FIELD: "MISSING_REQUIRED_FIELD";
+    readonly INVALID_FIELD_VALUE: "INVALID_FIELD_VALUE";
+    readonly INVALID_JSON_FORMAT: "INVALID_JSON_FORMAT";
+    readonly INVALID_PATH: "INVALID_PATH";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly PROCESS_NOT_FOUND: "PROCESS_NOT_FOUND";
+    readonly SESSION_NOT_FOUND: "SESSION_NOT_FOUND";
+    readonly FILE_NOT_FOUND: "FILE_NOT_FOUND";
+    readonly DIRECTORY_NOT_FOUND: "DIRECTORY_NOT_FOUND";
+    readonly CONFLICT: "CONFLICT";
+    readonly PROCESS_ALREADY_RUNNING: "PROCESS_ALREADY_RUNNING";
+    readonly PROCESS_NOT_RUNNING: "PROCESS_NOT_RUNNING";
+    readonly SESSION_INACTIVE: "SESSION_INACTIVE";
+    readonly RESOURCE_LOCKED: "RESOURCE_LOCKED";
+    readonly PROCESS_ALREADY_TERMINATED: "PROCESS_ALREADY_TERMINATED";
+    readonly OPERATION_TIMEOUT: "OPERATION_TIMEOUT";
+    readonly OPERATION_FAILED: "OPERATION_FAILED";
+    readonly EXECUTION_FAILED: "EXECUTION_FAILED";
+    readonly SIGNAL_FAILED: "SIGNAL_FAILED";
+    readonly FILE_OPERATION_ERROR: "FILE_OPERATION_ERROR";
+    readonly FILE_TOO_LARGE: "FILE_TOO_LARGE";
+    readonly FILE_TRANSFER_FAILED: "FILE_TRANSFER_FAILED";
+    readonly PATH_TRAVERSAL_DETECTED: "PATH_TRAVERSAL_DETECTED";
+    readonly DIRECTORY_NOT_EMPTY: "DIRECTORY_NOT_EMPTY";
+    readonly DISK_FULL: "DISK_FULL";
+    readonly FILE_LOCKED: "FILE_LOCKED";
+    readonly PROCESS_START_FAILED: "PROCESS_START_FAILED";
+    readonly INVALID_SIGNAL: "INVALID_SIGNAL";
+    readonly PROCESS_LIMIT_EXCEEDED: "PROCESS_LIMIT_EXCEEDED";
+    readonly SESSION_CREATION_FAILED: "SESSION_CREATION_FAILED";
+    readonly SESSION_LIMIT_EXCEEDED: "SESSION_LIMIT_EXCEEDED";
+    readonly SESSION_TIMEOUT: "SESSION_TIMEOUT";
+    readonly SHELL_NOT_FOUND: "SHELL_NOT_FOUND";
+    readonly SERVER_UNAVAILABLE: "SERVER_UNAVAILABLE";
+    readonly HEALTH_CHECK_FAILED: "HEALTH_CHECK_FAILED";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+    readonly MAINTENANCE_MODE: "MAINTENANCE_MODE";
+};
+declare const HTTP_STATUS: {
+    readonly OK: 200;
+    readonly CREATED: 201;
+    readonly ACCEPTED: 202;
+    readonly NO_CONTENT: 204;
+    readonly BAD_REQUEST: 400;
+    readonly UNAUTHORIZED: 401;
+    readonly FORBIDDEN: 403;
+    readonly NOT_FOUND: 404;
+    readonly METHOD_NOT_ALLOWED: 405;
+    readonly TIMEOUT: 408;
+    readonly CONFLICT: 409;
+    readonly GONE: 410;
+    readonly TOO_MANY_REQUESTS: 429;
+    readonly INTERNAL_SERVER_ERROR: 500;
+    readonly BAD_GATEWAY: 502;
+    readonly SERVICE_UNAVAILABLE: 503;
+    readonly GATEWAY_TIMEOUT: 504;
+};
+
+interface ErrorContext {
+    status?: number;
+    statusText?: string;
+    timestamp?: number;
+    serverErrorCode?: string;
+    originalError?: unknown;
+    [key: string]: unknown;
+}
+declare class DevboxSDKError extends Error {
+    code: string;
+    context?: ErrorContext | undefined;
+    constructor(message: string, code: string, context?: ErrorContext | undefined);
+}
+declare class AuthenticationError extends DevboxSDKError {
+    constructor(message: string, context?: ErrorContext);
+}
+declare class ConnectionError extends DevboxSDKError {
+    constructor(message: string, context?: ErrorContext);
+}
+declare class FileOperationError extends DevboxSDKError {
+    constructor(message: string, context?: ErrorContext, code?: string);
+}
+declare class DevboxNotFoundError extends DevboxSDKError {
+    constructor(devboxName: string, context?: ErrorContext);
+}
+declare class DevboxNotReadyError extends DevboxSDKError {
+    constructor(devboxName: string, currentStatus?: string, context?: ErrorContext);
+}
+declare class ValidationError extends DevboxSDKError {
+    constructor(message: string, context?: ErrorContext);
+}
+
+declare const VERSION = "1.0.0";
+
+export { type PortConfig$1 as APIPortConfig, type APIResponse, API_ENDPOINTS, AuthenticationError, type BatchUploadOptions, type CodeRunOptions, type CommandResult, ConnectionError, ContainerUrlResolver, type CreateDevboxRequest, DEFAULT_CONFIG, DevboxAPI, DevboxContainerClient, type DevboxCreateConfig, type DevboxCreateOptions, type DevboxDetailApiResponse, type DevboxInfo, DevboxInstance, type DevboxListApiResponse, DevboxNotFoundError, DevboxNotReadyError, DevboxRuntime, DevboxSDK, type DevboxSDKConfig, DevboxSDKError, type DevboxStatus, type DownloadFileOptions, ERROR_CODES, type EnvVar, type FileMap, FileOperationError, type FindInFilesOptions, type FindInFilesResponse, type GetProcessLogsResponse, type GetProcessStatusResponse, type GitAuth, type GitBranchInfo, type GitCloneOptions, type GitPullOptions, type GitPushOptions, type GitStatus, HTTP_STATUS, type HttpClientConfig, type KillProcessOptions, type ListProcessesResponse, type MonitorData, type MonitorDataApiResponse, type MoveFileOptions, type MoveFileResponse, type PortConfig, type PortPreviewUrl, type PortsResponse, type ProcessExecOptions, type ProcessExecResponse, type ProcessInfo, type ProcessStatus, type ReadOptions, type ReleaseListApiResponse, type RenameFileOptions, type RenameFileResponse, type ReplaceInFilesOptions, type ReplaceInFilesResponse, type ReplaceResult, type ResourceInfo, type SSHInfo, type SearchFilesOptions, type SearchFilesResponse, type SyncExecutionResponse, type TemplatesApiResponse, type TimeRange, type TransferError, type TransferProgress, type TransferResult, type UpdateDevboxRequest, VERSION, ValidationError, type WriteOptions, DevboxSDK as default };