@wave-av/sdk 2.0.1 → 2.0.2

package/dist/chunk-4DG4OBRD.mjs

@@ -0,0 +1,52 @@
+// src/desktop.ts
+var DesktopAPI = class {
+  client;
+  basePath = "/v1/desktop";
+  constructor(client) {
+    this.client = client;
+  }
+  async getInfo(nodeId) {
+    return this.client.get(`${this.basePath}/nodes/${nodeId}`);
+  }
+  async getStatus(nodeId) {
+    return this.client.get(
+      `${this.basePath}/nodes/${nodeId}/status`
+    );
+  }
+  async listDevices(nodeId) {
+    return this.client.get(`${this.basePath}/nodes/${nodeId}/devices`);
+  }
+  async configure(nodeId, config) {
+    return this.client.patch(`${this.basePath}/nodes/${nodeId}/config`, config);
+  }
+  async getConfig(nodeId) {
+    return this.client.get(`${this.basePath}/nodes/${nodeId}/config`);
+  }
+  async getLogs(nodeId, params) {
+    return this.client.get(`${this.basePath}/nodes/${nodeId}/logs`, {
+      params
+    });
+  }
+  async getPerformance(nodeId) {
+    return this.client.get(`${this.basePath}/nodes/${nodeId}/performance`);
+  }
+  async checkForUpdate(nodeId) {
+    return this.client.get(
+      `${this.basePath}/nodes/${nodeId}/updates`
+    );
+  }
+  async installUpdate(nodeId) {
+    return this.client.post(`${this.basePath}/nodes/${nodeId}/updates/install`);
+  }
+  async restart(nodeId) {
+    return this.client.post(`${this.basePath}/nodes/${nodeId}/restart`);
+  }
+};
+function createDesktopAPI(client) {
+  return new DesktopAPI(client);
+}
+
+export {
+  DesktopAPI,
+  createDesktopAPI
+};

package/dist/chunk-4G7FMCMJ.mjs

@@ -0,0 +1,68 @@
+// src/audience.ts
+var AudienceAPI = class {
+  client;
+  basePath = "/v1/audience";
+  constructor(client) {
+    this.client = client;
+  }
+  async createPoll(request) {
+    return this.client.post(`${this.basePath}/polls`, request);
+  }
+  async getPoll(pollId) {
+    return this.client.get(`${this.basePath}/polls/${pollId}`);
+  }
+  async closePoll(pollId) {
+    return this.client.post(`${this.basePath}/polls/${pollId}/close`);
+  }
+  async getPollResults(pollId) {
+    return this.client.get(`${this.basePath}/polls/${pollId}/results`);
+  }
+  async vote(pollId, optionIds) {
+    await this.client.post(`${this.basePath}/polls/${pollId}/vote`, { option_ids: optionIds });
+  }
+  async createQA(request) {
+    return this.client.post(`${this.basePath}/qa`, request);
+  }
+  async getQA(sessionId) {
+    return this.client.get(`${this.basePath}/qa/${sessionId}`);
+  }
+  async closeQA(sessionId) {
+    return this.client.post(`${this.basePath}/qa/${sessionId}/close`);
+  }
+  async submitQuestion(sessionId, text) {
+    return this.client.post(`${this.basePath}/qa/${sessionId}/questions`, { text });
+  }
+  async answerQuestion(sessionId, questionId, answer) {
+    return this.client.post(
+      `${this.basePath}/qa/${sessionId}/questions/${questionId}/answer`,
+      { answer }
+    );
+  }
+  async upvoteQuestion(sessionId, questionId) {
+    return this.client.post(
+      `${this.basePath}/qa/${sessionId}/questions/${questionId}/upvote`
+    );
+  }
+  async pinQuestion(sessionId, questionId) {
+    return this.client.post(
+      `${this.basePath}/qa/${sessionId}/questions/${questionId}/pin`
+    );
+  }
+  async sendReaction(streamId, type) {
+    await this.client.post(`${this.basePath}/reactions`, { stream_id: streamId, type });
+  }
+  async getReactionMetrics(streamId) {
+    return this.client.get(`${this.basePath}/reactions/${streamId}`);
+  }
+  async getEngagementMetrics(streamId) {
+    return this.client.get(`${this.basePath}/engagement/${streamId}`);
+  }
+};
+function createAudienceAPI(client) {
+  return new AudienceAPI(client);
+}
+
+export {
+  AudienceAPI,
+  createAudienceAPI
+};

package/dist/chunk-7M6XVUUK.mjs

