@buddy-works/sandbox-sdk 0.0.3-rc.0 → 0.1.0-rc.1

package/dist/index.d.mts

@@ -0,0 +1,1629 @@
+import { z } from "zod";
+import { inspect } from "node:util";
+import { Writable } from "node:stream";
+
+//#region src/api/openapi/types.gen.d.ts
+/**
+ * Sandbox reference
+ */
+type SandboxIdView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * The ID of the sandbox
+       */
+  id?: string;
+  /**
+       * A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end).
+       */
+  identifier?: string;
+  /**
+       * The name of the sandbox
+       */
+  name?: string;
+  /**
+       * The current status of the sandbox
+       */
+  status?: "STARTING" | "STOPPING" | "FAILED" | "RUNNING" | "STOPPED" | "RESTORING";
+};
+/**
+ * Integration reference
+ */
+type IntegrationIdView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * A human-readable ID of the integration
+       */
+  identifier?: string;
+  /**
+       * The unique hash ID of the integration
+       */
+  hash_id?: string;
+  /**
+       * The name of the integration
+       */
+  name?: string;
+  /**
+       * The type of integration
+       */
+  type?: "GIT_HUB" | "BITBUCKET" | "GOOGLE" | "DIGITAL_OCEAN" | "SLACK" | "MODULUS" | "HEROKU" | "AMAZON" | "GIT_LAB" | "SHOPIFY" | "GIT_HUB_ENTERPRISE" | "GIT_LAB_ENTERPRISE" | "PUSHOVER" | "PUSHBULLET" | "RACKSPACE" | "CUSTOM" | "CLOUDFLARE" | "NEW_RELIC" | "SENTRY" | "ROLLBAR" | "DATADOG" | "DO_SPACES" | "HONEYBADGER" | "VULTR" | "SENTRY_ENTERPRISE" | "LOGGLY" | "HIP_CHAT" | "FIREBASE" | "TELEGRAM" | "AZURE" | "UPCLOUD" | "GHOST_INSPECTOR" | "NETLIFY" | "AZURE_CLOUD" | "MICROSOFT_TEAMS" | "GOOGLE_SERVICE_ACCOUNT" | "GOOGLE_PLAY_STORE" | "DOCKER_HUB" | "APP_STORE" | "GIT_HUB_APP" | "GIT_HUB_APP_ENTERPRISE" | "GIT_HUB_API" | "ATOP" | "SNYK" | "STACK_HAWK" | "BLACKFIRE" | "BACKBLAZE" | "ONE_LOGIN" | "OKTA" | "CONTENTFUL";
+  /**
+       * The authentication method used by the integration
+       */
+  auth_type?: "OAUTH" | "TOKEN" | "API_KEY" | "APP" | "APP_SPRYKER" | "TOKEN_APP_EXTENSION" | "DEFAULT" | "OIDC" | "TRUSTED" | "APP_RW";
+  /**
+       * The host URL for custom integrations
+       */
+  host_url?: string;
+  /**
+       * The webhook URL for receiving notifications
+       */
+  webhook_address?: string;
+  /**
+       * The ATOP service URL
+       */
+  atop_url?: string;
+  /**
+       * The application ID for Azure Cloud integrations
+       */
+  app_id?: string;
+  /**
+       * The Google Cloud project ID
+       */
+  google_project?: string;
+  /**
+       * The JWT audience for token validation
+       */
+  audience?: string;
+};
+/**
+ * User/member reference
+ */
+type MemberView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * The ID of the user
+       */
+  id?: number;
+  /**
+       * The name of the user
+       */
+  name?: string;
+  /**
+       * The avatar URL of the user
+       */
+  avatar_url?: string;
+  /**
+       * The email address of the user
+       */
+  email?: string;
+  /**
+       * Whether the user has admin privileges
+       */
+  admin?: boolean;
+  /**
+       * Whether the user is workspace owner
+       */
+  workspace_owner?: boolean;
+};
+type ProjectView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * The human-readable ID of the project
+       */
+  name?: string;
+  /**
+       * The Name of the project
+       */
+  display_name: string;
+  /**
+       * The status of the project
+       */
+  status?: string;
+  /**
+       * Indicates if this is a public project
+       */
+  access?: "PRIVATE" | "PUBLIC";
+  /**
+       * The creation date of the project
+       */
+  create_date?: Date;
+  /**
+       * Repo slug of the Bitbucket, GitHub or GitLab project. Required when adding the integrated project
+       */
+  external_project_id?: string;
+  /**
+       * ID of the project in GitLab
+       */
+  git_lab_project_id?: number;
+  /**
+       * SSH or HTTPS url of the git repository. Required when adding the project integrated with custom git repository
+       */
+  custom_repo_url?: string;
+  /**
+       * Username used to authorize access to the git repository. Required when adding the project integrated with custom git repository
+       */
+  custom_repo_user?: string;
+  /**
+       * Password used to authorize access to the git repository. Required when adding the project integrated with custom git repository and the provided `custom_repo_url` is the HTTPS url
+       */
+  custom_repo_pass?: string;
+  /**
+       * The ID of the private SSH key used to authorize access to the git repository. Required when adding the project integrated with private git server by SSH url
+       */
+  custom_repo_ssh_key_id?: number;
+  created_by?: MemberView;
+  /**
+       * The HTTP repository URL
+       */
+  http_repository?: string;
+  /**
+       * The SSH repository URL
+       */
+  ssh_repository?: string;
+  /**
+       * The default branch name
+       */
+  default_branch?: string;
+  integration?: IntegrationIdView;
+  /**
+       * Defines whether the submodules are fetched during the runs in this project
+       */
+  fetch_submodules?: boolean;
+  /**
+       * Name of the key that will be used to authorize while fetching the submodules. Required when `fetch_submodules` is set to `true`
+       */
+  fetch_submodules_env_key?: string;
+  /**
+       * Enables/disables pull requests in the project. Available only for projects synchronized with GitHub or GitHub Enterprise repository
+       */
+  allow_pull_requests?: boolean;
+  /**
+       * If set to true, the default branch will be updated from GitHub/GitLab/Bitbucket.
+       */
+  update_default_branch_from_external?: boolean;
+  /**
+       * If set to true, the project is created without any repository attached.
+       */
+  without_repository?: boolean;
+};
+/**
+ * The TLS/SSL encryption settings of the tunnel
+ */
+type TlsSettingsView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * Where to terminate TLS connection
+       */
+  terminate_at?: "REGION" | "AGENT" | "TARGET";
+};
+/**
+ * The HTTP-specific settings of the tunnel
+ */
+type HttpSettingsView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * Whether to verify SSL/TLS certificates
+       */
+  verify_certificate?: boolean;
+  /**
+       * Enable HTTP compression
+       */
+  compression?: boolean;
+  /**
+       * Enable HTTP/2 protocol support
+       */
+  http2?: boolean;
+  /**
+       * Log incoming HTTP requests
+       */
+  log_requests?: boolean;
+  /**
+       * Custom HTTP headers to add to requests
+       */
+  request_headers?: Array<{
+    [key: string]: string;
+  }>;
+  /**
+       * List of allowed User-Agent strings
+       */
+  whitelist_user_agents?: Array<string>;
+  /**
+       * Rewrite the Host header to this value
+       */
+  rewrite_host_header?: string;
+  /**
+       * Custom HTTP headers to add to responses
+       */
+  response_headers?: Array<{
+    [key: string]: string;
+  }>;
+  /**
+       * Basic authentication username
+       */
+  login?: string;
+  /**
+       * Circuit breaker threshold (number of failed requests)
+       */
+  circuit_breaker?: number;
+  /**
+       * Base path for serving requests
+       */
+  serve_path?: string;
+  /**
+       * Type of authentication used
+       */
+  auth_type?: "NONE" | "BASIC" | "BUDDY";
+};
+type TunnelView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * The name of the tunnel
+       */
+  name: string;
+  /**
+       * The endpoint URL of the tunnel
+       */
+  endpoint: string;
+  /**
+       * The type of the tunnel
+       */
+  type: "TCP" | "TLS" | "HTTP" | "SSH";
+  /**
+       * The region where the tunnel is deployed
+       */
+  region: "US" | "EU" | "AS";
+  /**
+       * The IP addresses or domains allowed to access the tunnel
+       */
+  whitelist?: Array<string>;
+  /**
+       * The connection timeout of the tunnel in seconds
+       */
+  timeout?: number;
+  http?: HttpSettingsView;
+  tls?: TlsSettingsView;
+  /**
+       * The url of the tunnel
+       */
+  endpoint_url?: string;
+};
+type SandboxesView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  sandboxes?: Array<SandboxIdView>;
+};
+/**
+ * Sandbox content listing
+ */
+type SandboxContentView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * List of content items in the directory
+       */
+  contents?: Array<SandboxContentItem>;
+};
+/**
+ * Content item in a sandbox
+ */
+type SandboxContentItem = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * The content type (FILE or DIR)
+       */
+  type?: "FILE" | "DIR";
+  /**
+       * The name of the file or directory
+       */
+  name?: string;
+  /**
+       * The path to the file or directory
+       */
+  path?: string;
+  /**
+       * The size of the file in bytes
+       */
+  size?: bigint;
+};
+type SandboxCommandView = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * The ID of the command
+       */
+  id?: string;
+  /**
+       * Command to execute in the sandbox
+       */
+  command?: string;
+  /**
+       * Runtime environment for command execution (default: `BASH`)
+       */
+  runtime?: "BASH" | "JAVASCRIPT" | "TYPESCRIPT" | "PYTHON";
+  /**
+       * Command execution status
+       */
+  status?: "INPROGRESS" | "SUCCESSFUL" | "FAILED";
+  /**
+       * Command exit code
+       */
+  exit_code?: number;
+  /**
+       * API endpoint URL to retrieve logs for this command
+       */
+  logs_url?: string;
+};
+type SandboxCommandLog = {
+  /**
+       * The type of command output stream
+       */
+  type?: "STDOUT" | "STDERR";
+  /**
+       * The command execution logs.
+       */
+  data?: string;
+};
+type ExecuteSandboxCommandRequest = {
+  /**
+       * Command to execute in the sandbox
+       */
+  command: string;
+  /**
+       * Runtime environment for command execution (default: `BASH`)
+       */
+  runtime?: "BASH" | "JAVASCRIPT" | "TYPESCRIPT" | "PYTHON";
+};
+/**
+ * The list of variables you can use the action
+ */
+type EnvironmentVariableView = {
+  /**
+       * The ID of the variable
+       */
+  id?: number;
+  /**
+       * The name of the variable
+       */
+  key?: string;
+  /**
+       * The value of the variable
+       */
+  value?: string;
+  /**
+       * The type of the added variable
+       */
+  type?: "VAR" | "FILE" | "SSH_KEY" | "IOS_KEYCHAIN" | "IOS_PROVISION_PROFILES" | "SSH_PUBLIC_KEY" | "GPG_KEY";
+  /**
+       * If set to `true` the variable value will be encrypted and hidden
+       */
+  encrypted?: boolean;
+  /**
+       * If set to `true` the variable value can be set by Buddy actions
+       */
+  settable?: boolean;
+  /**
+       * Available only if `type=VAR`. If set to `true` the variable value can be set by Buddy actions only for execution time
+       */
+  run_only_settable?: boolean;
+  /**
+       * The optional description of the variable
+       */
+  description?: string;
+  /**
+       * Initial path for the variable
+       */
+  init_path?: string;
+  /**
+       * Default value for the variable
+       */
+  defaults?: string;
+  /**
+       * Specifies where to copy the file on each run. Set if `type` is `SSH_KEY`
+       */
+  file_path?: string;
+  /**
+       * File permission set on copy to a container on each run. Set if `type` is `SSH_KEY`
+       */
+  file_chmod?: string;
+  /**
+       * Set if `type` is `SSH_KEY`. If it's `NONE`, the variable can be used as a parameter in an action. For `CONTAINER`, the given key is additionally copied to an action container on each run
+       */
+  file_place?: "NONE" | "CONTAINER";
+  /**
+       * Whether the file is binary
+       */
+  binary?: boolean;
+  /**
+       * Public value for SSH key type variables
+       */
+  public_value?: string;
+  /**
+       * Fingerprint of SSH key
+       */
+  key_fingerprint?: string;
+  /**
+       * Checksum of the variable value
+       */
+  checksum?: string;
+  /**
+       * Password for certificates
+       */
+  password?: string;
+  /**
+       * Passphrase for encrypted SSH keys
+       */
+  passphrase?: string;
+  /**
+       * GPG key identifier
+       */
+  key_identifier?: string;
+};
+type CloneSandboxRequest = {
+  /**
+       * The ID of the sandbox to clone
+       */
+  source_sandbox_id: string;
+  /**
+       * The name of the sandbox
+       */
+  name: string;
+  /**
+       * A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end).
+       */
+  identifier?: string;
+};
+type SandboxResponse = {
+  /**
+       * API endpoint to GET this object
+       */
+  readonly url?: string;
+  /**
+       * Web URL to view this object in Buddy.works
+       */
+  readonly html_url?: string;
+  /**
+       * The ID of the sandbox
+       */
+  id?: string;
+  /**
+       * A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end).
+       */
+  identifier?: string;
+  /**
+       * The name of the sandbox
+       */
+  name?: string;
+  /**
+       * The current status of the sandbox
+       */
+  status?: "STARTING" | "STOPPING" | "FAILED" | "RUNNING" | "STOPPED" | "RESTORING";
+  /**
+       * The operating system of the sandbox ["ubuntu:22.04", "ubuntu:24.04"]
+       */
+  os?: string;
+  /**
+       * The resource configuration of the sandbox (CPU x RAM)
+       */
+  resources?: "1x2" | "2x4" | "3x6" | "4x8" | "5x10" | "6x12" | "7x14" | "8x16" | "9x18" | "10x20" | "11x22" | "12x24" | "CUSTOM";
+  /**
+       * The commands to run during setup of the sandbox
+       */
+  install_commands?: string;
+  /**
+       * The run command of the sandbox
+       */
+  run_command?: string;
+  /**
+       * The application directory of the sandbox
+       */
+  app_dir?: string;
+  /**
+       * The application type of the sandbox (passed command or existent service eg. apache2)
+       */
+  app_type?: "CMD" | "SERVICE";
+  /**
+       * The list of tags associated with the sandbox
+       */
+  tags?: Array<string>;
+  /**
+       * The current application status of the sandbox
+       */
+  app_status?: "NONE" | "RUNNING" | "ENDED" | "FAILED";
+  /**
+       * The boot logs of the sandbox
+       */
+  boot_logs?: Array<string>;
+  /**
+       * The current setup status of the sandbox
+       */
+  setup_status?: "INPROGRESS" | "SUCCESS" | "FAILED";
+  /**
+       * The tunnel endpoints of the sandbox
+       */
+  endpoints?: Array<TunnelView>;
+  project?: ProjectView;
+  /**
+       * The environment variables of the sandbox
+       */
+  variables?: Array<EnvironmentVariableView>;
+};
+/**
+ * The environment variables of the sandbox
+ */
+type AddVariableInObjectRequestWritable = {
+  /**
+       * The name of the variable
+       */
+  key: string;
+  /**
+       * The value of the variable
+       */
+  value?: string;
+  /**
+       * If set to `true` the variable value can be set by Buddy actions
+       */
+  settable?: boolean;
+  /**
+       * Available only if `type=VAR`. If set to `true` the variable value can be set by Buddy actions only for execution time
+       */
+  run_only_settable?: boolean;
+  /**
+       * If set to `true` the variable value will be encrypted and hidden
+       */
+  encrypted?: boolean;
+  /**
+       * The optional description of the variable
+       */
+  description?: string;
+  /**
+       * Initial path for the variable
+       */
+  init_path?: string;
+  /**
+       * Default value for the variable
+       */
+  defaults?: string;
+  /**
+       * Specifies where to copy the file on each run. Set if `type` is `SSH_KEY`
+       */
+  file_path?: string;
+  /**
+       * File permission set on copy to a container on each run. Set if `type` is `SSH_KEY`
+       */
+  file_chmod?: string;
+  /**
+       * Set if `type` is `SSH_KEY`. If it's `NONE`, the variable can be used as a parameter in an action. For `CONTAINER`, the given key is additionally copied to an action container on each run
+       */
+  file_place?: "NONE" | "CONTAINER";
+  /**
+       * Password for certificates
+       */
+  password?: string;
+  /**
+       * Passphrase for encrypted SSH keys
+       */
+  passphrase?: string;
+  /**
+       * GPG key identifier
+       */
+  key_identifier?: string;
+  /**
+       * The type of the added variable
+       */
+  type: "VAR" | "FILE" | "SSH_KEY" | "IOS_KEYCHAIN" | "IOS_PROVISION_PROFILES" | "SSH_PUBLIC_KEY" | "GPG_KEY";
+};
+/**
+ * The TLS/SSL encryption settings of the tunnel
+ */
+type TlsSettingsViewWritable = {
+  /**
+       * Private key for TLS certificate
+       */
+  private_key?: string;
+  /**
+       * TLS certificate
+       */
+  certificate?: string;
+  /**
+       * Certificate Authority certificate
+       */
+  ca_certificate?: string;
+  /**
+       * Where to terminate TLS connection
+       */
+  terminate_at?: "REGION" | "AGENT" | "TARGET";
+};
+/**
+ * The HTTP-specific settings of the tunnel
+ */
+type HttpSettingsViewWritable = {
+  /**
+       * Whether to verify SSL/TLS certificates
+       */
+  verify_certificate?: boolean;
+  /**
+       * Enable HTTP compression
+       */
+  compression?: boolean;
+  /**
+       * Enable HTTP/2 protocol support
+       */
+  http2?: boolean;
+  /**
+       * Log incoming HTTP requests
+       */
+  log_requests?: boolean;
+  /**
+       * Custom HTTP headers to add to requests
+       */
+  request_headers?: Array<{
+    [key: string]: string;
+  }>;
+  /**
+       * List of allowed User-Agent strings
+       */
+  whitelist_user_agents?: Array<string>;
+  /**
+       * Rewrite the Host header to this value
+       */
+  rewrite_host_header?: string;
+  /**
+       * Custom HTTP headers to add to responses
+       */
+  response_headers?: Array<{
+    [key: string]: string;
+  }>;
+  /**
+       * Basic authentication username
+       */
+  login?: string;
+  /**
+       * Basic authentication password
+       */
+  password?: string;
+  /**
+       * Custom TLS Certificate Authority
+       */
+  tls_ca?: string;
+  /**
+       * Circuit breaker threshold (number of failed requests)
+       */
+  circuit_breaker?: number;
+  /**
+       * Base path for serving requests
+       */
+  serve_path?: string;
+  /**
+       * Type of authentication used
+       */
+  auth_type?: "NONE" | "BASIC" | "BUDDY";
+};
+type TunnelViewWritable = {
+  /**
+       * The name of the tunnel
+       */
+  name: string;
+  /**
+       * The endpoint URL of the tunnel
+       */
+  endpoint: string;
+  /**
+       * The type of the tunnel
+       */
+  type: "TCP" | "TLS" | "HTTP" | "SSH";
+  /**
+       * The region where the tunnel is deployed
+       */
+  region: "US" | "EU" | "AS";
+  /**
+       * The IP addresses or domains allowed to access the tunnel
+       */
+  whitelist?: Array<string>;
+  /**
+       * The connection timeout of the tunnel in seconds
+       */
+  timeout?: number;
+  http?: HttpSettingsViewWritable;
+  tls?: TlsSettingsViewWritable;
+  /**
+       * The url of the tunnel
+       */
+  endpoint_url?: string;
+};
+type CreateNewSandboxRequestWritable = {
+  /**
+       * The name of the sandbox
+       */
+  name: string;
+  /**
+       * A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end).
+       */
+  identifier?: string;
+  /**
+       * The operating system of the sandbox ["ubuntu:22.04", "ubuntu:24.04"]
+       */
+  os: string;
+  /**
+       * The resource configuration of the sandbox (CPU x RAM)
+       */
+  resources?: "1x2" | "2x4" | "3x6" | "4x8" | "5x10" | "6x12" | "7x14" | "8x16" | "9x18" | "10x20" | "11x22" | "12x24" | "CUSTOM";
+  /**
+       * The commands to run during setup of the sandbox
+       */
+  install_commands?: string;
+  /**
+       * The run command of the sandbox
+       */
+  run_command?: string;
+  /**
+       * The application directory of the sandbox
+       */
+  app_dir?: string;
+  /**
+       * The application type of the sandbox (passed command or existent service eg. apache2)
+       */
+  app_type?: "CMD" | "SERVICE";
+  /**
+       * The list of tags associated with the sandbox
+       */
+  tags?: Array<string>;
+  /**
+       * The tunnel endpoints of the sandbox
+       */
+  endpoints?: Array<TunnelViewWritable>;
+  /**
+       * The environment variables of the sandbox
+       */
+  variables?: Array<AddVariableInObjectRequestWritable>;
+};
+type CreateFromSnapshotRequestWritable = {
+  /**
+       * The ID of the snapshot to create from
+       */
+  snapshot_id: string;
+  /**
+       * The name of the sandbox
+       */
+  name: string;
+  /**
+       * A human-readable ID. Alphanumeric characters, underscores, and hyphens (hyphens cannot appear at the start or end).
+       */
+  identifier?: string;
+  /**
+       * The operating system of the sandbox ["ubuntu:22.04", "ubuntu:24.04"]
+       */
+  os?: string;
+  /**
+       * The resource configuration of the sandbox (CPU x RAM)
+       */
+  resources?: "1x2" | "2x4" | "3x6" | "4x8" | "5x10" | "6x12" | "7x14" | "8x16" | "9x18" | "10x20" | "11x22" | "12x24" | "CUSTOM";
+  /**
+       * The commands to run during setup of the sandbox
+       */
+  install_commands?: string;
+  /**
+       * The run command of the sandbox
+       */
+  run_command?: string;
+  /**
+       * The application directory of the sandbox
+       */
+  app_dir?: string;
+  /**
+       * The application type of the sandbox (passed command or existent service eg. apache2)
+       */
+  app_type?: "CMD" | "SERVICE";
+  /**
+       * The list of tags associated with the sandbox
+       */
+  tags?: Array<string>;
+  /**
+       * The tunnel endpoints of the sandbox
+       */
+  endpoints?: Array<TunnelViewWritable>;
+  /**
+       * The environment variables of the sandbox
+       */
+  variables?: Array<EnvironmentVariableView>;
+};
+type GetSandboxesData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+  };
+  query: {
+    /**
+             * The human-readable ID of the project to filter sandboxes
+             */
+    project_name: string;
+  };
+  url: "/workspaces/{workspace_domain}/sandboxes";
+};
+type AddSandboxData = {
+  body?: CloneSandboxRequest | CreateFromSnapshotRequestWritable | CreateNewSandboxRequestWritable;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+  };
+  query: {
+    /**
+             * The human-readable ID of the project to filter sandboxes
+             */
+    project_name: string;
+  };
+  url: "/workspaces/{workspace_domain}/sandboxes";
+};
+type DeleteSandboxData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    id: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{id}";
+};
+type GetSandboxData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    id: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{id}";
+};
+type GetSandboxResponses = {
+  200: SandboxResponse;
+};
+type GetSandboxResponse = GetSandboxResponses[keyof GetSandboxResponses];
+type ExecuteSandboxCommandData = {
+  body?: ExecuteSandboxCommandRequest;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/commands";
+};
+type ExecuteSandboxCommandResponses = {
+  200: SandboxCommandView;
+};
+type ExecuteSandboxCommandResponse = ExecuteSandboxCommandResponses[keyof ExecuteSandboxCommandResponses];
+type GetSandboxCommandData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+    /**
+             * The ID of the command
+             */
+    id: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/commands/{id}";
+};
+type GetSandboxCommandLogsData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+    /**
+             * The ID of the command
+             */
+    command_id: string;
+  };
+  query?: {
+    /**
+             * If true, streams logs until the command completes
+             */
+    follow?: boolean;
+  };
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/commands/{command_id}/logs";
+};
+type TerminateSandboxCommandData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+    /**
+             * The ID of the command
+             */
+    command_id: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/commands/{command_id}/terminate";
+};
+type DeleteSandboxFileData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+    /**
+             * Absolute path to the file or directory to delete
+             */
+    path: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/content/{path}";
+};
+type DeleteSandboxFileResponses = {
+  /**
+       * File or directory deleted successfully
+       */
+  204: void;
+};
+type DeleteSandboxFileResponse = DeleteSandboxFileResponses[keyof DeleteSandboxFileResponses];
+type GetSandboxContentData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+    /**
+             * Absolute path to the file or directory. Recommended directory is `/buddy`
+             */
+    path: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/content/{path}";
+};
+type GetSandboxContentResponses = {
+  /**
+       * Content retrieved successfully
+       */
+  200: SandboxContentView;
+};
+type GetSandboxContentResponse = GetSandboxContentResponses[keyof GetSandboxContentResponses];
+type CreateSandboxDirectoryData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+    /**
+             * Absolute path where the directory should be created
+             */
+    path: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/content/{path}";
+};
+type CreateSandboxDirectoryResponses = {
+  /**
+       * Directory created successfully
+       */
+  201: SandboxContentItem;
+};
+type CreateSandboxDirectoryResponse = CreateSandboxDirectoryResponses[keyof CreateSandboxDirectoryResponses];
+type UploadSandboxFileResponses = {
+  /**
+       * File uploaded successfully
+       */
+  201: SandboxContentItem;
+};
+type UploadSandboxFileResponse = UploadSandboxFileResponses[keyof UploadSandboxFileResponses];
+type RestartSandboxData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/restart";
+};
+type StartSandboxData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/start";
+};
+type StopSandboxData = {
+  body?: never;
+  path: {
+    /**
+             * The human-readable ID of the workspace
+             */
+    workspace_domain: string;
+    /**
+             * The ID of the sandbox
+             */
+    sandbox_id: string;
+  };
+  query?: never;
+  url: "/workspaces/{workspace_domain}/sandboxes/{sandbox_id}/stop";
+};
+//#endregion
+//#region src/core/http-client.d.ts
+/** Configuration options for creating an HttpClient instance */
+interface HttpClientConfig {
+  /** Base URL prepended to all request paths */
+  baseURL?: string;
+  /** Request timeout in milliseconds */
+  timeout?: number;
+  /** Default headers sent with every request */
+  headers?: Record<string, string>;
+  /** Enable detailed request/response logging */
+  debugMode?: boolean;
+}
+/** Per-request configuration options */
+interface RequestConfig {
+  /** Disable automatic retry on transient failures */
+  skipRetry?: boolean;
+  /** URL query parameters to append */
+  queryParams?: Record<string, string | number | boolean | undefined>;
+  /** Additional headers for this request only */
+  headers?: Record<string, string>;
+  /** Response parsing mode */
+  responseType?: "json" | "text";
+}
+/** Normalized HTTP response with status, data, and headers */
+interface HttpResponse<T = unknown> {
+  /** HTTP status code (e.g. 200, 404) */
+  status: number;
+  /** HTTP status text (e.g. "OK", "Not Found") */
+  statusText: string;
+  /** Parsed response body */
+  data: T;
+  /** Response headers */
+  headers: Headers;
+}
+/** Base HTTP client with retry logic, timeout handling, and authentication support */
+declare class HttpClient {
+  #private;
+  protected readonly debugMode: boolean;
+  /** Create a new HTTP client with optional base URL, timeout, and headers */
+  constructor(config?: HttpClientConfig);
+  /** Perform a GET request */
+  get<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+  /** Perform a POST request with optional body data */
+  post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<HttpResponse<T>>;
+  /** Perform a DELETE request */
+  delete<T = unknown>(url: string, config?: RequestConfig): Promise<HttpResponse<T>>;
+  /** Set the Bearer token for authenticated requests */
+  setAuthToken(token: string): void;
+}
+//#endregion
+//#region src/types/utils.d.ts
+/**
+ * Utility type to make some properties of an object required.
+ */
+type WithRequired<T, K extends keyof T> = T & { [P in K]-?: NonNullable<T[P]> };
+//#endregion
+//#region src/types/index.d.ts
+type Data = {
+  body?: Record<string, unknown>;
+  path?: Record<string, string>;
+  query?: Record<string, string | boolean>;
+  url: string;
+};
+type OmitIfEmpty<T> = keyof T extends never ? never : T;
+type ClientPath<D extends Data> = NonNullable<D["path"]> extends infer P extends object ? OmitIfEmpty<Omit<P, "workspace_domain">> : never;
+type ClientQuery<D extends Data> = NonNullable<D["query"]> extends infer Q extends object ? OmitIfEmpty<Omit<Q, "project_name">> : never;
+type PathProp<D extends Data> = [ClientPath<D>] extends [never] ? {
+  path?: undefined;
+} : {
+  path: ClientPath<D>;
+};
+type QueryProp<D extends Data> = [ClientQuery<D>] extends [never] ? {
+  query?: undefined;
+} : {
+  query: ClientQuery<D>;
+};
+type ClientData<D extends Data> = Omit<WithRequired<D, D["body"] extends undefined ? never : "body">, "url" | "path" | "query"> & PathProp<D> & QueryProp<D>;
+//#endregion
+//#region src/core/buddy-api-client.d.ts
+/** Configuration options for creating a BuddyApiClient instance */
+interface BuddyApiConfig extends Omit<HttpClientConfig, "baseURL"> {
+  /** Buddy workspace domain (e.g. "mycompany") */
+  workspace: string;
+  /** Project name within the workspace */
+  project_name: string;
+  /** API authentication token (falls back to BUDDY_TOKEN env var) */
+  token?: string;
+  /** Base URL of the Buddy API */
+  apiUrl: string;
+}
+/** API client for Buddy sandbox operations with request validation and response transformation */
+declare class BuddyApiClient extends HttpClient {
+  #private;
+  readonly workspace: BuddyApiConfig["workspace"];
+  readonly project_name: BuddyApiConfig["project_name"];
+  /** Create a new sandbox */
+  addSandbox<const Data$1 extends AddSandboxData>(data: ClientData<Data$1>): Promise<SandboxResponse>;
+  /** Get a specific sandbox by its ID */
+  getSandboxById<const Data$1 extends GetSandboxData>(data: ClientData<Data$1>): Promise<SandboxResponse>;
+  /** Execute a command in a sandbox */
+  executeCommand<const Data$1 extends ExecuteSandboxCommandData>(data: ClientData<Data$1>): Promise<SandboxCommandView>;
+  /** Get a specific command execution details */
+  getCommandDetails<const Data$1 extends GetSandboxCommandData>(data: ClientData<Data$1>): Promise<SandboxCommandView>;
+  /** Terminate a running command in a sandbox */
+  terminateCommand<const Data$1 extends TerminateSandboxCommandData>(data: ClientData<Data$1>): Promise<SandboxCommandView>;
+  /** Delete a sandbox by its ID */
+  deleteSandboxById<const Data$1 extends DeleteSandboxData>(data: ClientData<Data$1>): Promise<void>;
+  /** Get all sandboxes in the workspace for a specific project */
+  getSandboxes<const Data$1 extends GetSandboxesData>(data: ClientData<Data$1>): Promise<SandboxesView>;
+  /** Start a sandbox */
+  startSandbox<const Data$1 extends StartSandboxData>(data: ClientData<Data$1>): Promise<SandboxResponse>;
+  /** Stop a sandbox */
+  stopSandbox<const Data$1 extends StopSandboxData>(data: ClientData<Data$1>): Promise<SandboxResponse>;
+  /** Restart a sandbox */
+  restartSandbox<const Data$1 extends RestartSandboxData>(data: ClientData<Data$1>): Promise<SandboxResponse>;
+  /** Get sandbox content (list files/directories at a path) */
+  getSandboxContent<const Data$1 extends GetSandboxContentData>(data: ClientData<Data$1>): Promise<GetSandboxContentResponse>;
+  /** Delete a file or directory from a sandbox */
+  deleteSandboxFile<const Data$1 extends DeleteSandboxFileData>(data: ClientData<Data$1>): Promise<DeleteSandboxFileResponse>;
+  /** Create a directory in a sandbox */
+  createSandboxDirectory<const Data$1 extends CreateSandboxDirectoryData>(data: ClientData<Data$1>): Promise<CreateSandboxDirectoryResponse>;
+  /** Upload a file to a sandbox */
+  uploadSandboxFile(data: {
+    body: Blob | File;
+    path: {
+      sandbox_id: string;
+      path: string;
+    };
+  }): Promise<UploadSandboxFileResponse>;
+  /** Download content from a sandbox (file or directory as tar.gz) */
+  downloadSandboxContent(data: {
+    path: {
+      sandbox_id: string;
+      path: string;
+    };
+  }): Promise<{
+    data: ArrayBuffer;
+    filename: string;
+  }>;
+  /** Stream logs from a specific command execution */
+  streamCommandLogs<const Data$1 extends GetSandboxCommandLogsData>(data: ClientData<Data$1>): AsyncGenerator<SandboxCommandLog, void, unknown>;
+  /** Create a new Buddy API client instance */
+  constructor(config: BuddyApiConfig);
+}
+//#endregion
+//#region src/entity/command.d.ts
+/** Represents a running or completed command execution in a sandbox */
+declare class Command {
+  protected readonly commandResponse: ExecuteSandboxCommandResponse;
+  protected readonly client: BuddyApiClient;
+  protected readonly sandboxId: string;
+  protected readonly commandId: string;
+  /** Create a new Command instance from an API response */
+  constructor({
+    commandResponse,
+    client,
+    sandboxId
+  }: {
+    commandResponse: ExecuteSandboxCommandResponse;
+    client: BuddyApiClient;
+    sandboxId: string;
+  });
+  /** The raw command response data from the API */
+  get data(): SandboxCommandView;
+  /**
+       * Stream logs from the command in real-time
+       * @returns AsyncGenerator yielding log entries with type and data
+       */
+  logs({
+    follow
+  }?: {
+    follow?: boolean;
+  }): AsyncGenerator<SandboxCommandLog, void, unknown>;
+  /**
+       * Wait for the command to finish execution
+       * @returns Command instance with final response data
+       */
+  wait(): Promise<Command>;
+  /**
+       * Get all output from the command (waits for completion)
+       * @returns Complete output as a string
+       */
+  output(stream?: "STDOUT" | "STDERR" | "BOTH"): Promise<string>;
+  /**
+       * Get all stdout output from the command (waits for completion)
+       * @returns Stdout as a string
+       */
+  stdout(): Promise<string>;
+  /**
+       * Get all stderr output from the command (waits for completion)
+       * @returns Stderr as a string
+       */
+  stderr(): Promise<string>;
+  /** Terminate the running command */
+  kill(): Promise<void>;
+  /**
+       * Poll the API until the command reaches a terminal state
+       * @returns Final command response
+       */
+  protected pollForCommandCompletion(pollIntervalMs?: number): Promise<ExecuteSandboxCommandResponse>;
+}
+//#endregion
+//#region src/utils/regions.d.ts
+declare const REGIONS: {
+  readonly US: "US";
+  readonly EU: "EU";
+  readonly AP: "AP";
+};
+type Region = (typeof REGIONS)[keyof typeof REGIONS];
+declare const API_URLS: Record<Region, string>;
+//#endregion
+//#region src/utils/client.d.ts
+/** Connection configuration for workspace and API authentication */
+interface ConnectionConfig {
+  /** Workspace name/slug (falls back to BUDDY_WORKSPACE env var) */
+  workspace?: string;
+  /** Project name/slug (falls back to BUDDY_PROJECT env var) */
+  project?: string;
+  /** API authentication token (falls back to BUDDY_TOKEN env var) */
+  token?: string;
+  /** API region: US, EU, or AP (falls back to BUDDY_REGION env var) */
+  region?: Region;
+  /** Custom API URL for testing (falls back to BUDDY_API_URL env var) */
+  apiUrl?: string;
+}
+//#endregion
+//#region src/entity/filesystem.d.ts
+/**
+ * File information returned by file system operations
+ */
+interface FileInfo {
+  /** File or directory name */
+  name: string;
+  /** Full path to the file or directory */
+  path: string;
+  /** Type: "FILE" or "DIR" */
+  type: "FILE" | "DIR";
+  /** Size in bytes (for files) */
+  size?: bigint;
+  /** API URL for this item */
+  url?: string;
+  /** Web URL for viewing in Buddy.works */
+  htmlUrl?: string;
+}
+/**
+ * Configuration for getting a FileSystem instance
+ */
+interface GetFileSystemConfig {
+  /** Optional connection configuration to override defaults */
+  connection?: ConnectionConfig;
+}
+/**
+ * Provides file system operations within a Sandbox.
+ *
+ * FileSystem instances can be created either direct via `FileSystem.forSandbox()`
+ * or accessed via the `Sandbox.fs` property.
+ */
+declare class FileSystem {
+  #private;
+  /**
+       * Create a FileSystem instance for a specific sandbox.
+       *
+       * @param sandboxId - The ID of the sandbox
+       * @param config - Optional configuration including connection settings
+       * @returns A FileSystem instance for the specified sandbox
+       */
+  static forSandbox(sandboxId: string, config?: GetFileSystemConfig): FileSystem;
+  constructor(client: BuddyApiClient, sandboxId: string);
+  /**
+       * Lists contents of a directory in the Sandbox.
+       *
+       * @param dirPath - Directory path to list. Relative paths are resolved based on the sandbox working directory.
+       * @returns Array of file and directory information
+       */
+  listFiles(dirPath: string): Promise<FileInfo[]>;
+  /**
+       * Create a new directory in the Sandbox.
+       *
+       * @param dirPath - Path where the directory should be created
+       */
+  createFolder(dirPath: string): Promise<void>;
+  /**
+       * Deletes a file or directory from the Sandbox.
+       *
+       * @param filePath - Path to the file or directory to delete
+       */
+  deleteFile(filePath: string): Promise<void>;
+  /**
+       * Downloads a file from the Sandbox.
+       *
+       * @param remotePath - Path to the file in the Sandbox
+       * @param localPath - Optional local path to save the file
+       * @returns File contents as a Buffer
+       */
+  downloadFile(remotePath: string, localPath?: string): Promise<Buffer>;
+  /**
+       * Uploads a file to the Sandbox.
+       *
+       * @param source - Buffer with content or path to local file
+       * @param remotePath - Destination path in the Sandbox
+       */
+  uploadFile(source: Buffer | string, remotePath: string): Promise<void>;
+}
+//#endregion
+//#region src/entity/sandbox.d.ts
+/**
+ * Configuration for creating a new sandbox
+ */
+interface CreateSandboxConfig extends Partial<CreateNewSandboxRequestWritable> {
+  /** Optional connection configuration to override defaults */
+  connection?: ConnectionConfig;
+}
+/**
+ * Configuration for getting an existing sandbox
+ */
+interface GetSandboxConfig {
+  /** Optional connection configuration to override defaults */
+  connection?: ConnectionConfig;
+}
+/**
+ * Configuration for listing sandboxes
+ */
+interface ListSandboxesConfig {
+  /** Optional connection configuration to override defaults */
+  connection?: ConnectionConfig;
+}
+/**
+ * Options for running a command in the sandbox
+ */
+interface RunCommandOptions extends ExecuteSandboxCommandRequest {
+  /** Stream to write stdout to (default: process.stdout, null to disable) */
+  stdout?: Writable | null;
+  /** Stream to write stderr to (default: process.stderr, null to disable) */
+  stderr?: Writable | null;
+  /** Whether to run the command in detached mode (non-blocking) */
+  detached?: boolean;
+}
+declare class Sandbox {
+  #private;
+  /** The raw sandbox response data from the API */
+  get data(): SandboxResponse;
+  /** The sandbox ID, throws if not initialized */
+  get initializedId(): NonNullable<GetSandboxResponse["id"]>;
+  /**
+       * File system operations for this sandbox.
+       * Provides methods for listing, uploading, downloading, and managing files.
+       */
+  get fs(): FileSystem;
+  /**
+       * Create a new sandbox
+       * @param config - Sandbox configuration including identifier, name, os, and optional connection settings
+       * @returns A ready-to-use Sandbox instance
+       */
+  static create(config?: CreateSandboxConfig): Promise<Sandbox>;
+  /**
+       * Get an existing sandbox by its identifier
+       * @param identifier - Identifier of the sandbox to retrieve
+       * @param config - Optional configuration including connection settings
+       * @returns The Sandbox instance
+       */
+  static getByIdentifier(identifier: NonNullable<GetSandboxResponse["identifier"]>, config?: GetSandboxConfig): Promise<Sandbox>;
+  /**
+       * Get an existing sandbox by its ID
+       * @param sandboxId - ID of the sandbox to retrieve
+       * @param config - Optional configuration including connection settings
+       * @returns The Sandbox instance
+       */
+  static getById(sandboxId: NonNullable<GetSandboxResponse["id"]>, config?: GetSandboxConfig): Promise<Sandbox>;
+  /**
+       * List all sandboxes in the workspace
+       *
+       * Returns a simplified view of each sandbox (id, identifier, name, status, urls)
+       * rather than full Sandbox instances. Use `getById()` or `getByIdentifier()`
+       * to get a full Sandbox instance for a specific sandbox.
+       *
+       * @param config - Optional configuration including connection settings
+       * @returns Array of simplified sandbox objects
+       */
+  static list(config?: ListSandboxesConfig): Promise<SandboxIdView[]>;
+  /**
+       * Execute a command in the sandbox
+       * @returns Command instance (call wait() for blocking execution)
+       */
+  runCommand(options: RunCommandOptions): Promise<Command>;
+  /**
+       * Delete the sandbox permanently
+       */
+  destroy(): Promise<void>;
+  /**
+       * Refresh the sandbox data from the API
+       * Updates the internal state with the latest sandbox information
+       */
+  refresh(): Promise<void>;
+  /**
+       * Wait until the sandbox setup is complete
+       * @param pollIntervalMs - How often to check the status (default: 1000ms)
+       */
+  waitUntilReady(pollIntervalMs?: number): Promise<void>;
+  /**
+       * Wait until the sandbox is in RUNNING state
+       * @param pollIntervalMs - How often to check the status (default: 1000ms)
+       * @param maxWaitMs - Maximum time to wait before timing out (default: 60000ms)
+       */
+  waitUntilRunning(pollIntervalMs?: number, maxWaitMs?: number): Promise<void>;
+  /**
+       * Wait until the sandbox is in STOPPED state
+       * @param pollIntervalMs - How often to check the status (default: 1000ms)
+       * @param maxWaitMs - Maximum time to wait before timing out (default: 60000ms)
+       */
+  waitUntilStopped(pollIntervalMs?: number, maxWaitMs?: number): Promise<void>;
+  /**
+       * Start a stopped sandbox
+       * Waits until the sandbox reaches RUNNING state
+       */
+  start(): Promise<void>;
+  /**
+       * Stop a running sandbox
+       * Waits until the sandbox reaches STOPPED state
+       */
+  stop(): Promise<void>;
+  /**
+       * Restart the sandbox
+       * Waits until the sandbox reaches RUNNING state and setup is complete
+       */
+  restart(): Promise<void>;
+  private constructor();
+}
+//#endregion
+//#region src/errors/index.d.ts
+declare const ERROR_CODES: {
+  /** HTTP errors - use statusCode field to distinguish (401, 403, 404, 500, etc.) */readonly HTTP_ERROR: "HTTP_ERROR"; /** Zod validation errors from user input */
+  readonly VALIDATION_ERROR: "VALIDATION_ERROR"; /** All other errors (config, streaming, internal, etc.) */
+  readonly GENERIC_ERROR: "GENERIC_ERROR";
+};
+type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+declare class BuddySDKError extends Error {
+  readonly code: ErrorCode;
+  readonly statusCode?: number;
+  readonly details?: unknown;
+  readonly cause?: Error;
+  constructor(message: string, options?: {
+    code?: ErrorCode;
+    statusCode?: number;
+    details?: unknown;
+    cause?: Error;
+  });
+}
+//#endregion
+export { API_URLS, BuddyApiClient, BuddySDKError, Command, type ConnectionConfig, type CreateSandboxConfig, ERROR_CODES, type ErrorCode, type FileInfo, FileSystem, type GetFileSystemConfig, type GetSandboxConfig, type ListSandboxesConfig, REGIONS, type Region, Sandbox, type SandboxIdView };