@daytonaio/sdk 0.200.1 → 0.202.0

package/esm/errors/DaytonaError.d.ts

@@ -5,172 +5,196 @@ import { AxiosHeaders } from 'axios';
 import type { AxiosError } from 'axios';
 export type ResponseHeaders = InstanceType<typeof AxiosHeaders>;
 /**
- * Base error for Daytona SDK.
- *
- * @example
- * ```ts
- * try {
- *   await daytona.get('missing-sandbox')
- * } catch (error) {
- *   if (error instanceof DaytonaError) {
- *     console.log(error.statusCode)
- *     console.log(error.errorCode)
- *     console.log(error.message)
- *   }
- * }
- * ```
+ * Wire-format `source` identifiers set by the translation layer when a
+ * Daytona service stamps them on the wire envelope. `source = undefined`
+ * means the response did not carry a structured envelope (treat as opaque).
+ */
+export declare const SOURCE_API = "DAYTONA_API";
+export declare const SOURCE_DAEMON = "DAYTONA_DAEMON";
+export declare const SOURCE_PROXY = "DAYTONA_PROXY";
+/**
+ * Base error for Daytona SDK. `statusCode` and `code` are populated only
+ * for errors translated from a server response. `source` is `undefined`
+ * unless the caller (or the translation layer) sets it.
  */
 export declare class DaytonaError extends Error {
-    /** HTTP status code if available */
     statusCode?: number;
-    /** Machine-readable error code if available */
-    errorCode?: string;
-    /** Response headers if available */
+    code?: string;
+    readonly source?: string;
     headers?: ResponseHeaders;
-    constructor(message: string, statusCode?: number, headers?: ResponseHeaders, errorCode?: string);
+    constructor(message: string, statusCode?: number, headers?: ResponseHeaders, code?: string, source?: string);
+    /**
+     * @deprecated Use {@link DaytonaError.code} instead. Kept so existing
+     * `err.errorCode` reads keep returning the machine-readable code.
+     * @returns the machine-readable error code, or `undefined` when the
+     * response did not carry one (same as {@link DaytonaError.code})
+     */
+    get errorCode(): string | undefined;
 }
-/**
- * Error thrown when a resource is not found (HTTP 404).
- *
- * @example
- * ```ts
- * try {
- *   await sandbox.fs.downloadFile('/workspace/missing.txt')
- * } catch (error) {
- *   if (error instanceof DaytonaNotFoundError) {
- *     console.log(error.statusCode)
- *   }
- * }
- * ```
- */
+/** The request was malformed or invalid (HTTP 400). */
+export declare class DaytonaBadRequestError extends DaytonaError {
+}
+/** Authentication failed — missing or invalid credentials (HTTP 401). */
+export declare class DaytonaAuthenticationError extends DaytonaError {
+}
+/** The authenticated caller lacks permission for the operation (HTTP 403). */
+export declare class DaytonaForbiddenError extends DaytonaError {
+}
+/** The requested resource does not exist (HTTP 404). */
 export declare class DaytonaNotFoundError extends DaytonaError {
 }
 /**
- * Error thrown when rate limit is exceeded.
+ * The operation timed out (HTTP 408, or 504 when a gateway timed out).
  *
- * @example
- * ```ts
- * try {
- *   for await (const sandbox of daytona.list()) {
- *     console.log(sandbox.id)
- *   }
- * } catch (error) {
- *   if (error instanceof DaytonaRateLimitError) {
- *     console.log(error.errorCode)
- *   }
- * }
- * ```
+ * Also matches {@link DaytonaConnectionTimeoutError} via `instanceof`, even
+ * though that class sits under {@link DaytonaConnectionError} in the prototype
+ * chain. Transport timeouts were raised as `DaytonaTimeoutError` before
+ * `DaytonaConnectionTimeoutError` existed, so this keeps pre-existing
+ * `catch (err) { if (err instanceof DaytonaTimeoutError) ... }` blocks working
+ * — the same compatibility the Python SDK gets from inheriting both classes.
  */
+export declare class DaytonaTimeoutError extends DaytonaError {
+    static [Symbol.hasInstance](value: unknown): boolean;
+}
+/** The request conflicts with the current state of the resource (HTTP 409). */
+export declare class DaytonaConflictError extends DaytonaError {
+}
+/** The resource existed but is permanently gone (HTTP 410). */
+export declare class DaytonaGoneError extends DaytonaError {
+}
+/** The request was well-formed but semantically invalid (HTTP 422). */
+export declare class DaytonaUnprocessableEntityError extends DaytonaError {
+}
+/** The caller exceeded a rate limit (HTTP 429). */
 export declare class DaytonaRateLimitError extends DaytonaError {
 }
