@wave-av/sdk 2.0.1 → 2.0.3

package/dist/chunk-H2YYTNUH.mjs

@@ -0,0 +1,266 @@
+import {
+  initTelemetry
+} from "./chunk-YEK26SSO.mjs";
+
+// src/client.ts
+import { EventEmitter } from "eventemitter3";
+var WaveError = class extends Error {
+  code;
+  statusCode;
+  requestId;
+  details;
+  retryable;
+  constructor(message, code, statusCode, requestId, details) {
+    super(message);
+    this.name = "WaveError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.details = details;
+    this.retryable = this.isRetryable(statusCode, code);
+  }
+};
+var RateLimitError = class extends WaveError {
+  retryAfter;
+  constructor(message, retryAfter, requestId) {
+    super(message, "RATE_LIMITED", 429, requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var WaveClient = class extends EventEmitter {
+  config;
+  constructor(config) {
+    super();
+    if (!config.apiKey) {
+      throw new Error("WAVE SDK: apiKey is required");
+    }
+    this.config = {
+      apiKey: config.apiKey,
+      organizationId: config.organizationId || "",
+      baseUrl: config.baseUrl || "https://api.wave.online",
+      timeout: config.timeout || 3e4,
+      maxRetries: config.maxRetries ?? 3,
+      debug: config.debug || false,
+      customHeaders: config.customHeaders || {},
+      telemetry: config.telemetry
+    };
+    if (config.telemetry) {
+      initTelemetry(config.telemetry);
+    }
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path, options) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  /**
+   * Make a POST request
+   */
+  async post(path, body, options) {
+    return this.request(path, {
+      ...options,
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * Make a PUT request
+   */
+  async put(path, body, options) {
+    return this.request(path, {
+      ...options,
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * Make a PATCH request
+   */
+  async patch(path, body, options) {
+    return this.request(path, {
+      ...options,
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(path, options) {
+    return this.request(path, { ...options, method: "DELETE" });
+  }
+  /**
+   * Make an API request with retry logic
+   */
+  async request(path, options = {}) {
+    const { params, noRetry, timeout: requestTimeout, ...fetchOptions } = options;
+    let url = `${this.config.baseUrl}${path}`;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== void 0) {
+          searchParams.set(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        url += `?${queryString}`;
+      }
+    }
+    return this.executeWithRetry(
+      url,
+      {
+        ...fetchOptions,
+        headers: this.buildHeaders(fetchOptions.headers)
+      },
+      noRetry ? 0 : this.config.maxRetries,
+      requestTimeout || this.config.timeout
+    );
+  }
+  /**
+   * Execute request with exponential backoff retry
+   */
+  async executeWithRetry(url, options, maxRetries, timeout) {
+    const method = options.method || "GET";
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        this.emit("request.start", url, method);
+        const startTime = Date.now();
+        const response = await this.fetchWithTimeout(url, options, timeout);
+        const duration = Date.now() - startTime;
+        if (response.status === 429) {
+          const retryAfter = this.parseRetryAfter(response);
+          this.emit("rate_limit.hit", retryAfter);
+          if (attempt < maxRetries) {
+            this.emit("request.retry", url, method, attempt + 1, retryAfter);
+            await this.sleep(retryAfter);
+            continue;
+          }
+          throw new RateLimitError(
+            "Rate limit exceeded",
+            retryAfter,
+            response.headers.get("x-request-id") || void 0
+          );
+        }
+        if (!response.ok) {
+          const error = await this.parseErrorResponse(response);
+          if (error.retryable && attempt < maxRetries) {
+            const delay = this.calculateBackoff(attempt);
+            this.emit("request.retry", url, method, attempt + 1, delay);
+            await this.sleep(delay);
+            continue;
+          }
+          throw error;
+        }
+        this.emit("request.success", url, method, duration);
+        const contentType = response.headers.get("content-type");
+        if (contentType?.includes("application/json")) {
+          return response.json();
+        }
+        return {};
+      } catch (error) {
+        lastError = error;
+        if (error instanceof WaveError && !error.retryable) {
+          throw error;
+        }
+        if (error instanceof TypeError || error instanceof Error && error.name === "AbortError") {
+          if (attempt < maxRetries) {
+            const delay = this.calculateBackoff(attempt);
+            this.emit("request.retry", url, method, attempt + 1, delay);
+            await this.sleep(delay);
+            continue;
+          }
+        }
+        this.emit("request.error", url, method, error);
+      }
+    }
+    throw lastError || new WaveError("Request failed after retries", "UNKNOWN_ERROR", 0);
+  }
+  /**
+   * Fetch with timeout
+   */
+  async fetchWithTimeout(url, options, timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      return response;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Build request headers
+   */
+  buildHeaders(additionalHeaders) {
+    const headers = {
+      "Authorization": `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json",
+      "Accept": "application/json",
+      "User-Agent": `wave-sdk-typescript/1.0.0`,
+      ...this.config.customHeaders
+    };
+    if (this.config.organizationId) {
+      headers["X-Organization-Id"] = this.config.organizationId;
+    }
+    if (additionalHeaders) {
+      if (additionalHeaders instanceof Headers) {
+        additionalHeaders.forEach((value, key) => {
+          headers[key] = value;
+        });
+      } else if (Array.isArray(additionalHeaders)) {
+        additionalHeaders.forEach(([key, value]) => {
+          headers[key] = value;
+        });
+      } else {
+        Object.assign(headers, additionalHeaders);
+      }
+    }
+    return headers;
+  }
+  /**
+   * Parse error response
+   */
+  /**
+   * Parse Retry-After header
+   */
+  /**
+   * Calculate exponential backoff delay
+   */
+  calculateBackoff(attempt) {
+    const baseDelay = 1e3;
+    const maxDelay = 3e4;
+    const delay = Math.min(baseDelay * Math.pow(2, attempt), maxDelay);
+    return delay + Math.random() * delay * 0.25;
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Log debug message
+   */
+  log(message, ...args) {
+    if (this.config.debug) {
+      console.log(`[WaveSDK] ${message}`, ...args);
+    }
+  }
+};
+function createClient(config) {
+  return new WaveClient(config);
+}
+
+export {
+  WaveError,
+  RateLimitError,
+  WaveClient,
+  createClient
+};

package/dist/chunk-IGDBED5P.mjs

@@ -0,0 +1,246 @@
+// src/scene.ts
+var SceneAPI = class {
+  client;
+  basePath = "/v1/scene";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Start scene detection
+   *
+   * Requires: scene:detect permission
+   */
+  async detect(request) {
+    return this.client.post(`${this.basePath}/detect`, request);
+  }
+  /**
+   * Get scene detection job
+   *
+   * Requires: scene:read permission
+   */
+  async getDetection(detectionId) {
+    return this.client.get(`${this.basePath}/${detectionId}`);
+  }
+  /**
+   * Remove scene detection
+   *
+   * Requires: scene:remove permission (server-side RBAC enforced)
+   */
+  async removeDetection(detectionId) {
+    await this.client.delete(
+      `${this.basePath}/${detectionId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * List scene detections
+   *
+   * Requires: scene:read permission
+   */
+  async listDetections(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  /**
+   * Get scenes for a detection
+   *
+   * Requires: scene:read permission
+   */
+  async getScenes(detectionId, params) {
+    return this.client.get(
+      `${this.basePath}/${detectionId}/scenes`,
+      { params }
+    );
+  }
+  /**
+   * Get a specific scene
+   *
+   * Requires: scene:read permission
+   */
+  async getScene(detectionId, sceneId) {
+    return this.client.get(
+      `${this.basePath}/${detectionId}/scenes/${sceneId}`
+    );
+  }
+  /**
+   * Update scene metadata
+   *
+   * Requires: scene:update permission
+   */
+  async updateScene(detectionId, sceneId, updates) {
+    return this.client.patch(
+      `${this.basePath}/${detectionId}/scenes/${sceneId}`,
+      updates
+    );
+  }
+  /**
+   * Get scene at a specific timestamp
+   *
+   * Requires: scene:read permission
+   */
+  async getSceneAtTime(detectionId, timestamp) {
+    try {
+      return await this.client.get(
+        `${this.basePath}/${detectionId}/scenes/at`,
+        { params: { timestamp } }
+      );
+    } catch (error) {
+      if (error.statusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Get scene boundaries (transitions)
+   *
+   * Requires: scene:read permission
+   */
+  async getBoundaries(detectionId, params) {
+    return this.client.get(
+      `${this.basePath}/${detectionId}/boundaries`,
+      { params }
+    );
+  }
+  /**
+   * Detect scene boundaries only (without full analysis)
+   *
+   * Requires: scene:detect permission
+   */
+  async detectBoundaries(mediaId, mediaType, options) {
+    return this.client.post(`${this.basePath}/boundaries`, {
+      media_id: mediaId,
+      media_type: mediaType,
+      ...options
+    });
+  }
+  /**
+   * Get shots for a scene
+   *
+   * Requires: scene:read permission
+   */
+  async getShots(detectionId, sceneId, params) {
+    return this.client.get(
+      `${this.basePath}/${detectionId}/scenes/${sceneId}/shots`,
+      { params }
+    );
+  }
+  /**
+   * Get all shots for a detection
+   *
+   * Requires: scene:read permission
+   */
+  async getAllShots(detectionId, params) {
+    return this.client.get(`${this.basePath}/${detectionId}/shots`, { params });
+  }
+  /**
+   * Get scene summary/statistics
+   *
+   * Requires: scene:read permission
+   */
+  async getSummary(detectionId) {
+    return this.client.get(`${this.basePath}/${detectionId}/summary`);
+  }
+  /**
+   * Get visual timeline
+   *
+   * Requires: scene:read permission
+   */
+  async getTimeline(detectionId, options) {
+    return this.client.get(`${this.basePath}/${detectionId}/timeline`, {
+      params: options
+    });
+  }
+  /**
+   * Compare scenes between detections
+   *
+   * Requires: scene:read permission
+   */
+  async compareScenes(sourceDetectionId, targetDetectionId, options) {
+    return this.client.post(`${this.basePath}/compare`, {
+      source_detection_id: sourceDetectionId,
+      target_detection_id: targetDetectionId,
+      ...options
+    });
+  }
+  /**
+   * Find similar scenes across all content
+   *
+   * Requires: scene:read permission
+   */
+  async findSimilarScenes(detectionId, sceneId, options) {
+    return this.client.get(`${this.basePath}/${detectionId}/scenes/${sceneId}/similar`, {
+      params: options
+    });
+  }
+  /**
+   * Export scene data
+   *
+   * Requires: scene:read permission
+   */
+  async exportDetection(detectionId, format) {
+    return this.client.post(`${this.basePath}/${detectionId}/export`, { format });
+  }
+  /**
+   * Generate scene thumbnails
+   *
+   * Requires: scene:update permission
+   */
+  async generateThumbnails(detectionId, options) {
+    return this.client.post(`${this.basePath}/${detectionId}/thumbnails`, options);
+  }
+  /**
+   * Wait for scene detection to complete
+   */
+  async waitForReady(detectionId, options) {
+    const pollInterval = options?.pollInterval || 3e3;
+    const timeout = options?.timeout || 18e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const detection = await this.getDetection(detectionId);
+      if (options?.onProgress) {
+        options.onProgress(detection);
+      }
+      if (detection.status === "ready") {
+        return detection;
+      }
+      if (detection.status === "failed") {
+        throw new Error(
+          `Scene detection failed: ${detection.error || "Unknown error"}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Scene detection timed out after ${timeout}ms`);
+  }
+  /**
+   * Merge scenes
+   *
+   * Requires: scene:update permission
+   */
+  async mergeScenes(detectionId, sceneIds, options) {
+    return this.client.post(
+      `${this.basePath}/${detectionId}/scenes/merge`,
+      { scene_ids: sceneIds, ...options }
+    );
+  }
+  /**
+   * Split scene at timestamp
+   *
+   * Requires: scene:update permission
+   */
+  async splitScene(detectionId, sceneId, splitTime) {
+    return this.client.post(`${this.basePath}/${detectionId}/scenes/${sceneId}/split`, {
+      split_time: splitTime
+    });
+  }
+};
+function createSceneAPI(client) {
+  return new SceneAPI(client);
+}
+
+export {
+  SceneAPI,
+  createSceneAPI
+};

package/dist/chunk-IVFZ5X4W.mjs

@@ -0,0 +1,68 @@
+// src/signage.ts
+var SignageAPI = class {
+  client;
+  basePath = "/v1/signage";
+  constructor(client) {
+    this.client = client;
+  }
+  async listDisplays(params) {
+    return this.client.get(`${this.basePath}/displays`, {
+      params
+    });
+  }
+  async getDisplay(displayId) {
+    return this.client.get(`${this.basePath}/displays/${displayId}`);
+  }
+  async registerDisplay(request) {
+    return this.client.post(`${this.basePath}/displays`, request);
+  }
+  async updateDisplay(displayId, updates) {
+    return this.client.patch(`${this.basePath}/displays/${displayId}`, updates);
+  }
+  async removeDisplay(displayId) {
+    await this.client.delete(`${this.basePath}/displays/${displayId}`);
+  }
+  async createPlaylist(request) {
+    return this.client.post(`${this.basePath}/playlists`, request);
+  }
+  async updatePlaylist(playlistId, updates) {
+    return this.client.patch(`${this.basePath}/playlists/${playlistId}`, updates);
+  }
+  async removePlaylist(playlistId) {
+    await this.client.delete(`${this.basePath}/playlists/${playlistId}`);
+  }
+  async listPlaylists(params) {
+    return this.client.get(`${this.basePath}/playlists`, {
+      params
+    });
+  }
+  async assignPlaylist(displayId, playlistId) {
+    await this.client.post(`${this.basePath}/displays/${displayId}/playlist`, {
+      playlist_id: playlistId
+    });
+  }
+  async scheduleContent(request) {
+    return this.client.post(`${this.basePath}/schedules`, request);
+  }
+  async listSchedules(displayId) {
+    const path = displayId ? `${this.basePath}/displays/${displayId}/schedules` : `${this.basePath}/schedules`;
+    return this.client.get(path);
+  }
+  async removeSchedule(scheduleId) {
+    await this.client.delete(`${this.basePath}/schedules/${scheduleId}`);
+  }
+  async configureDisplay(displayId, config) {
+    return this.client.patch(
+      `${this.basePath}/displays/${displayId}/config`,
+      config
+    );
+  }
+};
+function createSignageAPI(client) {
+  return new SignageAPI(client);
+}
+
+export {
+  SignageAPI,
+  createSignageAPI
+};

package/dist/chunk-JC32PG3T.mjs

@@ -0,0 +1,114 @@
+// src/ghost.ts
+var GhostAPI = class {
+  client;
+  basePath = "/v1/productions";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Start an Autopilot directing session
+   *
+   * Requires: ghost:create permission
+   */
+  async start(request) {
+    return this.client.post(
+      `${this.basePath}/${request.production_id}/ghost`,
+      request
+    );
+  }
+  /**
+   * Get the current Autopilot session for a production
+   *
+   * Requires: ghost:read permission
+   */
+  async get(productionId) {
+    return this.client.get(`${this.basePath}/${productionId}/ghost`);
+  }
+  /**
+   * Update an Autopilot session
+   *
+   * Requires: ghost:update permission
+   */
+  async update(productionId, request) {
+    return this.client.patch(`${this.basePath}/${productionId}/ghost`, request);
+  }
+  /**
+   * Stop an Autopilot session
+   *
+   * Requires: ghost:stop permission
+   */
+  async stop(productionId) {
+    return this.client.post(`${this.basePath}/${productionId}/ghost/stop`);
+  }
+  /**
+   * Pause an Autopilot session
+   *
+   * Requires: ghost:update permission
+   */
+  async pause(productionId) {
+    return this.client.post(`${this.basePath}/${productionId}/ghost/pause`);
+  }
+  /**
+   * Resume a paused Autopilot session
+   *
+   * Requires: ghost:update permission
+   */
+  async resume(productionId) {
+    return this.client.post(`${this.basePath}/${productionId}/ghost/resume`);
+  }
+  /**
+   * Override the current shot with a manual selection
+   *
+   * Requires: ghost:override permission
+   */
+  async override(productionId, override) {
+    await this.client.post(`${this.basePath}/${productionId}/ghost/override`, override);
+  }
+  /**
+   * List AI suggestions for a production's Autopilot session
+   *
+   * Requires: ghost:read permission
+   */
+  async listSuggestions(productionId, params) {
+    return this.client.get(
+      `${this.basePath}/${productionId}/ghost/suggestions`,
+      { params }
+    );
+  }
+  /**
+   * Accept an AI suggestion
+   *
+   * Requires: ghost:update permission
+   */
+  async acceptSuggestion(productionId, suggestionId) {
+    return this.client.post(
+      `${this.basePath}/${productionId}/ghost/suggestions/${suggestionId}/accept`
+    );
+  }
+  /**
+   * Reject an AI suggestion
+   *
+   * Requires: ghost:update permission
+   */
+  async rejectSuggestion(productionId, suggestionId) {
+    return this.client.post(
+      `${this.basePath}/${productionId}/ghost/suggestions/${suggestionId}/reject`
+    );
+  }
+  /**
+   * Get directing statistics for a production's Autopilot session
+   *
+   * Requires: ghost:read permission
+   */
+  async getStats(productionId) {
+    return this.client.get(`${this.basePath}/${productionId}/ghost/stats`);
+  }
+};
+function createGhostAPI(client) {
+  return new GhostAPI(client);
+}
+
+export {
+  GhostAPI,
+  createGhostAPI
+};