@wave-av/sdk 2.0.1 → 2.0.2

package/dist/search.js

@@ -0,0 +1,268 @@
+"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/search.ts
+var search_exports = {};
+__export(search_exports, {
+  SearchAPI: () => SearchAPI,
+  createSearchAPI: () => createSearchAPI
+});
+module.exports = __toCommonJS(search_exports);
+var SearchAPI = class {
+  client;
+  basePath = "/v1/search";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Search content
+   *
+   * Requires: search:query permission
+   */
+  async search(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Quick search (simplified API)
+   *
+   * Requires: search:query permission
+   */
+  async quickSearch(query, options) {
+    const response = await this.search({
+      query,
+      mode: "semantic",
+      types: options?.types,
+      filters: options?.filters,
+      limit: options?.limit || 10
+    });
+    return response.results;
+  }
+  /**
+   * Search within a specific media
+   *
+   * Requires: search:query permission
+   */
+  async searchInMedia(mediaId, mediaType, query, options) {
+    return this.client.post(`${this.basePath}/media`, {
+      media_id: mediaId,
+      media_type: mediaType,
+      query,
+      ...options
+    });
+  }
+  /**
+   * Visual search (search by image)
+   *
+   * Requires: search:visual permission
+   */
+  async visualSearch(request) {
+    return this.client.post(`${this.basePath}/visual`, request);
+  }
+  /**
+   * Find similar frames
+   *
+   * Requires: search:visual permission
+   */
+  async findSimilarFrames(mediaId, timestamp, options) {
+    return this.client.post(`${this.basePath}/visual/similar`, {
+      media_id: mediaId,
+      timestamp,
+      ...options
+    });
+  }
+  /**
+   * Detect objects in media
+   *
+   * Requires: search:visual permission
+   */
+  async detectObjects(mediaId, options) {
+    return this.client.post(`${this.basePath}/visual/objects`, {
+      media_id: mediaId,
+      ...options
+    });
+  }
+  /**
+   * Audio search (search by audio)
+   *
+   * Requires: search:audio permission
+   */
+  async audioSearch(request) {
+    return this.client.post(`${this.basePath}/audio`, request);
+  }
+  /**
+   * Find similar audio segments
+   *
+   * Requires: search:audio permission
+   */
+  async findSimilarAudio(mediaId, startTime, endTime, options) {
+    return this.client.post(`${this.basePath}/audio/similar`, {
+      media_id: mediaId,
+      start_time: startTime,
+      end_time: endTime,
+      ...options
+    });
+  }
+  /**
+   * Detect music in media
+   *
+   * Requires: search:audio permission
+   */
+  async detectMusic(mediaId) {
+    return this.client.get(`${this.basePath}/audio/music/${mediaId}`);
+  }
+  /**
+   * Get search suggestions
+   *
+   * Requires: search:query permission
+   */
+  async getSuggestions(prefix, options) {
+    return this.client.get(`${this.basePath}/suggest`, {
+      params: { prefix, ...options }
+    });
+  }
+  /**
+   * Get trending searches
+   *
+   * Requires: search:query permission
+   */
+  async getTrending(options) {
+    return this.client.get(`${this.basePath}/trending`, { params: options });
+  }
+  /**
+   * Index media for search
+   *
+   * Requires: search:index permission
+   */
+  async indexMedia(mediaId, mediaType, options) {
+    return this.client.post(`${this.basePath}/index`, {
+      media_id: mediaId,
+      media_type: mediaType,
+      ...options
+    });
+  }
+  /**
+   * Get index status
+   *
+   * Requires: search:read permission
+   */
+  async getIndexStatus(mediaId) {
+    return this.client.get(`${this.basePath}/index/${mediaId}`);
+  }
+  /**
+   * Reindex media
+   *
+   * Requires: search:index permission
+   */
+  async reindexMedia(mediaId, options) {
+    return this.client.post(
+      `${this.basePath}/index/${mediaId}/reindex`,
+      options
+    );
+  }
+  /**
+   * Remove media from index
+   *
+   * Requires: search:index permission (server-side RBAC enforced)
+   */
+  async removeFromIndex(mediaId) {
+    await this.client.delete(
+      `${this.basePath}/index/${mediaId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Save a search
+   *
+   * Requires: search:save permission
+   */
+  async saveSearch(name, request, options) {
+    return this.client.post(`${this.basePath}/saved`, {
+      name,
+      query: request,
+      ...options
+    });
+  }
+  /**
+   * List saved searches
+   *
+   * Requires: search:read permission
+   */
+  async listSavedSearches(params) {
+    return this.client.get(`${this.basePath}/saved`, { params });
+  }
+  /**
+   * Run a saved search
+   *
+   * Requires: search:query permission
+   */
+  async runSavedSearch(savedSearchId) {
+    return this.client.post(
+      `${this.basePath}/saved/${savedSearchId}/run`
+    );
+  }
+  /**
+   * Remove a saved search
+   *
+   * Requires: search:save permission (server-side RBAC enforced)
+   */
+  async removeSavedSearch(savedSearchId) {
+    await this.client.delete(
+      `${this.basePath}/saved/${savedSearchId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Get search analytics
+   *
+   * Requires: search:analytics permission
+   */
+  async getAnalytics(options) {
+    return this.client.get(`${this.basePath}/analytics`, { params: options });
+  }
+  /**
+   * Wait for indexing to complete
+   */
+  async waitForIndex(mediaId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 6e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const status = await this.getIndexStatus(mediaId);
+      if (options?.onProgress) {
+        options.onProgress(status);
+      }
+      if (status.status === "ready") {
+        return status;
+      }
+      if (status.status === "failed") {
+        throw new Error(`Indexing failed: ${status.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Indexing timed out after ${timeout}ms`);
+  }
+};
+function createSearchAPI(client) {
+  return new SearchAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SearchAPI,
+  createSearchAPI
+});

package/dist/search.mjs

@@ -0,0 +1,10 @@
+import {
+  SearchAPI,
+  createSearchAPI
+} from "./chunk-A344OOT7.mjs";
+import "./chunk-ZJO7AP4Q.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  SearchAPI,
+  createSearchAPI
+};

package/dist/sentiment-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/sentiment-types.ts
+var sentiment_types_exports = {};
+module.exports = __toCommonJS(sentiment_types_exports);

package/dist/sentiment.js

@@ -0,0 +1,235 @@
+"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/sentiment.ts
+var sentiment_exports = {};
+__export(sentiment_exports, {
+  SentimentAPI: () => SentimentAPI,
+  createSentimentAPI: () => createSentimentAPI
+});
+module.exports = __toCommonJS(sentiment_exports);
+var SentimentAPI = class {
+  client;
+  basePath = "/v1/sentiment";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a sentiment analysis job
+   *
+   * Requires: sentiment:analyze permission
+   */
+  async analyze(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Analyze text directly (synchronous for short text)
+   *
+   * Requires: sentiment:analyze permission
+   */
+  async analyzeText(text, options) {
+    return this.client.post(`${this.basePath}/text`, { text, ...options });
+  }
+  /**
+   * Batch analyze multiple items
+   *
+   * Requires: sentiment:analyze permission
+   */
+  async batchAnalyze(request) {
+    return this.client.post(`${this.basePath}/batch`, request);
+  }
+  /**
+   * Get an analysis by ID
+   *
+   * Requires: sentiment:read permission
+   */
+  async get(analysisId) {
+    return this.client.get(`${this.basePath}/${analysisId}`);
+  }
+  /**
+   * Remove an analysis
+   *
+   * Requires: sentiment:remove permission (server-side RBAC enforced)
+   */
+  async remove(analysisId) {
+    await this.client.delete(
+      `${this.basePath}/${analysisId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * List analyses
+   *
+   * Requires: sentiment:read permission
+   */
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  /**
+   * Get sentiment segments
+   *
+   * Requires: sentiment:read permission
+   */
+  async getSegments(analysisId, params) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/segments`,
+      { params }
+    );
+  }
+  /**
+   * Get sentiment summary
+   *
+   * Requires: sentiment:read permission
+   */
+  async getSummary(analysisId) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/summary`
+    );
+  }
+  /**
+   * Get sentiment trend over time
+   *
+   * Requires: sentiment:read permission
+   */
+  async getTrend(analysisId, options) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/trend`,
+      { params: options }
+    );
+  }
+  /**
+   * Get key emotional moments
+   *
+   * Requires: sentiment:read permission
+   */
+  async getKeyMoments(analysisId, options) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/key-moments`,
+      { params: options }
+    );
+  }
+  /**
+   * Get topic sentiments
+   *
+   * Requires: sentiment:read permission
+   */
+  async getTopicSentiments(analysisId, options) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/topics`,
+      { params: options }
+    );
+  }
+  /**
+   * Get sentiment by speaker
+   *
+   * Requires: sentiment:read permission
+   */
+  async getSpeakerSentiment(analysisId) {
+    return this.client.get(`${this.basePath}/${analysisId}/speakers`);
+  }
+  /**
+   * Start real-time sentiment analysis
+   *
+   * Requires: sentiment:realtime permission
+   */
+  async startRealtime(streamId, options) {
+    return this.client.post(`${this.basePath}/realtime/start`, {
+      stream_id: streamId,
+      ...options
+    });
+  }
+  /**
+   * Stop real-time analysis
+   *
+   * Requires: sentiment:realtime permission
+   */
+  async stopRealtime(sessionId) {
+    return this.client.post(
+      `${this.basePath}/realtime/${sessionId}/stop`
+    );
+  }
+  /**
+   * Get real-time session status
+   *
+   * Requires: sentiment:read permission
+   */
+  async getRealtimeStatus(sessionId) {
+    return this.client.get(`${this.basePath}/realtime/${sessionId}`);
+  }
+  /**
+   * Compare sentiment between analyses
+   *
+   * Requires: sentiment:read permission
+   */
+  async compare(analysisIds) {
+    return this.client.post(`${this.basePath}/compare`, {
+      analysis_ids: analysisIds
+    });
+  }
+  /**
+   * Export analysis results
+   *
+   * Requires: sentiment:read permission
+   */
+  async exportAnalysis(analysisId, format) {
+    return this.client.post(`${this.basePath}/${analysisId}/export`, { format });
+  }
+  /**
+   * Wait for analysis to complete
+   */
+  async waitForReady(analysisId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 6e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const analysis = await this.get(analysisId);
+      if (options?.onProgress) {
+        options.onProgress(analysis);
+      }
+      if (analysis.status === "ready") {
+        return analysis;
+      }
+      if (analysis.status === "failed") {
+        throw new Error(
+          `Sentiment analysis failed: ${analysis.error || "Unknown error"}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Sentiment analysis timed out after ${timeout}ms`);
+  }
+  /**
+   * Get supported languages
+   *
+   * Requires: sentiment:read permission
+   */
+  async getSupportedLanguages() {
+    return this.client.get(`${this.basePath}/languages`);
+  }
+};
+function createSentimentAPI(client) {
+  return new SentimentAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SentimentAPI,
+  createSentimentAPI
+});

package/dist/sentiment.mjs

@@ -0,0 +1,9 @@
+import {
+  SentimentAPI,
+  createSentimentAPI
+} from "./chunk-NLQVD2LF.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  SentimentAPI,
+  createSentimentAPI
+};

package/dist/signage.js

@@ -0,0 +1,93 @@
+"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/signage.ts
+var signage_exports = {};
+__export(signage_exports, {
+  SignageAPI: () => SignageAPI,
+  createSignageAPI: () => createSignageAPI
+});
+module.exports = __toCommonJS(signage_exports);
+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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SignageAPI,
+  createSignageAPI
+});

package/dist/signage.mjs

@@ -0,0 +1,9 @@
+import {
+  SignageAPI,
+  createSignageAPI
+} from "./chunk-IVFZ5X4W.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  SignageAPI,
+  createSignageAPI
+};