@wave-av/sdk 2.0.1 → 2.0.2

package/dist/pulse.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/pulse.ts
+var pulse_exports = {};
+__export(pulse_exports, {
+  PulseAPI: () => PulseAPI,
+  createPulseAPI: () => createPulseAPI
+});
+module.exports = __toCommonJS(pulse_exports);
+var PulseAPI = class {
+  client;
+  basePath = "/v1/analytics";
+  constructor(client) {
+    this.client = client;
+  }
+  async getStreamAnalytics(streamId, params) {
+    return this.client.get(`${this.basePath}/streams/${streamId}`, {
+      params
+    });
+  }
+  async getViewerAnalytics(params) {
+    return this.client.get(`${this.basePath}/viewers`, {
+      params
+    });
+  }
+  async getQualityMetrics(params) {
+    return this.client.get(`${this.basePath}/quality`, {
+      params
+    });
+  }
+  async getEngagementMetrics(params) {
+    return this.client.get(`${this.basePath}/engagement`, {
+      params
+    });
+  }
+  async getRevenueMetrics(params) {
+    return this.client.get(`${this.basePath}/revenue`, {
+      params
+    });
+  }
+  async getTimeSeries(metric, params) {
+    return this.client.get(`${this.basePath}/timeseries/${metric}`, {
+      params
+    });
+  }
+  async createReport(request) {
+    return this.client.post(`${this.basePath}/reports`, request);
+  }
+  async getReport(reportId) {
+    return this.client.get(`${this.basePath}/reports/${reportId}`);
+  }
+  async listReports(params) {
+    return this.client.get(`${this.basePath}/reports`, {
+      params
+    });
+  }
+  async listDashboards(params) {
+    return this.client.get(`${this.basePath}/dashboards`, {
+      params
+    });
+  }
+  async createDashboard(request) {
+    return this.client.post(`${this.basePath}/dashboards`, request);
+  }
+  async getDashboard(dashboardId) {
+    return this.client.get(`${this.basePath}/dashboards/${dashboardId}`);
+  }
+  async updateDashboard(dashboardId, updates) {
+    return this.client.patch(`${this.basePath}/dashboards/${dashboardId}`, updates);
+  }
+  async removeDashboard(dashboardId) {
+    await this.client.delete(`${this.basePath}/dashboards/${dashboardId}`);
+  }
+};
+function createPulseAPI(client) {
+  return new PulseAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PulseAPI,
+  createPulseAPI
+});

package/dist/pulse.mjs

@@ -0,0 +1,9 @@
+import {
+  PulseAPI,
+  createPulseAPI
+} from "./chunk-XGAYMWRH.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  PulseAPI,
+  createPulseAPI
+};

package/dist/qr.js

@@ -0,0 +1,71 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/qr.ts
+var qr_exports = {};
+__export(qr_exports, {
+  QrAPI: () => QrAPI,
+  createQrAPI: () => createQrAPI
+});
+module.exports = __toCommonJS(qr_exports);
+var QrAPI = class {
+  client;
+  basePath = "/v1/qr";
+  constructor(client) {
+    this.client = client;
+  }
+  async create(request) {
+    return this.client.post(this.basePath, request);
+  }
+  async get(qrId) {
+    return this.client.get(`${this.basePath}/${qrId}`);
+  }
+  async update(qrId, updates) {
+    return this.client.patch(`${this.basePath}/${qrId}`, updates);
+  }
+  async remove(qrId) {
+    await this.client.delete(`${this.basePath}/${qrId}`);
+  }
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  async getAnalytics(qrId, params) {
+    return this.client.get(`${this.basePath}/${qrId}/analytics`, {
+      params
+    });
+  }
+  async createBatch(items) {
+    return this.client.post(`${this.basePath}/batch`, { items });
+  }
+  async getImage(qrId, format, size) {
+    return this.client.get(`${this.basePath}/${qrId}/image`, {
+      params: { format, size }
+    });
+  }
+};
+function createQrAPI(client) {
+  return new QrAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  QrAPI,
+  createQrAPI
+});

package/dist/qr.mjs