-/**
- * Error thrown when authentication fails (HTTP 401).
- *
- * @example
- * ```ts
- * try {
- *   for await (const sandbox of daytona.list()) {
- *     console.log(sandbox.id)
- *   }
- * } catch (error) {
- *   if (error instanceof DaytonaAuthenticationError) {
- *     console.log(error.statusCode)
- *   }
- * }
- * ```
- */
-export declare class DaytonaAuthenticationError extends DaytonaError {
+/** A Daytona service failed unexpectedly (HTTP 500). */
+export declare class DaytonaInternalServerError extends DaytonaError {
 }
-/**
- * Error thrown when the request is forbidden (HTTP 403).
- *
- * @example
- * ```ts
- * try {
- *   await daytona.get('sandbox-without-access')
- * } catch (error) {
- *   if (error instanceof DaytonaAuthorizationError) {
- *     console.log(error.message)
- *   }
- * }
- * ```
- */
-export declare class DaytonaAuthorizationError extends DaytonaError {
+/** An upstream gateway returned an invalid response (HTTP 502). */
+export declare class DaytonaBadGatewayError extends DaytonaError {
 }
-/**
- * Error thrown when a resource conflict occurs (HTTP 409).
- *
- * @example
- * ```ts
- * try {
- *   await daytona.create({ name: 'existing-sandbox' })
- * } catch (error) {
- *   if (error instanceof DaytonaConflictError) {
- *     console.log(error.errorCode)
- *   }
- * }
- * ```
- */
-export declare class DaytonaConflictError extends DaytonaError {
+/** The service is temporarily unable to handle the request (HTTP 503). */
+export declare class DaytonaServiceUnavailableError extends DaytonaError {
 }
 /**
- * Error thrown when input validation fails (HTTP 400 or client-side validation).
+ * Legacy umbrella for validation failures. Kept so existing
+ * `catch (err) { if (err instanceof DaytonaValidationError) ... }` blocks keep
+ * matching both server-returned HTTP 400s and locally rejected arguments.
  *
- * @example
- * ```ts
- * try {
- *   Image.debianSlim('3.8' as never)
- * } catch (error) {
- *   if (error instanceof DaytonaValidationError) {
- *     console.log(error.message)
- *   }
- * }
- * ```
+ * @deprecated Do not throw or catch this directly in new code. Branch on the
+ * precise class instead:
+ * - {@link DaytonaInvalidArgumentError} — the SDK rejected your arguments
+ *   locally, before any request was sent.
+ * - {@link DaytonaBadRequestError} — a Daytona service returned HTTP 400.
+ * - {@link DaytonaUnprocessableEntityError} — a Daytona service returned
+ *   HTTP 422 (well-formed but semantically invalid).
  */
-export declare class DaytonaValidationError extends DaytonaError {
+export declare class DaytonaValidationError extends DaytonaBadRequestError {
 }
 /**
- * Error thrown when a timeout occurs.
- *
- * @example
- * ```ts
- * try {
- *   await sandbox.waitUntilStarted(1)
- * } catch (error) {
- *   if (error instanceof DaytonaTimeoutError) {
- *     console.log(error.message)
- *   }
- * }
- * ```
+ * @deprecated Use {@link DaytonaForbiddenError} instead.
  */
-export declare class DaytonaTimeoutError extends DaytonaError {
+export declare class DaytonaAuthorizationError extends DaytonaForbiddenError {
 }
 /**
- * Error thrown when a network connection fails.
+ * The SDK rejected the caller's arguments locally, before any request was
+ * sent. `statusCode`, `code` and `source` are always `undefined` — no Daytona
+ * service was contacted, so there is no HTTP status to report.
+ *
+ * Distinct from {@link DaytonaBadRequestError} (a service returned HTTP 400)
+ * and {@link DaytonaUnprocessableEntityError} (a service returned HTTP 422).
+ * This one always means: fix the arguments at the call site.
  *
  * @example
  * ```ts
  * try {
- *   await ptyHandle.waitForConnection()
- * } catch (error) {
- *   if (error instanceof DaytonaConnectionError) {
- *     console.log(error.message)
+ *   await sandbox.setAutoStopInterval(-1)
+ * } catch (err) {
+ *   if (err instanceof DaytonaInvalidArgumentError) {
+ *     // never reached the API — the value itself is invalid
  *   }
  * }
  * ```
  */
+export declare class DaytonaInvalidArgumentError extends DaytonaValidationError {
+}
+/** Network connection failure (can't connect or mid-request drop). */
 export declare class DaytonaConnectionError extends DaytonaError {
 }
-/**
- * Maps an HTTP status code to the corresponding Daytona error class.
- */
+/** Transport-layer timeout (connect / read). Subclass of DaytonaConnectionError. */
+export declare class DaytonaConnectionTimeoutError extends DaytonaConnectionError {
+}
+/** Git authentication against the remote failed (code `GIT_AUTH_FAILED`). */
+export declare class DaytonaGitAuthFailedError extends DaytonaAuthenticationError {
+}
+/** The git remote repository was not found (code `GIT_REPO_NOT_FOUND`). */
+export declare class DaytonaGitRepoNotFoundError extends DaytonaNotFoundError {
+}
+/** The git branch does not exist (code `GIT_BRANCH_NOT_FOUND`). */
+export declare class DaytonaGitBranchNotFoundError extends DaytonaNotFoundError {
+}
+/** The git branch already exists (code `GIT_BRANCH_EXISTS`). */
+export declare class DaytonaGitBranchExistsError extends DaytonaConflictError {
+}
+/** The git push was rejected by the remote (code `GIT_PUSH_REJECTED`). */
+export declare class DaytonaGitPushRejectedError extends DaytonaConflictError {
+}
+/** The operation requires a clean worktree (code `GIT_DIRTY_WORKTREE`). */
+export declare class DaytonaGitDirtyWorktreeError extends DaytonaConflictError {
+}
+/** A git merge produced conflicts (code `GIT_MERGE_CONFLICT`). */
+export declare class DaytonaGitMergeConflictError extends DaytonaConflictError {
+}
+/** The file does not exist in the sandbox (code `FILE_NOT_FOUND`). */
+export declare class DaytonaFileNotFoundError extends DaytonaNotFoundError {
+}
+/** Access to the sandbox file was denied (code `FILE_ACCESS_DENIED`). */
+export declare class DaytonaFileAccessDeniedError extends DaytonaForbiddenError {
+}
+/** The supplied file path was rejected by the daemon (code `INVALID_FILE_PATH`). */
+export declare class DaytonaInvalidFilePathError extends DaytonaBadRequestError {
+}
+/** The daemon could not read the sandbox file (code `FILE_READ_FAILED`). */
+export declare class DaytonaFileReadFailedError extends DaytonaInternalServerError {
+}
+/** The LSP server must be initialized first (code `LSP_SERVER_NOT_INITIALIZED`). */
+export declare class DaytonaLspServerNotInitializedError extends DaytonaBadRequestError {
+}
+/** Command execution exceeded its timeout (code `PROCESS_EXECUTION_TIMEOUT`). */
+export declare class DaytonaProcessExecutionTimeoutError extends DaytonaTimeoutError {
+}
+/** The sandbox process does not exist (code `PROCESS_NOT_FOUND`). */
+export declare class DaytonaProcessNotFoundError extends DaytonaNotFoundError {
+}
+/** The session has already ended (code `SESSION_ENDED`). */
+export declare class DaytonaSessionEndedError extends DaytonaGoneError {
+}
+/** The session command already finished (code `COMMAND_ALREADY_COMPLETED`). */
+export declare class DaytonaCommandAlreadyCompletedError extends DaytonaGoneError {
+}
+/** The accessibility service is unavailable (code `A11Y_UNAVAILABLE`). */
+export declare class DaytonaA11yUnavailableError extends DaytonaServiceUnavailableError {
+}
+/** A screen recording is still active (code `RECORDING_STILL_ACTIVE`). */
+export declare class DaytonaRecordingStillActiveError extends DaytonaConflictError {
+}
+/** ffmpeg is not available for recording (code `RECORDING_FFMPEG_NOT_FOUND`). */
+export declare class DaytonaRecordingFfmpegNotFoundError extends DaytonaServiceUnavailableError {
+}
+/** Maps an HTTP status code to the corresponding Daytona error class. */
 export declare function errorClassFromStatusCode(statusCode?: number): typeof DaytonaError;
 /**
  * Creates the appropriate Daytona error subclass from structured error metadata.
+ *
+ * Resolution order: (source, code) override -> HTTP status code -> DaytonaError.
  */
-export declare function createDaytonaError(message: string, statusCode?: number, headers?: ResponseHeaders, errorCode?: string): DaytonaError;
+export declare function createDaytonaError(message: string, statusCode?: number, headers?: ResponseHeaders, code?: string, source?: string): DaytonaError;
 /**
- * Creates the appropriate Daytona error subclass from an Axios error.
+ * Creates the appropriate Daytona error subclass from an Axios error. Maps
+ * client-side timeouts to DaytonaConnectionTimeoutError, networking failures
+ * (no response received) to DaytonaConnectionError, and HTTP responses to
+ * the most specific subclass via `createDaytonaError`.
  */
 export declare function createAxiosDaytonaError(error: AxiosError): DaytonaError;
 //# sourceMappingURL=DaytonaError.d.ts.map