@@ -0,0 +1,241 @@
+// src/captions.ts
+var CaptionsAPI = class {
+  client;
+  basePath = "/v1/captions";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Generate captions using AI
+   *
+   * Requires: captions:generate permission
+   */
+  async generate(request) {
+    return this.client.post(`${this.basePath}/generate`, request);
+  }
+  /**
+   * Upload existing captions
+   *
+   * Requires: captions:create permission
+   */
+  async upload(request) {
+    return this.client.post(`${this.basePath}/upload`, request);
+  }
+  /**
+   * Get a caption track by ID
+   *
+   * Requires: captions:read permission
+   */
+  async get(trackId) {
+    return this.client.get(`${this.basePath}/${trackId}`);
+  }
+  /**
+   * Update a caption track
+   *
+   * Requires: captions:update permission
+   */
+  async update(trackId, request) {
+    return this.client.patch(`${this.basePath}/${trackId}`, request);
+  }
+  /**
+   * Remove a caption track
+   *
+   * Requires: captions:remove permission (server-side RBAC enforced)
+   */
+  async remove(trackId) {
+    await this.client.delete(
+      `${this.basePath}/${trackId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * List caption tracks
+   *
+   * Requires: captions:read permission
+   */
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  /**
+   * Get caption tracks for a specific media
+   *
+   * Requires: captions:read permission
+   */
+  async getForMedia(mediaId, mediaType) {
+    const result = await this.list({ media_id: mediaId, media_type: mediaType });
+    return result.data;
+  }
+  /**
+   * Get caption cues (segments)
+   *
+   * Requires: captions:read permission
+   */
+  async getCues(trackId, params) {
+    return this.client.get(
+      `${this.basePath}/${trackId}/cues`,
+      { params }
+    );
+  }
+  /**
+   * Update a caption cue
+   *
+   * Requires: captions:update permission
+   */
+  async updateCue(trackId, cueId, updates) {
+    return this.client.patch(
+      `${this.basePath}/${trackId}/cues/${cueId}`,
+      updates
+    );
+  }
+  /**
+   * Add a new caption cue
+   *
+   * Requires: captions:update permission
+   */
+  async addCue(trackId, cue) {
+    return this.client.post(
+      `${this.basePath}/${trackId}/cues`,
+      cue
+    );
+  }
+  /**
+   * Remove a caption cue
+   *
+   * Requires: captions:update permission (server-side RBAC enforced)
+   */
+  async removeCue(trackId, cueId) {
+    await this.client.delete(
+      `${this.basePath}/${trackId}/cues/${cueId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Bulk update cues
+   *
+   * Requires: captions:update permission
+   */
+  async bulkUpdateCues(trackId, updates) {
+    return this.client.post(`${this.basePath}/${trackId}/cues/bulk`, { updates });
+  }
+  /**
+   * Translate a caption track to another language
+   *
+   * Requires: captions:translate permission
+   */
+  async translate(trackId, request) {
+    return this.client.post(
+      `${this.basePath}/${trackId}/translate`,
+      request
+    );
+  }
+  /**
+   * Export captions in a specific format
+   *
+   * Requires: captions:read permission
+   */
+  async exportFormat(trackId, format) {
+    return this.client.get(`${this.basePath}/${trackId}/export`, {
+      params: { format }
+    });
+  }
+  /**
+   * Get captions as plain text
+   *
+   * Requires: captions:read permission
+   */
+  async getText(trackId) {
+    const result = await this.client.get(
+      `${this.basePath}/${trackId}/text`
+    );
+    return result.text;
+  }
+  /**
+   * Burn captions into video
+   *
+   * Requires: captions:burnin permission
+   */
+  async burnIn(request) {
+    return this.client.post(`${this.basePath}/burn-in`, request);
+  }
+  /**
+   * Get burn-in job status
+   *
+   * Requires: captions:read permission
+   */
+  async getBurnInJob(jobId) {
+    return this.client.get(`${this.basePath}/burn-in/${jobId}`);
+  }
+  /**
+   * Wait for burn-in to complete
+   */
+  async waitForBurnIn(jobId, options) {
+    const pollInterval = options?.pollInterval || 3e3;
+    const timeout = options?.timeout || 18e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const job = await this.getBurnInJob(jobId);
+      if (options?.onProgress) {
+        options.onProgress(job);
+      }
+      if (job.status === "ready") {
+        return job;
+      }
+      if (job.status === "failed") {
+        throw new Error(`Burn-in failed: ${job.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Burn-in timed out after ${timeout}ms`);
+  }
+  /**
+   * Wait for caption generation to complete
+   */
+  async waitForReady(trackId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 6e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const track = await this.get(trackId);
+      if (options?.onProgress) {
+        options.onProgress(track);
+      }
+      if (track.status === "ready") {
+        return track;
+      }
+      if (track.status === "failed") {
+        throw new Error(`Caption generation failed: ${track.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Caption generation timed out after ${timeout}ms`);
+  }
+  /**
+   * Get supported languages
+   *
+   * Requires: captions:read permission
+   */
+  async getSupportedLanguages() {
+    return this.client.get(`${this.basePath}/languages`);
+  }
+  /**
+   * Detect language from audio
+   *
+   * Requires: captions:generate permission
+   */
+  async detectLanguage(mediaId, mediaType) {
+    return this.client.post(`${this.basePath}/detect-language`, {
+      media_id: mediaId,
+      media_type: mediaType
+    });
+  }
+};
+function createCaptionsAPI(client) {
+  return new CaptionsAPI(client);
+}
+
+export {
+  CaptionsAPI,
+  createCaptionsAPI
+};

package/dist/chunk-A344OOT7.mjs

@@ -0,0 +1,243 @@
+// src/search.ts
+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);
+}
+
+export {
+  SearchAPI,
+  createSearchAPI
+};