@wave-av/sdk 2.0.0 → 2.0.2

package/dist/chunk-XWABBOSX.mjs

@@ -0,0 +1,278 @@
+// src/studio.ts
+var StudioAPI = class {
+  client;
+  basePath = "/v1/productions";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a new production
+   *
+   * Requires: productions:create permission
+   */
+  async create(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Get a production by ID
+   *
+   * Requires: productions:read permission
+   */
+  async get(productionId) {
+    return this.client.get(`${this.basePath}/${productionId}`);
+  }
+  /**
+   * Update a production
+   *
+   * Requires: productions:update permission
+   */
+  async update(productionId, request) {
+    return this.client.patch(`${this.basePath}/${productionId}`, request);
+  }
+  /**
+   * Remove a production
+   *
+   * Requires: productions:remove permission (server-side RBAC enforced)
+   */
+  async remove(productionId) {
+    await this.client.delete(`${this.basePath}/${productionId}`);
+  }
+  /**
+   * List productions with optional filters
+   *
+   * Requires: productions:read permission
+   */
+  async list(params) {
+    const queryParams = {
+      limit: params?.limit,
+      offset: params?.offset,
+      cursor: params?.cursor,
+      status: params?.status,
+      created_after: params?.created_after,
+      created_before: params?.created_before,
+      order_by: params?.order_by,
+      order: params?.order
+    };
+    return this.client.get(this.basePath, {
+      params: queryParams
+    });
+  }
+  /**
+   * Start a production (go live)
+   *
+   * Transitions the production from 'idle' or 'rehearsal' to 'live'.
+   *
+   * Requires: productions:control permission
+   */
+  async start(productionId) {
+    return this.client.post(`${this.basePath}/${productionId}/start`);
+  }
+  /**
+   * Stop a production (end broadcast)
+   *
+   * Transitions the production to 'ending' and then 'ended'.
+   *
+   * Requires: productions:control permission
+   */
+  async stop(productionId) {
+    return this.client.post(`${this.basePath}/${productionId}/stop`);
+  }
+  /**
+   * Start a rehearsal session
+   *
+   * Allows testing sources, scenes, and transitions without going live.
+   * Transitions the production from 'idle' to 'rehearsal'.
+   *
+   * Requires: productions:control permission
+   */
+  async startRehearsal(productionId) {
+    return this.client.post(`${this.basePath}/${productionId}/rehearsal`);
+  }
+  /**
+   * Add an input source to a production
+   *
+   * Requires: productions:sources:create permission
+   */
+  async addSource(productionId, source) {
+    return this.client.post(`${this.basePath}/${productionId}/sources`, source);
+  }
+  /**
+   * Remove a source from a production
+   *
+   * Requires: productions:sources:remove permission
+   */
+  async removeSource(productionId, sourceId) {
+    await this.client.delete(`${this.basePath}/${productionId}/sources/${sourceId}`);
+  }
+  /**
+   * List all sources for a production
+   *
+   * Requires: productions:sources:read permission
+   */
+  async listSources(productionId) {
+    return this.client.get(`${this.basePath}/${productionId}/sources`);
+  }
+  /**
+   * Get a specific source by ID
+   *
+   * Requires: productions:sources:read permission
+   */
+  async getSource(productionId, sourceId) {
+    return this.client.get(`${this.basePath}/${productionId}/sources/${sourceId}`);
+  }
+  /**
+   * Create a new scene in a production
+   *
+   * Requires: productions:scenes:create permission
+   */
+  async createScene(productionId, scene) {
+    return this.client.post(`${this.basePath}/${productionId}/scenes`, scene);
+  }
+  /**
+   * Update an existing scene
+   *
+   * Requires: productions:scenes:update permission
+   */
+  async updateScene(productionId, sceneId, updates) {
+    return this.client.patch(`${this.basePath}/${productionId}/scenes/${sceneId}`, updates);
+  }
+  /**
+   * Remove a scene from a production
+   *
+   * Requires: productions:scenes:remove permission
+   */
+  async removeScene(productionId, sceneId) {
+    await this.client.delete(`${this.basePath}/${productionId}/scenes/${sceneId}`);
+  }
+  /**
+   * List all scenes for a production
+   *
+   * Requires: productions:scenes:read permission
+   */
+  async listScenes(productionId) {
+    return this.client.get(`${this.basePath}/${productionId}/scenes`);
+  }
+  /**
+   * Activate a scene with an optional transition
+   *
+   * Sets the scene as the active scene for the production output.
+   *
+   * Requires: productions:scenes:control permission
+   */
+  async activateScene(productionId, sceneId, transition) {
+    return this.client.post(
+      `${this.basePath}/${productionId}/scenes/${sceneId}/activate`,
+      transition ? { transition } : void 0
+    );
+  }
+  /**
+   * Set the program (live) source with an optional transition
+   *
+   * Switches the currently live output to the specified source.
+   *
+   * Requires: productions:control permission
+   */
+  async setProgram(productionId, sourceId, transition) {
+    await this.client.post(`${this.basePath}/${productionId}/program`, {
+      source_id: sourceId,
+      transition
+    });
+  }
+  /**
+   * Set the preview source
+   *
+   * Loads a source into the preview output for inspection before going live.
+   *
+   * Requires: productions:control permission
+   */
+  async setPreview(productionId, sourceId) {
+    await this.client.post(`${this.basePath}/${productionId}/preview`, { source_id: sourceId });
+  }
+  /**
+   * Execute a transition between preview and program
+   *
+   * Swaps the current preview source into program using the specified transition.
+   *
+   * Requires: productions:control permission
+   */
+  async transition(productionId, config) {
+    await this.client.post(`${this.basePath}/${productionId}/transition`, config);
+  }
+  /**
+   * Add a graphic overlay to a production
+   *
+   * Requires: productions:graphics:create permission
+   */
+  async addGraphic(productionId, graphic) {
+    return this.client.post(`${this.basePath}/${productionId}/graphics`, graphic);
+  }
+  /**
+   * Update an existing graphic
+   *
+   * Requires: productions:graphics:update permission
+   */
+  async updateGraphic(productionId, graphicId, updates) {
+    return this.client.patch(
+      `${this.basePath}/${productionId}/graphics/${graphicId}`,
+      updates
+    );
+  }
+  /**
+   * Remove a graphic from a production
+   *
+   * Requires: productions:graphics:remove permission
+   */
+  async removeGraphic(productionId, graphicId) {
+    await this.client.delete(`${this.basePath}/${productionId}/graphics/${graphicId}`);
+  }
+  /**
+   * Show a graphic on the production output
+   *
+   * Makes the graphic visible on the live output.
+   *
+   * Requires: productions:graphics:control permission
+   */
+  async showGraphic(productionId, graphicId) {
+    await this.client.post(`${this.basePath}/${productionId}/graphics/${graphicId}/show`);
+  }
+  /**
+   * Hide a graphic from the production output
+   *
+   * Removes the graphic from the live output without deleting it.
+   *
+   * Requires: productions:graphics:control permission
+   */
+  async hideGraphic(productionId, graphicId) {
+    await this.client.post(`${this.basePath}/${productionId}/graphics/${graphicId}/hide`);
+  }
+  /**
+   * Get the current audio mix for a production
+   *
+   * Returns volume, mute, solo, pan, and processing settings for all channels.
+   *
+   * Requires: productions:audio:read permission
+   */
+  async getAudioMix(productionId) {
+    return this.client.get(`${this.basePath}/${productionId}/audio-mix`);
+  }
+  /**
+   * Set the audio mix for a production
+   *
+   * Updates volume, mute, solo, pan, and processing settings for channels.
+   *
+   * Requires: productions:audio:control permission
+   */
+  async setAudioMix(productionId, channels) {
+    return this.client.put(`${this.basePath}/${productionId}/audio-mix`, {
+      channels
+    });
+  }
+};
+function createStudioAPI(client) {
+  return new StudioAPI(client);
+}
+
+export {
+  StudioAPI,
+  createStudioAPI
+};

package/dist/chunk-Y6FXYEAI.mjs

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-YBLXHI3M.mjs

@@ -0,0 +1,257 @@
+// src/transcribe.ts
+var TranscribeAPI = class {
+  client;
+  basePath = "/v1/transcribe";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a transcription job
+   *
+   * Requires: transcribe:create permission
+   */
+  async create(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Get a transcription by ID
+   *
+   * Requires: transcribe:read permission
+   */
+  async get(transcriptionId) {
+    return this.client.get(`${this.basePath}/${transcriptionId}`);
+  }
+  /**
+   * Update a transcription
+   *
+   * Requires: transcribe:update permission
+   */
+  async update(transcriptionId, request) {
+    return this.client.patch(
+      `${this.basePath}/${transcriptionId}`,
+      request
+    );
+  }
+  /**
+   * Remove a transcription
+   *
+   * Requires: transcribe:remove permission (server-side RBAC enforced)
+   */
+  async remove(transcriptionId) {
+    await this.client.delete(
+      `${this.basePath}/${transcriptionId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * List transcriptions
+   *
+   * Requires: transcribe:read permission
+   */
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  /**
+   * Get transcription segments
+   *
+   * Requires: transcribe:read permission
+   */
+  async getSegments(transcriptionId, params) {
+    return this.client.get(
+      `${this.basePath}/${transcriptionId}/segments`,
+      { params }
+    );
+  }
+  /**
+   * Update a segment
+   *
+   * Requires: transcribe:update permission
+   */
+  async updateSegment(transcriptionId, segmentId, updates) {
+    return this.client.patch(
+      `${this.basePath}/${transcriptionId}/segments/${segmentId}`,
+      updates
+    );
+  }
+  /**
+   * Merge segments
+   *
+   * Requires: transcribe:update permission
+   */
+  async mergeSegments(transcriptionId, segmentIds) {
+    return this.client.post(
+      `${this.basePath}/${transcriptionId}/segments/merge`,
+      { segment_ids: segmentIds }
+    );
+  }
+  /**
+   * Split a segment
+   *
+   * Requires: transcribe:update permission
+   */
+  async splitSegment(transcriptionId, segmentId, splitTime) {
+    return this.client.post(
+      `${this.basePath}/${transcriptionId}/segments/${segmentId}/split`,
+      { split_time: splitTime }
+    );
+  }
+  /**
+   * Get speakers
+   *
+   * Requires: transcribe:read permission
+   */
+  async getSpeakers(transcriptionId) {
+    return this.client.get(
+      `${this.basePath}/${transcriptionId}/speakers`
+    );
+  }
+  /**
+   * Update speaker label
+   *
+   * Requires: transcribe:update permission
+   */
+  async updateSpeaker(transcriptionId, speakerId, label) {
+    return this.client.patch(
+      `${this.basePath}/${transcriptionId}/speakers/${speakerId}`,
+      { label }
+    );
+  }
+  /**
+   * Merge speakers
+   *
+   * Requires: transcribe:update permission
+   */
+  async mergeSpeakers(transcriptionId, speakerIds, newLabel) {
+    return this.client.post(
+      `${this.basePath}/${transcriptionId}/speakers/merge`,
+      { speaker_ids: speakerIds, label: newLabel }
+    );
+  }
+  /**
+   * Export transcription
+   *
+   * Requires: transcribe:read permission
+   */
+  async exportTranscription(transcriptionId, format, options) {
+    return this.client.post(`${this.basePath}/${transcriptionId}/export`, {
+      format,
+      ...options
+    });
+  }
+  /**
+   * Get plain text transcript
+   *
+   * Requires: transcribe:read permission
+   */
+  async getText(transcriptionId, options) {
+    const result = await this.client.get(
+      `${this.basePath}/${transcriptionId}/text`,
+      { params: options }
+    );
+    return result.text;
+  }
+  /**
+   * Search within a transcription
+   *
+   * Requires: transcribe:read permission
+   */
+  async search(transcriptionId, query, options) {
+    return this.client.post(`${this.basePath}/${transcriptionId}/search`, {
+      query,
+      ...options
+    });
+  }
+  /**
+   * Start real-time transcription
+   *
+   * Requires: transcribe:realtime permission
+   */
+  async startRealtime(streamId, options) {
+    return this.client.post(`${this.basePath}/realtime/start`, {
+      stream_id: streamId,
+      ...options
+    });
+  }
+  /**
+   * Stop real-time transcription
+   *
+   * Requires: transcribe:realtime permission
+   */
+  async stopRealtime(sessionId) {
+    return this.client.post(
+      `${this.basePath}/realtime/${sessionId}/stop`
+    );
+  }
+  /**
+   * Get real-time session status
+   *
+   * Requires: transcribe:read permission
+   */
+  async getRealtimeStatus(sessionId) {
+    return this.client.get(`${this.basePath}/realtime/${sessionId}`);
+  }
+  /**
+   * Wait for transcription to complete
+   */
+  async waitForReady(transcriptionId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 18e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const transcription = await this.get(transcriptionId);
+      if (options?.onProgress) {
+        options.onProgress(transcription);
+      }
+      if (transcription.status === "ready") {
+        return transcription;
+      }
+      if (transcription.status === "failed") {
+        throw new Error(
+          `Transcription failed: ${transcription.error || "Unknown error"}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Transcription timed out after ${timeout}ms`);
+  }
+  /**
+   * Detect language from audio
+   *
+   * Requires: transcribe:read permission
+   */
+  async detectLanguage(sourceUrl) {
+    return this.client.post(`${this.basePath}/detect-language`, {
+      source_url: sourceUrl
+    });
+  }
+  /**
+   * Get supported languages
+   *
+   * Requires: transcribe:read permission
+   */
+  async getSupportedLanguages() {
+    return this.client.get(`${this.basePath}/languages`);
+  }
+  /**
+   * Estimate transcription cost
+   *
+   * Requires: transcribe:read permission
+   */
+  async estimateCost(durationSeconds, model = "standard", options) {
+    return this.client.post(`${this.basePath}/estimate`, {
+      duration_seconds: durationSeconds,
+      model,
+      ...options
+    });
+  }
+};
+function createTranscribeAPI(client) {
+  return new TranscribeAPI(client);
+}
+
+export {
+  TranscribeAPI,
+  createTranscribeAPI
+};

package/dist/chunk-YEK26SSO.mjs

@@ -0,0 +1,100 @@
+import {
+  __require
+} from "./chunk-Y6FXYEAI.mjs";
+
+// src/telemetry.ts
+var SPAN_STATUS_OK = 1;
+var SPAN_STATUS_ERROR = 2;
+var resolvedTracer = null;
+var telemetryEnabled = false;
+function initTelemetry(config) {
+  if (!config.enabled) {
+    telemetryEnabled = false;
+    resolvedTracer = null;
+    return;
+  }
+  try {
+    const otelApi = __require("@opentelemetry/api");
+    const serviceName = config.serviceName ?? "@wave/sdk";
+    resolvedTracer = otelApi.trace.getTracer(serviceName, "2.0.0");
+    telemetryEnabled = true;
+  } catch {
+    telemetryEnabled = false;
+    resolvedTracer = null;
+  }
+}
+function resetTelemetry() {
+  telemetryEnabled = false;
+  resolvedTracer = null;
+}
+function isTelemetryEnabled() {
+  return telemetryEnabled;
+}
+async function withTelemetry(operationName, fn, attributes) {
+  if (!telemetryEnabled || !resolvedTracer) {
+    return fn();
+  }
+  const span = resolvedTracer.startSpan(`wave.sdk.${operationName}`);
+  const startTime = performance.now();
+  try {
+    if (attributes) {
+      for (const [key, value] of Object.entries(attributes)) {
+        span.setAttribute(key, value);
+      }
+    }
+    const result = await fn();
+    const durationMs = performance.now() - startTime;
+    span.setAttribute("wave.sdk.method", operationName);
+    span.setAttribute("wave.sdk.duration_ms", Math.round(durationMs));
+    span.setStatus({ code: SPAN_STATUS_OK });
+    span.end();
+    return result;
+  } catch (error) {
+    const durationMs = performance.now() - startTime;
+    span.setAttribute("wave.sdk.method", operationName);
+    span.setAttribute("wave.sdk.duration_ms", Math.round(durationMs));
+    const errorType = error instanceof Error ? error.constructor.name : "UnknownError";
+    span.setAttribute("wave.sdk.error_type", errorType);
+    span.setStatus({ code: SPAN_STATUS_ERROR });
+    span.end();
+    throw error;
+  }
+}
+function withTelemetrySync(operationName, fn, attributes) {
+  if (!telemetryEnabled || !resolvedTracer) {
+    return fn();
+  }
+  const span = resolvedTracer.startSpan(`wave.sdk.${operationName}`);
+  const startTime = performance.now();
+  try {
+    if (attributes) {
+      for (const [key, value] of Object.entries(attributes)) {
+        span.setAttribute(key, value);
+      }
+    }
+    const result = fn();
+    const durationMs = performance.now() - startTime;
+    span.setAttribute("wave.sdk.method", operationName);
+    span.setAttribute("wave.sdk.duration_ms", Math.round(durationMs));
+    span.setStatus({ code: SPAN_STATUS_OK });
+    span.end();
+    return result;
+  } catch (error) {
+    const durationMs = performance.now() - startTime;
+    span.setAttribute("wave.sdk.method", operationName);
+    span.setAttribute("wave.sdk.duration_ms", Math.round(durationMs));
+    const errorType = error instanceof Error ? error.constructor.name : "UnknownError";
+    span.setAttribute("wave.sdk.error_type", errorType);
+    span.setStatus({ code: SPAN_STATUS_ERROR });
+    span.end();
+    throw error;
+  }
+}
+
+export {
+  initTelemetry,
+  resetTelemetry,
+  isTelemetryEnabled,
+  withTelemetry,
+  withTelemetrySync
+};

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