@wave-av/sdk 2.0.1 → 2.0.2

package/dist/captions.js

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

package/dist/captions.mjs

@@ -0,0 +1,9 @@
+import {
+  CaptionsAPI,
+  createCaptionsAPI
+} from "./chunk-7M6XVUUK.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  CaptionsAPI,
+  createCaptionsAPI
+};

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

package/dist/chapters.js

@@ -0,0 +1,280 @@
+"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/chapters.ts
+var chapters_exports = {};
+__export(chapters_exports, {
+  ChaptersAPI: () => ChaptersAPI,
+  createChaptersAPI: () => createChaptersAPI
+});
+module.exports = __toCommonJS(chapters_exports);
+var ChaptersAPI = class {
+  client;
+  basePath = "/v1/chapters";
+  constructor(client) {
+    this.client = client;
+  }
+  // Chapter Sets
+  /**
+   * Generate chapters using AI
+   *
+   * Requires: chapters:generate permission
+   */
+  async generate(request) {
+    return this.client.post(`${this.basePath}/generate`, request);
+  }
+  /**
+   * Create a chapter set manually
+   *
+   * Requires: chapters:create permission
+   */
+  async createSet(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Get a chapter set by ID
+   *
+   * Requires: chapters:read permission
+   */
+  async getSet(setId) {
+    return this.client.get(`${this.basePath}/${setId}`);
+  }
+  /**
+   * Update a chapter set
+   *
+   * Requires: chapters:update permission
+   */
+  async updateSet(setId, request) {
+    return this.client.patch(`${this.basePath}/${setId}`, request);
+  }
+  /**
+   * Remove a chapter set
+   *
+   * Requires: chapters:remove permission (canDelete verified server-side)
+   */
+  async removeSet(setId) {
+    await this.client.delete(`${this.basePath}/${setId}`);
+  }
+  /**
+   * List chapter sets
+   *
+   * Requires: chapters:read permission
+   */
+  async listSets(params) {
+    return this.client.get(this.basePath, { params });
+  }
+  /**
+   * Get the default chapter set for a media
+   *
+   * Requires: chapters:read permission
+   */
+  async getDefaultSet(mediaId, mediaType) {
+    try {
+      return await this.client.get(`${this.basePath}/default`, {
+        params: { media_id: mediaId, media_type: mediaType }
+      });
+    } catch (error) {
+      if (error.statusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Duplicate a chapter set
+   *
+   * Requires: chapters:create permission
+   */
+  async duplicateSet(setId, name) {
+    return this.client.post(`${this.basePath}/${setId}/duplicate`, { name });
+  }
+  // Individual Chapters
+  /**
+   * Add a chapter to a set
+   *
+   * Requires: chapters:update permission
+   */
+  async addChapter(setId, chapter) {
+    return this.client.post(`${this.basePath}/${setId}/chapters`, chapter);
+  }
+  /**
+   * Get a chapter by ID
+   *
+   * Requires: chapters:read permission
+   */
+  async getChapter(setId, chapterId) {
+    return this.client.get(`${this.basePath}/${setId}/chapters/${chapterId}`);
+  }
+  /**
+   * Update a chapter
+   *
+   * Requires: chapters:update permission
+   */
+  async updateChapter(setId, chapterId, request) {
+    return this.client.patch(
+      `${this.basePath}/${setId}/chapters/${chapterId}`,
+      request
+    );
+  }
+  /**
+   * Remove a chapter
+   *
+   * Requires: chapters:update permission (server-side RBAC enforced)
+   */
+  async removeChapter(setId, chapterId) {
+    await this.client.delete(
+      `${this.basePath}/${setId}/chapters/${chapterId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Reorder chapters
+   *
+   * Requires: chapters:update permission
+   */
+  async reorderChapters(setId, chapterIds) {
+    return this.client.post(
+      `${this.basePath}/${setId}/chapters/reorder`,
+      { chapter_ids: chapterIds }
+    );
+  }
+  /**
+   * Bulk update chapters
+   *
+   * Requires: chapters:update permission
+   */
+  async bulkUpdateChapters(setId, updates) {
+    return this.client.post(`${this.basePath}/${setId}/chapters/bulk`, { updates });
+  }
+  // Thumbnails
+  /**
+   * Generate thumbnail for a chapter
+   *
+   * Requires: chapters:update permission
+   */
+  async generateThumbnail(setId, chapterId, options) {
+    return this.client.post(
+      `${this.basePath}/${setId}/chapters/${chapterId}/thumbnail`,
+      options
+    );
+  }
+  /**
+   * Generate thumbnails for all chapters in a set
+   *
+   * Requires: chapters:update permission
+   */
+  async generateAllThumbnails(setId) {
+    return this.client.post(`${this.basePath}/${setId}/thumbnails`);
+  }
+  // Export
+  /**
+   * Export chapters in various formats
+   *
+   * Requires: chapters:read permission
+   */
+  async exportChapters(setId, format) {
+    return this.client.get(`${this.basePath}/${setId}/export`, {
+      params: { format }
+    });
+  }
+  /**
+   * Import chapters from a format
+   *
+   * Requires: chapters:create permission
+   */
+  async importChapters(mediaId, mediaType, format, content, options) {
+    return this.client.post(`${this.basePath}/import`, {
+      media_id: mediaId,
+      media_type: mediaType,
+      format,
+      content,
+      ...options
+    });
+  }
+  // Utilities
+  /**
+   * Wait for chapter generation to complete
+   */
+  async waitForReady(setId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 6e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const set = await this.getSet(setId);
+      if (options?.onProgress) {
+        options.onProgress(set);
+      }
+      if (set.status === "ready") {
+        return set;
+      }
+      if (set.status === "failed") {
+        throw new Error(`Chapter generation failed: ${set.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Chapter generation timed out after ${timeout}ms`);
+  }
+  /**
+   * Get chapter at a specific time
+   *
+   * Requires: chapters:read permission
+   */
+  async getChapterAtTime(setId, time) {
+    try {
+      return await this.client.get(`${this.basePath}/${setId}/at`, {
+        params: { time }
+      });
+    } catch (error) {
+      if (error.statusCode === 404) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Merge chapters
+   *
+   * Requires: chapters:update permission
+   */
+  async mergeChapters(setId, chapterIds, options) {
+    return this.client.post(`${this.basePath}/${setId}/chapters/merge`, {
+      chapter_ids: chapterIds,
+      ...options
+    });
+  }
+  /**
+   * Split a chapter at a specific time
+   *
+   * Requires: chapters:update permission
+   */
+  async splitChapter(setId, chapterId, splitTime, options) {
+    return this.client.post(`${this.basePath}/${setId}/chapters/${chapterId}/split`, {
+      split_time: splitTime,
+      ...options
+    });
+  }
+};
+function createChaptersAPI(client) {
+  return new ChaptersAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChaptersAPI,
+  createChaptersAPI
+});

package/dist/chapters.mjs

@@ -0,0 +1,9 @@
+import {
+  ChaptersAPI,
+  createChaptersAPI
+} from "./chunk-CO2VB72Z.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  ChaptersAPI,
+  createChaptersAPI
+};

package/dist/chunk-362MRITF.mjs

@@ -0,0 +1,46 @@
+// src/qr.ts
+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);
+}
+
+export {
+  QrAPI,
+  createQrAPI
+};

package/dist/chunk-3ZLK4J3V.mjs

@@ -0,0 +1,69 @@
+// src/podcast.ts
+var PodcastAPI = class {
+  client;
+  basePath = "/v1/podcasts";
+  constructor(client) {
+    this.client = client;
+  }
+  async create(request) {
+    return this.client.post(this.basePath, request);
+  }
+  async get(podcastId) {
+    return this.client.get(`${this.basePath}/${podcastId}`);
+  }
+  async update(podcastId, updates) {
+    return this.client.patch(`${this.basePath}/${podcastId}`, updates);
+  }
+  async remove(podcastId) {
+    await this.client.delete(`${this.basePath}/${podcastId}`);
+  }
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  async createEpisode(request) {
+    return this.client.post(`${this.basePath}/${request.podcast_id}/episodes`, request);
+  }
+  async getEpisode(episodeId) {
+    return this.client.get(`/v1/episodes/${episodeId}`);
+  }
+  async updateEpisode(episodeId, updates) {
+    return this.client.patch(`/v1/episodes/${episodeId}`, updates);
+  }
+  async removeEpisode(episodeId) {
+    await this.client.delete(`/v1/episodes/${episodeId}`);
+  }
+  async publishEpisode(episodeId) {
+    return this.client.post(`/v1/episodes/${episodeId}/publish`);
+  }
+  async listEpisodes(podcastId, params) {
+    return this.client.get(`${this.basePath}/${podcastId}/episodes`, {
+      params
+    });
+  }
+  async getRSSFeed(podcastId) {
+    return this.client.get(`${this.basePath}/${podcastId}/rss`);
+  }
+  async getAnalytics(podcastId, params) {
+    return this.client.get(`${this.basePath}/${podcastId}/analytics`, {
+      params
+    });
+  }
+  async distribute(podcastId, targets) {
+    return this.client.post(`${this.basePath}/${podcastId}/distribute`, {
+      targets
+    });
+  }
+  async getDistributionStatus(podcastId) {
+    return this.client.get(`${this.basePath}/${podcastId}/distribution`);
+  }
+};
+function createPodcastAPI(client) {
+  return new PodcastAPI(client);
+}
+
+export {
+  PodcastAPI,
+  createPodcastAPI
+};