@@ -0,0 +1,9 @@
+import {
+  QrAPI,
+  createQrAPI
+} from "./chunk-362MRITF.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  QrAPI,
+  createQrAPI
+};

package/dist/replay.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/replay.ts
+var replay_exports = {};
+__export(replay_exports, {
+  ReplayAPI: () => ReplayAPI,
+  createReplayAPI: () => createReplayAPI
+});
+module.exports = __toCommonJS(replay_exports);
+var ReplayAPI = class {
+  client;
+  basePath = "/v1/replay";
+  constructor(client) {
+    this.client = client;
+  }
+  async createSession(switcherId) {
+    return this.client.post(this.basePath, { switcherId });
+  }
+  async getSession(sessionId) {
+    return this.client.get(`${this.basePath}/${sessionId}`);
+  }
+  async markPOI(sessionId, label) {
+    return this.client.post(`${this.basePath}/${sessionId}/poi`, { label });
+  }
+  async listPOIs(sessionId) {
+    return this.client.get(`${this.basePath}/${sessionId}/poi`);
+  }
+  async exportClip(sessionId, options) {
+    return this.client.post(`${this.basePath}/${sessionId}/clips`, options);
+  }
+  async getClip(sessionId, clipId) {
+    return this.client.get(`${this.basePath}/${sessionId}/clips/${clipId}`);
+  }
+  async listClips(sessionId) {
+    return this.client.get(`${this.basePath}/${sessionId}/clips`);
+  }
+};
+function createReplayAPI(client) {
+  return new ReplayAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReplayAPI,
+  createReplayAPI
+});

package/dist/replay.mjs

@@ -0,0 +1,38 @@
+import "./chunk-Y6FXYEAI.mjs";
+
+// src/replay.ts
+var ReplayAPI = class {
+  client;
+  basePath = "/v1/replay";
+  constructor(client) {
+    this.client = client;
+  }
+  async createSession(switcherId) {
+    return this.client.post(this.basePath, { switcherId });
+  }
+  async getSession(sessionId) {
+    return this.client.get(`${this.basePath}/${sessionId}`);
+  }
+  async markPOI(sessionId, label) {
+    return this.client.post(`${this.basePath}/${sessionId}/poi`, { label });
+  }
+  async listPOIs(sessionId) {
+    return this.client.get(`${this.basePath}/${sessionId}/poi`);
+  }
+  async exportClip(sessionId, options) {
+    return this.client.post(`${this.basePath}/${sessionId}/clips`, options);
+  }
+  async getClip(sessionId, clipId) {
+    return this.client.get(`${this.basePath}/${sessionId}/clips/${clipId}`);
+  }
+  async listClips(sessionId) {
+    return this.client.get(`${this.basePath}/${sessionId}/clips`);
+  }
+};
+function createReplayAPI(client) {
+  return new ReplayAPI(client);
+}
+export {
+  ReplayAPI,
+  createReplayAPI
+};

package/dist/scene-types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scene-types.ts
+var scene_types_exports = {};
+module.exports = __toCommonJS(scene_types_exports);

package/dist/scene-types.mjs

@@ -0,0 +1 @@
+import "./chunk-IL2SGWBC.mjs";

package/dist/scene.js

@@ -0,0 +1,271 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scene.ts
+var scene_exports = {};
+__export(scene_exports, {
+  SceneAPI: () => SceneAPI,
+  createSceneAPI: () => createSceneAPI
+});
+module.exports = __toCommonJS(scene_exports);
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SceneAPI,
+  createSceneAPI
+});

package/dist/scene.mjs

@@ -0,0 +1,10 @@
+import {
+  SceneAPI,
+  createSceneAPI
+} from "./chunk-IGDBED5P.mjs";
+import "./chunk-IL2SGWBC.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  SceneAPI,
+  createSceneAPI
+};

package/dist/search-types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/search-types.ts
+var search_types_exports = {};
+module.exports = __toCommonJS(search_types_exports);

package/dist/search-types.mjs

@@ -0,0 +1 @@
+import "./chunk-ZJO7AP4Q.mjs";