@wave-av/sdk 2.0.0 → 2.0.2

package/dist/chunk-AI64YR5W.mjs

@@ -0,0 +1,173 @@
+// src/clips.ts
+var ClipsAPI = class {
+  client;
+  basePath = "/v1/clips";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new clip
+   *
+   * Requires: clips:create permission
+   */
+  async create(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Get a clip by ID
+   *
+   * Requires: clips:read permission
+   */
+  async get(clipId) {
+    return this.client.get(`${this.basePath}/${clipId}`);
+  }
+  /**
+   * Update a clip
+   *
+   * Requires: clips:update permission
+   */
+  async update(clipId, request) {
+    return this.client.patch(`${this.basePath}/${clipId}`, request);
+  }
+  /**
+   * Remove a clip
+   *
+   * Requires: clips:remove permission (server-side RBAC enforced)
+   */
+  async remove(clipId) {
+    await this.client.delete(`${this.basePath}/${clipId}`);
+  }
+  /**
+   * List clips with optional filters
+   *
+   * Requires: clips:read permission
+   */
+  async list(params) {
+    const queryParams = {
+      limit: params?.limit,
+      offset: params?.offset,
+      cursor: params?.cursor,
+      status: params?.status,
+      source_type: params?.source_type,
+      source_id: params?.source_id,
+      created_after: params?.created_after,
+      created_before: params?.created_before,
+      order_by: params?.order_by,
+      order: params?.order
+    };
+    if (params?.tags?.length) {
+      queryParams["tags"] = params.tags.join(",");
+    }
+    return this.client.get(this.basePath, {
+      params: queryParams
+    });
+  }
+  /**
+   * Export a clip to a different format
+   *
+   * Requires: clips:export permission
+   */
+  async exportClip(clipId, request) {
+    return this.client.post(
+      `${this.basePath}/${clipId}/export`,
+      request
+    );
+  }
+  /**
+   * Get export job status
+   *
+   * Requires: clips:read permission
+   */
+  async getExport(clipId, exportId) {
+    return this.client.get(
+      `${this.basePath}/${clipId}/exports/${exportId}`
+    );
+  }
+  /**
+   * List all exports for a clip
+   *
+   * Requires: clips:read permission
+   */
+  async listExports(clipId, params) {
+    return this.client.get(
+      `${this.basePath}/${clipId}/exports`,
+      { params }
+    );
+  }
+  /**
+   * Detect highlights in source content
+   *
+   * Requires: clips:analyze permission
+   */
+  async detectHighlights(sourceType, sourceId, options) {
+    return this.client.post(
+      `${this.basePath}/highlights/detect`,
+      {
+        source_type: sourceType,
+        source_id: sourceId,
+        ...options
+      }
+    );
+  }
+  /**
+   * Generate clips from detected highlights
+   *
+   * Requires: clips:create permission
+   */
+  async createFromHighlights(sourceType, sourceId, options) {
+    return this.client.post(`${this.basePath}/highlights/create`, {
+      source_type: sourceType,
+      source_id: sourceId,
+      ...options
+    });
+  }
+  /**
+   * Wait for a clip to be ready
+   */
+  async waitForReady(clipId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 3e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const clip = await this.get(clipId);
+      if (options?.onProgress) {
+        options.onProgress(clip);
+      }
+      if (clip.status === "ready") {
+        return clip;
+      }
+      if (clip.status === "failed") {
+        throw new Error(`Clip processing failed: ${clip.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Clip processing timed out after ${timeout}ms`);
+  }
+  /**
+   * Wait for an export to be ready
+   */
+  async waitForExport(clipId, exportId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 3e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const exportJob = await this.getExport(clipId, exportId);
+      if (exportJob.status === "ready") {
+        return exportJob;
+      }
+      if (exportJob.status === "failed") {
+        throw new Error(`Export failed: ${exportJob.error || "Unknown error"}`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Export timed out after ${timeout}ms`);
+  }
+};
+function createClipsAPI(client) {
+  return new ClipsAPI(client);
+}
+
+export {
+  ClipsAPI,
+  createClipsAPI
+};

package/dist/chunk-C2GQ756E.mjs

@@ -0,0 +1,57 @@
+// src/prism.ts
+var PrismAPI = class {
+  client;
+  basePath = "/v1/prism";
+  constructor(client) {
+    this.client = client;
+  }
+  async createDevice(request) {
+    return this.client.post(`${this.basePath}/devices`, request);
+  }
+  async getDevice(deviceId) {
+    return this.client.get(`${this.basePath}/devices/${deviceId}`);
+  }
+  async updateDevice(deviceId, request) {
+    return this.client.patch(`${this.basePath}/devices/${deviceId}`, request);
+  }
+  async removeDevice(deviceId) {
+    await this.client.delete(`${this.basePath}/devices/${deviceId}`);
+  }
+  async listDevices(params) {
+    return this.client.get(`${this.basePath}/devices`, {
+      params
+    });
+  }
+  async startDevice(deviceId) {
+    return this.client.post(`${this.basePath}/devices/${deviceId}/start`);
+  }
+  async stopDevice(deviceId) {
+    return this.client.post(`${this.basePath}/devices/${deviceId}/stop`);
+  }
+  async getHealth(deviceId) {
+    return this.client.get(`${this.basePath}/devices/${deviceId}/health`);
+  }
+  async discoverSources(options) {
+    return this.client.post(`${this.basePath}/discovery`, options);
+  }
+  async getPresets(deviceId) {
+    return this.client.get(`${this.basePath}/devices/${deviceId}/presets`);
+  }
+  async setPreset(deviceId, request) {
+    return this.client.put(`${this.basePath}/devices/${deviceId}/presets`, request);
+  }
+  async removePreset(deviceId, slotNumber) {
+    await this.client.delete(`${this.basePath}/devices/${deviceId}/presets/${slotNumber}`);
+  }
+  async recallPreset(deviceId, slotNumber) {
+    await this.client.post(`${this.basePath}/devices/${deviceId}/presets/${slotNumber}/recall`);
+  }
+};
+function createPrismAPI(client) {
+  return new PrismAPI(client);
+}
+
+export {
+  PrismAPI,
+  createPrismAPI
+};

package/dist/chunk-CO2VB72Z.mjs

@@ -0,0 +1,255 @@
+// src/chapters.ts
+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);
+}
+
+export {
+  ChaptersAPI,
+  createChaptersAPI
+};

package/dist/chunk-DWXWAILB.mjs

@@ -0,0 +1,44 @@
+// src/usb.ts
+var UsbAPI = class {
+  client;
+  basePath = "/v1/usb";
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get(`${this.basePath}/devices`, {
+      params
+    });
+  }
+  async get(deviceId) {
+    return this.client.get(`${this.basePath}/devices/${deviceId}`);
+  }
+  async claim(deviceId, request) {
+    return this.client.post(`${this.basePath}/devices/${deviceId}/claim`, request);
+  }
+  async release(deviceId) {
+    return this.client.post(`${this.basePath}/devices/${deviceId}/release`);
+  }
+  async getCapabilities(deviceId) {
+    return this.client.get(
+      `${this.basePath}/devices/${deviceId}/capabilities`
+    );
+  }
+  async listByNode(nodeId, params) {
+    return this.client.get(
+      `${this.basePath}/nodes/${nodeId}/devices`,
+      { params }
+    );
+  }
+  async configure(deviceId, config) {
+    return this.client.patch(`${this.basePath}/devices/${deviceId}/config`, config);
+  }
+};
+function createUsbAPI(client) {
+  return new UsbAPI(client);
+}
+
+export {
+  UsbAPI,
+  createUsbAPI
+};

package/dist/chunk-FLEFYLDM.mjs

@@ -0,0 +1,71 @@
+// src/vault.ts
+var VaultAPI = class {
+  client;
+  basePath = "/v1/vault";
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get(`${this.basePath}/recordings`, {
+      params
+    });
+  }
+  async get(recordingId) {
+    return this.client.get(`${this.basePath}/recordings/${recordingId}`);
+  }
+  async update(recordingId, updates) {
+    return this.client.patch(`${this.basePath}/recordings/${recordingId}`, updates);
+  }
+  async remove(recordingId) {
+    await this.client.delete(`${this.basePath}/recordings/${recordingId}`);
+  }
+  async getStorageUsage() {
+    return this.client.get(`${this.basePath}/storage`);
+  }
+  async createUpload(request) {
+    return this.client.post(`${this.basePath}/uploads`, request);
+  }
+  async completeUpload(uploadId) {
+    return this.client.post(`${this.basePath}/uploads/${uploadId}/complete`);
+  }
+  async startRecording(streamId, options) {
+    return this.client.post(`${this.basePath}/recordings`, {
+      stream_id: streamId,
+      ...options
+    });
+  }
+  async stopRecording(streamId) {
+    return this.client.post(`${this.basePath}/recordings/stop`, { stream_id: streamId });
+  }
+  async transcode(recordingId, request) {
+    return this.client.post(
+      `${this.basePath}/recordings/${recordingId}/transcode`,
+      request
+    );
+  }
+  async getTranscodeJob(jobId) {
+    return this.client.get(`${this.basePath}/transcode/${jobId}`);
+  }
+  async createArchivePolicy(policy) {
+    return this.client.post(`${this.basePath}/policies`, policy);
+  }
+  async listArchivePolicies() {
+    return this.client.get(`${this.basePath}/policies`);
+  }
+  async removeArchivePolicy(policyId) {
+    await this.client.delete(`${this.basePath}/policies/${policyId}`);
+  }
+  async getDownloadUrl(recordingId) {
+    return this.client.get(
+      `${this.basePath}/recordings/${recordingId}/download`
+    );
+  }
+};
+function createVaultAPI(client) {
+  return new VaultAPI(client);
+}
+
+export {
+  VaultAPI,
+  createVaultAPI
+};