@bugbug-io/sdk 13.39.1

package/README.md

@@ -0,0 +1,576 @@
+<div align="center">
+
+![BugBug Logo](https://bugbug.io/favicon-96x96.png)
+
+# BugBug SDK
+
+**TypeScript SDK for BugBug**
+
+A comprehensive TypeScript SDK for interacting with the [BugBug](https://bugbug.io) API, featuring rate limiting, error handling, and built-in progress watching utilities.
+
+</div>
+
+## Features
+
+- **Easy to use** - Simple factory function and intuitive API
+- **Type-safe** - Full TypeScript support with comprehensive type definitions
+- **Rate limiting** - Built-in exponential backoff and request throttling
+- **Error handling** - Comprehensive error types and automatic retries
+- **Request cancellation** - AbortController support for all requests
+- **Progress watching utilities** - Built-in polling for test and suite completion
+- **Verbose logging** - Detailed request/response logging for debugging
+- **Metrics collection** - Optional telemetry and performance tracking
+
+## Installation
+
+```bash
+npm install @bugbug-io/sdk
+```
+
+## Quick Start
+
+```typescript
+import { createBugBug } from '@bugbug-io/sdk';
+
+const bugbug = createBugBug({
+  apiToken: 'your-api-token',
+  verbose: true, // Enable detailed logging
+});
+
+// Run a test and watch progress until completion
+const result = await bugbug.tests.startRun('my-test', {
+  watchProgress: true,
+  onProgress: (run) => console.log(`Status: ${run.status}`),
+});
+
+console.log('Test completed:', result.status);
+
+// Get recent test runs
+const recentTests = await bugbug.tests.getRecentRuns({ hours: 24 });
+
+// Run a suite
+const suiteResult = await bugbug.suites.startRun('suite-id', {
+  watchProgress: true,
+});
+```
+
+## Configuration
+
+### Basic Configuration
+
+```typescript
+const bugbug = createBugBug({
+  apiToken: 'your-api-token',
+});
+```
+
+### Advanced Configuration
+
+```typescript
+const bugbug = createBugBug({
+  apiToken: 'your-api-token',
+  apiUrl: 'https://app.bugbug.io/api/v2', // Full API base URL. Default: https://app.bugbug.io/api/v2
+  verbose: false, // Enable detailed logging
+  logLevel: 'info', // 'debug' | 'info' | 'warn' | 'error'
+  timeout: 30000, // Request timeout in milliseconds
+
+  // Rate limiting configuration
+  rateLimit: {
+    maxRequests: 100, // Max requests per window
+    windowMs: 60000, // Time window in milliseconds
+    exponentialBackoff: {
+      baseDelay: 1000, // Base delay for retries (ms)
+      maxDelay: 30000, // Maximum delay (ms)
+      maxRetries: 3, // Maximum retry attempts on rate-limit
+    },
+  },
+});
+```
+
+> **Note on `apiUrl`:** The SDK treats `apiUrl` as the **full API base URL** and does not auto-append `/api/v2` or rewrite the value in any way. Pass a complete URL like `https://app.bugbug.io/api/v2`. Host-only values will route to the wrong endpoint.
+
+## API Reference
+
+### Auth
+
+```typescript
+import {
+  BUGBUG_CLI_OAUTH_CLIENT_ID,
+  BUGBUG_OAUTH_CODE_CHALLENGE_METHOD,
+  createOAuthCodeChallenge,
+  createOAuthCodeVerifier,
+  createOAuthState,
+  createBugBug,
+} from '@bugbug-io/sdk';
+
+const bugbug = createBugBug({ apiToken: 'placeholder' });
+const codeVerifier = createOAuthCodeVerifier();
+const authorize = await bugbug.auth.getAuth({
+  clientId: BUGBUG_CLI_OAUTH_CLIENT_ID,
+  redirectUri: 'http://127.0.0.1:48123/callback',
+  codeChallenge: createOAuthCodeChallenge(codeVerifier),
+  codeChallengeMethod: BUGBUG_OAUTH_CODE_CHALLENGE_METHOD,
+  state: createOAuthState(),
+});
+```
+
+`auth.getAuth` and `auth.exchangeCode` call root `/auth/...` endpoints and do
+not send the configured API token. `auth.identity` validates the configured token.
+
+### Tests
+
+```typescript
+// List all tests
+const tests = await bugbug.tests.list({
+  page: 1,
+  pageSize: 50,
+  query: 'search-term',
+  ordering: 'name', // 'name' | '-name' | 'created' | '-created'
+});
+
+// Get a specific test
+const test = await bugbug.tests.get('test-id');
+
+// Run a test by name or UUID (fire-and-forget; returns the run state)
+const runState = await bugbug.tests.startRun('test-id-or-name', {
+  profileName: 'Production',
+  variables: [
+    { key: 'username', value: 'testuser' },
+    { key: 'password', value: 'testpass' },
+  ],
+});
+
+// Run a test and watch progress until completion (returns full TestRun)
+const completedRun = await bugbug.tests.startRun('test-id-or-name', {
+  watchProgress: true,
+  pollInterval: 2000, // Check every 2 seconds
+  timeout: 300000, // 5 minute timeout
+  onProgress: (state) => console.log(`Status: ${state.status}`),
+});
+
+// Poll an existing run until it finishes
+const run = await bugbug.tests.watchRunProgress(
+  runState.id,
+  (state) => console.log(`Status: ${state.status}`),
+  { pollInterval: 2000, timeout: 300000 },
+);
+
+// Get run details / lightweight progress
+const runDetails = await bugbug.tests.getRun('run-id');
+const status = await bugbug.tests.getRunProgress('run-id');
+
+// Recent runs, logs, screenshots, JUnit report
+const recentTests = await bugbug.tests.getRecentRuns({ hours: 24 });
+const logs = await bugbug.tests.getRunLogs('run-id');
+const screenshots = await bugbug.tests.getRunScreenshots('run-id');
+const junitXml = await bugbug.tests.downloadRunJunitReport('run-id');
+
+// Stop a running test
+await bugbug.tests.stopRun('run-id');
+```
+
+### Suites
+
+```typescript
+// List all suites
+const suites = await bugbug.suites.list();
+
+// Get a specific suite
+const suite = await bugbug.suites.get('suite-id');
+
+// Run a suite (fire-and-forget; returns the run state)
+const runState = await bugbug.suites.startRun('suite-id', {
+  profileName: 'Production',
+});
+
+// Run a suite and watch progress until completion (returns full SuiteRun)
+const completedRun = await bugbug.suites.startRun('suite-id', {
+  watchProgress: true,
+  onProgress: (state) => console.log(`Status: ${state.status}`),
+});
+
+// Poll an existing suite run until it finishes
+const run = await bugbug.suites.watchRunProgress(runState.id, (state) =>
+  console.log(`Status: ${state.status}`),
+);
+
+// Run details, recent runs, and JUnit report
+const runDetails = await bugbug.suites.getRun('run-id');
+const recentSuites = await bugbug.suites.getRecentRuns({ hours: 24 });
+const junitXml = await bugbug.suites.downloadRunJunitReport('run-id');
+
+// Stop a running suite
+await bugbug.suites.stopRun('run-id');
+```
+
+### Profiles
+
+```typescript
+// List all profiles
+const profiles = await bugbug.profiles.list();
+
+// Get a specific profile
+const profile = await bugbug.profiles.get('profile-id');
+
+// Find profile by name
+const profile = await bugbug.profiles.findByName('Production');
+
+// Get all profiles (handles pagination)
+const allProfiles = await bugbug.profiles.getAll();
+
+// Get default profile
+const defaultProfile = await bugbug.profiles.getDefault();
+```
+
+### Configuration & System Info
+
+```typescript
+// Get IP addresses for whitelisting
+const ips = await bugbug.config.getIpAddresses();
+
+// Test connectivity
+const isConnected = await bugbug.testConnection();
+
+// Get system information (IP addresses + connectivity probe)
+const systemInfo = await bugbug.config.getSystemInfo();
+```
+
+### Groups (Components)
+
+Groups represent reusable test components or test building blocks.
+
+```typescript
+// List all groups
+const groups = await bugbug.groups.list({
+  query: 'login',
+  page: 1,
+  pageSize: 50,
+});
+
+// Get a specific group
+const group = await bugbug.groups.get('group-id');
+
+// Create a new group
+const newGroup = await bugbug.groups.create({
+  name: 'Login Component',
+});
+
+// Update a group
+const updatedGroup = await bugbug.groups.update('group-id', {
+  name: 'Updated Login Component',
+});
+
+// Partially update a group
+const patchedGroup = await bugbug.groups.partialUpdate('group-id', {
+  name: 'Patched Name',
+});
+
+// Delete a group
+await bugbug.groups.delete('group-id');
+```
+
+### Components
+
+Components are reusable test building blocks that can be shared across multiple tests.
+
+```typescript
+// List all components
+const components = await bugbug.components.list({
+  query: 'login',
+  page: 1,
+  pageSize: 50,
+});
+
+// The response has a nested structure
+const { results } = components;
+const componentsList = results.results; // Array of components
+
+// See which tests use a component
+const usage = await bugbug.components.getUsage('component-id');
+```
+
+### Steps
+
+Steps represent individual actions within tests or groups.
+
+```typescript
+// ✅ NEW: Get steps through their parent group
+const group = await bugbug.groups.get('group-id');
+const steps = group.steps; // Array of steps in this group
+
+// ✅ Get a specific step by ID
+const step = await bugbug.steps.get('step-id');
+
+// ✅ List groups to find steps
+const groups = await bugbug.groups.list({ query: 'login' });
+groups.results.forEach((group) => {
+  console.log(`Group: ${group.name}, Steps: ${group.steps?.length || 0}`);
+});
+
+// Create a new step
+const newStep = await bugbug.steps.create({
+  type: 'click',
+  name: 'Click Login Button',
+  groupId: 'group-id',
+  isActive: true,
+  runTimeout: 30,
+  interactionPosition: 'center',
+  selectorsPresets: [],
+});
+
+// Update a step
+const updatedStep = await bugbug.steps.update('step-id', {
+  type: 'click',
+  name: 'Updated Step',
+  groupId: 'group-id',
+  interactionPosition: 'center',
+  selectorsPresets: [],
+});
+
+// Partially update a step
+const patchedStep = await bugbug.steps.partialUpdate('step-id', {
+  type: 'click',
+  name: 'Patched Step Name',
+  runTimeout: 60,
+});
+
+// Delete a step
+await bugbug.steps.delete('step-id');
+```
+
+### Step Runs
+
+```typescript
+// Get details of a single step run (selectors, errors, screenshots)
+const stepRun = await bugbug.stepRuns.get('step-run-id');
+```
+
+### Project
+
+The `project` module operates on the single project the API token is scoped to.
+
+```typescript
+// Get settings for the authenticated project
+const settings = await bugbug.project.getSettings();
+
+// Export the project as a ZIP archive (Uint8Array)
+const zipBytes = await bugbug.project.export();
+
+// Import a project from ZIP bytes
+await bugbug.project.import(zipBytes);
+```
+
+### Projects
+
+```typescript
+// List the projects available to the current credentials
+const projects = await bugbug.projects.list();
+```
+
+### Visual Regression
+
+```typescript
+// List reference screenshots for a step
+const refs = await bugbug.visualRegression.listReferenceScreenshots({
+  stepId: 'step-id',
+  page: 1,
+  pageSize: 50,
+});
+
+// Get a single reference screenshot
+const ref = await bugbug.visualRegression.getReferenceScreenshot('ref-id');
+
+// Create, update, and delete reference screenshots
+const created = await bugbug.visualRegression.createReferenceScreenshot({
+  stepId: 'step-id',
+  screenshot: 'https://example.com/reference.png',
+});
+await bugbug.visualRegression.updateReferenceScreenshot('ref-id', { isActive: false });
+await bugbug.visualRegression.deleteReferenceScreenshot('ref-id');
+```
+
+### Tests - Extended CRUD Operations
+
+In addition to running tests, you can now create, update, and delete tests programmatically.
+
+```typescript
+// Create a new test
+const newTest = await bugbug.tests.create({
+  name: 'My New Test',
+  screenSizeType: 'desktop',
+});
+
+// Update a test
+const updatedTest = await bugbug.tests.update('test-id', {
+  name: 'Updated Test Name',
+  isActive: true,
+});
+
+// Partially update a test
+const patchedTest = await bugbug.tests.partialUpdate('test-id', {
+  name: 'Patched Test Name',
+});
+
+// Delete a test
+await bugbug.tests.delete('test-id');
+
+// Link a component (group) to a test
+await bugbug.tests.linkComponent('test-id', {
+  groupId: 'group-id',
+  atIndex: 0, // Optional: insert at specific position
+});
+
+// Unlink a component from a test
+await bugbug.tests.unlinkComponent('test-id', 'group-id');
+
+// Get test run logs
+const logs = await bugbug.tests.getRunLogs('run-id');
+
+// Download JUnit report
+const junitXml = await bugbug.tests.downloadRunJunitReport('run-id');
+```
+
+## High-Level Methods
+
+### Running Tests with Progress Watching
+
+```typescript
+// Run test and watch progress until completion
+const result = await bugbug.tests.startRun('test-name-or-id', {
+  watchProgress: true,
+  profileName: 'Production',
+  timeout: 600000, // 10 minutes
+  onProgress: (run) => {
+    console.log(`Test ${run.id}: ${run.status}`);
+  },
+});
+```
+
+### Running Suites with Progress Watching
+
+```typescript
+// Run suite and watch progress until completion
+const result = await bugbug.suites.startRun('suite-id', {
+  watchProgress: true,
+  profileName: 'Production',
+  onProgress: (run) => {
+    console.log(`Suite ${run.id}: ${run.status} (${run.test_runs?.length || 0} tests)`);
+  },
+});
+```
+
+## Error Handling
+
+The SDK provides comprehensive error types for different scenarios:
+
+```typescript
+import {
+  BugBugError,
+  AuthenticationError,
+  AuthorizationError,
+  ValidationError,
+  NotFoundError,
+  RateLimitError,
+  NetworkError,
+  CancellationError,
+  TimeoutError,
+} from '@bugbug-io/sdk';
+
+try {
+  const result = await bugbug.tests.startRun('test-id');
+} catch (error) {
+  if (error instanceof AuthenticationError) {
+    console.error('Invalid API token');
+  } else if (error instanceof RateLimitError) {
+    console.error(`Rate limited. Retry after ${error.retryAfter}ms`);
+  } else if (error instanceof TimeoutError) {
+    console.error(`Request timed out after ${error.timeout}ms`);
+  } else if (error instanceof NetworkError) {
+    console.error('Network error occurred');
+  } else {
+    console.error('Unknown error:', error.message);
+  }
+}
+```
+
+## Request Cancellation
+
+All requests support cancellation using AbortController:
+
+```typescript
+const controller = new AbortController();
+
+// Cancel the request after 5 seconds
+setTimeout(() => controller.abort(), 5000);
+
+try {
+  const result = await bugbug.tests.list({
+    signal: controller.signal,
+  });
+} catch (error) {
+  if (error instanceof CancellationError) {
+    console.log('Request was cancelled');
+  }
+}
+```
+
+## Rate Limiting
+
+The SDK applies rate limiting with exponential backoff automatically, based on the
+`rateLimit` configuration (see [Advanced Configuration](#advanced-configuration)).
+On HTTP 429 responses it backs off and retries up to `maxRetries`, throwing a
+`RateLimitError` once retries are exhausted.
+
+## Client Methods
+
+The top-level client exposes a few helpers alongside the resource modules:
+
+```typescript
+// Read the resolved config (apiToken, apiUrl, etc.)
+const config = bugbug.getConfig();
+
+// Update config at runtime
+bugbug.updateConfig({ apiUrl: 'https://app.bugbug.io/api/v2' });
+
+// Switch the active project (shorthand for updateConfig({ projectId }))
+bugbug.setProject('project-id');
+
+// Probe connectivity to the API
+const connectivity = await bugbug.testConnection();
+```
+
+## TypeScript Support
+
+The SDK is built with TypeScript and provides comprehensive type definitions:
+
+```typescript
+import type { Test, TestRun, Suite, SuiteRun } from '@bugbug-io/sdk';
+
+// All API responses are properly typed
+const test: Test = await bugbug.tests.get('test-id');
+const run: TestRun = await bugbug.tests.startRun(test.id, { watchProgress: true });
+```
+
+## Environment Variables
+
+You can also configure the SDK using environment variables:
+
+```bash
+BUGBUG_API_TOKEN=your-api-token
+BUGBUG_API_URL=https://app.bugbug.io/api/v2
+BUGBUG_VERBOSE=true
+```
+
+```typescript
+import { createBugBug } from '@bugbug-io/sdk';
+
+const bugbug = createBugBug({
+  apiToken: process.env.BUGBUG_API_TOKEN!,
+  apiUrl: process.env.BUGBUG_API_URL,
+  verbose: process.env.BUGBUG_VERBOSE === 'true',
+});
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/dist/constants/sdk-error-codes.d.ts

@@ -0,0 +1,35 @@
+/**
+ * SDK transport-level error codes.
+ *
+ * Each `BugBugError` (and subclass) carries one of these codes in its `code`
+ * field. Distinct from step-execution codes in `step-error-codes.ts`, which
+ * describe runtime failures inside a test/suite run.
+ */
+export declare const SDK_ERROR_CODES: {
+    readonly AUTHENTICATION_ERROR: "AUTHENTICATION_ERROR";
+    readonly AUTHORIZATION_ERROR: "AUTHORIZATION_ERROR";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
+    readonly MISSING_PROJECT_ID_ERROR: "MISSING_PROJECT_ID_ERROR";
+    readonly NOT_FOUND_ERROR: "NOT_FOUND_ERROR";
+    readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
+    readonly TIMEOUT_ERROR: "TIMEOUT_ERROR";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly CANCELLATION_ERROR: "CANCELLATION_ERROR";
+    readonly INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR";
+    readonly SERVICE_UNAVAILABLE: "SERVICE_UNAVAILABLE";
+    readonly UNEXPECTED_RESPONSE: "UNEXPECTED_RESPONSE";
+    readonly HTTP_ERROR: "HTTP_ERROR";
+};
+export type SdkErrorCode = (typeof SDK_ERROR_CODES)[keyof typeof SDK_ERROR_CODES];
+/**
+ * Synthetic HTTP status codes used when no real response is available.
+ *
+ * - `0`   — no request was sent or no response was received (network/DNS/config).
+ * - `408` — RFC 7231 Request Timeout: client-side timeout fired before response.
+ * - `499` — nginx convention for client-cancelled requests.
+ */
+export declare const STATUS_NO_RESPONSE = 0;
+export declare const STATUS_CLIENT_TIMEOUT = 408;
+export declare const STATUS_CLIENT_CANCELLED = 499;
+//# sourceMappingURL=sdk-error-codes.d.ts.map

package/dist/constants/sdk-error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sdk-error-codes.d.ts","sourceRoot":"","sources":["../../src/constants/sdk-error-codes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;CAelB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,OAAO,eAAe,CAAC,CAAC;AAElF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,qBAAqB,MAAM,CAAC;AACzC,eAAO,MAAM,uBAAuB,MAAM,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * BugBug SDK - TypeScript SDK for BugBug API
+ *
+ * @example
+ * ```typescript
+ * import { createBugBug } from '@bugbug-io/sdk';
+ *
+ * const sdk = createBugBug({
+ *   apiToken: 'your-api-token',
+ *   verbose: true
+ * });
+ *
+ * // Run a test
+ * const result = await sdk.tests.startRun('my-test', {
+ *   watchProgress: true,
+ *   onProgress: (run) => console.log(`Status: ${run.status}`)
+ * });
+ *
+ * // Get recent test runs
+ * const recentTests = await sdk.tests.getRecentRuns({ hours: 24 });
+ *
+ * // Run a suite
+ * const suiteResult = await sdk.suites.startRun('suite-id', {
+ *   watchProgress: true
+ * });
+ * ```
+ */
+import type { BugBugConfig } from './types/config';
+import { BugBugSDK } from './sdk';
+/**
+ * Factory function that creates a new {@link BugBugSDK} instance.
+ *
+ * Prefer this over `new BugBugSDK(...)` — it keeps call sites concise and is the
+ * documented entry point for the SDK.
+ *
+ * @param config - SDK configuration (API token, base URL, rate limits, etc.)
+ * @returns A fully initialized SDK instance with all modules ready to use
+ *
+ * @example
+ * ```typescript
+ * import { createBugBug } from '@bugbug-io/sdk';
+ *
+ * const sdk = createBugBug({ apiToken: process.env.BUGBUG_API_TOKEN! });
+ *
+ * const result = await sdk.tests.startRun('my-test', { watchProgress: true });
+ * ```
+ */
+export declare function createBugBug(config: BugBugConfig): BugBugSDK;
+export { BugBugSDK } from './sdk';
+export type { BugBugConfig, RequestOptions, WaitOptions, RequestHook, RequestErrorHook, } from './types/config';
+export type { RateLimitConfig } from './services/rateLimiter/rateLimiter.types';
+export { TestsModule } from './modules/tests/tests';
+export type { ImportTestOptions, ListTestRunsOptions, ListTestsOptions, RunTestBaseOptions, RunTestNoWatchProgressOptions, RunTestWatchProgressOptions, } from './modules/tests/tests.types';
+export { SuitesModule } from './modules/suites/suites';
+export type { ListSuiteRunsOptions, ListSuitesOptions, RunSuiteBaseOptions, RunSuiteNoWatchProgressOptions, RunSuiteWatchProgressOptions, } from './modules/suites/suites.types';
+export { ProfilesModule } from './modules/profiles/profiles';
+export { ConfigModule } from './modules/config/config';
+export { GroupsModule } from './modules/groups/groups';
+export { ComponentsModule } from './modules/components/components';
+export { StepsModule } from './modules/steps/steps';
+export { StepRunsModule } from './modules/stepRuns/stepRuns';
+export { ProjectModule } from './modules/project/project';
+export { ProjectArtifactsModule } from './modules/projectArtifacts/projectArtifacts';
+export type { ProjectArtifact, UploadProjectArtifactOptions, } from './modules/projectArtifacts/projectArtifacts.types';
+export { ProjectsModule } from './modules/projects/projects';
+export type { Project, ProjectsListResponse, ProjectsListQuery, } from './modules/projects/projects.types';
+export { VariablesModule } from './modules/variables/variables';
+export type { CreateVariableOptions, UpdateVariableOptions, } from './modules/variables/variables.types';
+export { VisualRegressionModule } from './modules/visualRegression/visualRegression';
+export { VISUAL_REGRESSION_RESOLUTION_ACTIONS, VISUAL_REGRESSION_RESOLUTION_TYPE_BY_ACTION, } from './modules/visualRegression/visualRegression.constants';
+export type { VisualRegressionResolutionAction } from './modules/visualRegression/visualRegression.constants';
+export type { VisualRegressionResolutionType, VisualRegressionResolveResponse, VisualRegressionResolveResult, } from './modules/visualRegression/visualRegression.types';
+export { AuthModule } from './modules/auth/auth';
+export type { AuthAuthorizeParams, AuthAuthorizeResponse, AuthIdentity, AuthTokenRequest, AuthTokenResponse, } from './modules/auth/auth.types';
+export { BUGBUG_CLI_OAUTH_CLIENT_ID, BUGBUG_MCP_OAUTH_CLIENT_ID, BUGBUG_OAUTH_CODE_CHALLENGE_METHOD, } from './modules/auth/auth.types';
+export { createOAuthCodeChallenge, createOAuthCodeVerifier, createOAuthState, } from './modules/auth/auth.utils';
+export { ASSERTION_STEP_TYPES, VISUAL_REGRESSION_STEP_TYPES, isAssertionStepType, isVisualRegressionStepType, } from './modules/steps/steps.utils';
+export { BugBugError, AuthenticationError, AuthorizationError, ValidationError, ConfigurationError, MissingProjectIdError, NotFoundError, RateLimitError, TimeoutError, NetworkError, CancellationError, InternalServerError, ServiceUnavailableError, UnexpectedResponseError, HttpError, isBugBugError, isAuthenticationError, isAuthorizationError, isValidationError, isConfigurationError, isMissingProjectIdError, isNotFoundError, isRateLimitError, isTimeoutError, isNetworkError, isCancellationError, isInternalServerError, isServiceUnavailableError, isUnexpectedResponseError, isHttpError, } from './types/errors';
+export type { RequestOrigin } from './types/errors';
+export { SDK_ERROR_CODES } from './constants/sdk-error-codes';
+export type { SdkErrorCode } from './constants/sdk-error-codes';
+export type { ComponentsListQuery, ComponentsListResponse, DebugArtifact, DebugArtifactByType, DebugArtifactType, DebugArtifactsListResponse, Group, GroupCreateRequest, GroupPartialUpdateRequest, GroupUpdateRequest, GroupsListQuery, GroupsListResponse, ImportFormat, InsertGroup, InsertGroupResponse, IpAddressesResponse, Profile, ProfilesListQuery, ProfilesListResponse, ProjectSettings, RunMode, RunSuiteRequest, RunSuiteResponse, RunTestRequest, RunTestResponse, Screenshot, Selector, SelectorsGroup, SelectorsPreset, ScreenSizeType, Status, StepCreateRequest, StepDetails, StepPatchRequest, StepRunDetails, StepSource, StepType, StepUpdateRequest, Suite, SuiteCreateRequest, SuitePartialUpdateRequest, SuiteRun, SuiteRunScreenshotsResponse, SuiteRunsListQuery, SuiteRunState, SuiteRunsListResponse, SuiteSummary, SuiteUpdateRequest, SuitesListQuery, SuitesListResponse, Test, TestCreateRequest, TestRun, TestRunScreenshotsResponse, TestRunsListQuery, TestRunState, TestRunsListResponse, TestSummary, TestUpdateRequest, TestsListQuery, TestsListResponse, UnlinkComponentRequest, UnlinkComponentResponse, UpdateStepPositionRequest, UpdateStepPositionResponse, UpdateStepWaitingCondition, Variable, CreatedVariable, CreateVariableRequest, UpdateVariableRequest, VariablesListResponse, VisualRegressionRefScreenshot, VisualRegressionRefScreenshotCreate, VisualRegressionRefScreenshotPatch, VisualRegressionResolveRequest, VisualRegressionRefScreenshotsListQuery, VisualRegressionRefScreenshotUpdate, VisualRegressionRefScreenshotsListResponse, StepErrorCode, } from '@bugbug-io/api-schema';
+export { CursorSchema, DebugArtifactByTypeSchema, PageSizeSchema, RUN_MODES, RunModeSchema, SelectorsPresetSchema, ScreenSizeTypeSchema, StatusSchema, StepCreateSchema, StepErrorCodeSchema, StepSchema, StepTypeSchema, StepUpdateSchema, UuidSchema, } from '@bugbug-io/api-schema/schemas';
+export { STEP_ERROR_CODES } from '@bugbug-io/api-schema';
+export type { ConnectivityStatus, SdkSystemInfo } from './types/sdk';
+export { isCompletedStatus, isEditingStatus, isFailedStatus, isPassedStatus, isRunningStatus, } from './types/sdk';
+//# sourceMappingURL=index.d.ts.map