@wave-av/sdk 2.0.1 → 2.0.2

package/dist/chunk-UCDSNV22.mjs

@@ -0,0 +1,63 @@
+// src/distribution.ts
+var DistributionAPI = class {
+  client;
+  basePath = "/v1/distribution";
+  constructor(client) {
+    this.client = client;
+  }
+  async listDestinations(params) {
+    return this.client.get(`${this.basePath}/destinations`, {
+      params
+    });
+  }
+  async getDestination(destId) {
+    return this.client.get(`${this.basePath}/destinations/${destId}`);
+  }
+  async addDestination(request) {
+    return this.client.post(`${this.basePath}/destinations`, request);
+  }
+  async updateDestination(destId, updates) {
+    return this.client.patch(`${this.basePath}/destinations/${destId}`, updates);
+  }
+  async removeDestination(destId) {
+    await this.client.delete(`${this.basePath}/destinations/${destId}`);
+  }
+  async startSimulcast(streamId, destinationIds) {
+    return this.client.post(`${this.basePath}/simulcast`, {
+      stream_id: streamId,
+      destination_ids: destinationIds
+    });
+  }
+  async stopSimulcast(streamId) {
+    return this.client.post(`${this.basePath}/simulcast/stop`, {
+      stream_id: streamId
+    });
+  }
+  async getSimulcastStatus(streamId) {
+    return this.client.get(`${this.basePath}/simulcast/${streamId}`);
+  }
+  async schedulePost(request) {
+    return this.client.post(`${this.basePath}/posts`, request);
+  }
+  async listScheduledPosts(params) {
+    return this.client.get(`${this.basePath}/posts`, {
+      params
+    });
+  }
+  async cancelScheduledPost(postId) {
+    await this.client.delete(`${this.basePath}/posts/${postId}`);
+  }
+  async getDistributionAnalytics(params) {
+    return this.client.get(`${this.basePath}/analytics`, {
+      params
+    });
+  }
+};
+function createDistributionAPI(client) {
+  return new DistributionAPI(client);
+}
+
+export {
+  DistributionAPI,
+  createDistributionAPI
+};

package/dist/chunk-V5DWA5P4.mjs

@@ -0,0 +1,279 @@
+// src/collab.ts
+var CollabAPI = class {
+  client;
+  basePath = "/v1/collab";
+  constructor(client) {
+    this.client = client;
+  }
+  // Rooms
+  /**
+   * Create a collaboration room
+   *
+   * Requires: collab:create permission
+   */
+  async createRoom(request) {
+    return this.client.post(`${this.basePath}/rooms`, request);
+  }
+  /**
+   * Get a room by ID
+   *
+   * Requires: collab:read permission
+   */
+  async getRoom(roomId) {
+    return this.client.get(`${this.basePath}/rooms/${roomId}`);
+  }
+  /**
+   * Update a room
+   *
+   * Requires: collab:update permission
+   */
+  async updateRoom(roomId, request) {
+    return this.client.patch(
+      `${this.basePath}/rooms/${roomId}`,
+      request
+    );
+  }
+  /**
+   * Close a room
+   *
+   * Requires: collab:manage permission
+   */
+  async closeRoom(roomId) {
+    return this.client.post(`${this.basePath}/rooms/${roomId}/close`);
+  }
+  /**
+   * Archive a room
+   *
+   * Requires: collab:manage permission (server-side RBAC enforced)
+   */
+  async archiveRoom(roomId) {
+    await this.client.delete(
+      `${this.basePath}/rooms/${roomId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * List rooms
+   *
+   * Requires: collab:read permission
+   */
+  async listRooms(params) {
+    return this.client.get(
+      `${this.basePath}/rooms`,
+      { params }
+    );
+  }
+  /**
+   * Get join token for real-time connection
+   *
+   * Requires: collab:join permission
+   */
+  async getJoinToken(roomId, options) {
+    return this.client.post(`${this.basePath}/rooms/${roomId}/token`, options);
+  }
+  // Participants
+  /**
+   * List participants in a room
+   *
+   * Requires: collab:read permission
+   */
+  async listParticipants(roomId, params) {
+    return this.client.get(
+      `${this.basePath}/rooms/${roomId}/participants`,
+      { params }
+    );
+  }
+  /**
+   * Get a participant
+   *
+   * Requires: collab:read permission
+   */
+  async getParticipant(roomId, participantId) {
+    return this.client.get(
+      `${this.basePath}/rooms/${roomId}/participants/${participantId}`
+    );
+  }
+  /**
+   * Update a participant's role
+   *
+   * Requires: collab:manage permission
+   */
+  async updateParticipant(roomId, participantId, updates) {
+    return this.client.patch(
+      `${this.basePath}/rooms/${roomId}/participants/${participantId}`,
+      updates
+    );
+  }
+  /**
+   * Remove a participant from a room
+   *
+   * Requires: collab:manage permission (server-side RBAC enforced)
+   */
+  async removeParticipant(roomId, participantId) {
+    await this.client.delete(
+      `${this.basePath}/rooms/${roomId}/participants/${participantId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Invite users to a room
+   *
+   * Requires: collab:invite permission
+   */
+  async invite(roomId, invites) {
+    return this.client.post(`${this.basePath}/rooms/${roomId}/invite`, { invites });
+  }
+  // Comments
+  /**
+   * Add a comment
+   *
+   * Requires: collab:comment permission
+   */
+  async addComment(roomId, comment) {
+    return this.client.post(
+      `${this.basePath}/rooms/${roomId}/comments`,
+      comment
+    );
+  }
+  /**
+   * List comments
+   *
+   * Requires: collab:read permission
+   */
+  async listComments(roomId, params) {
+    return this.client.get(
+      `${this.basePath}/rooms/${roomId}/comments`,
+      { params }
+    );
+  }
+  /**
+   * Update a comment
+   *
+   * Requires: collab:comment permission (own comments) or collab:manage
+   */
+  async updateComment(roomId, commentId, updates) {
+    return this.client.patch(
+      `${this.basePath}/rooms/${roomId}/comments/${commentId}`,
+      updates
+    );
+  }
+  /**
+   * Remove a comment
+   *
+   * Requires: collab:comment permission (own) or collab:manage (server-side RBAC enforced)
+   */
+  async removeComment(roomId, commentId) {
+    await this.client.delete(
+      `${this.basePath}/rooms/${roomId}/comments/${commentId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Add a reaction to a comment
+   *
+   * Requires: collab:comment permission
+   */
+  async addReaction(roomId, commentId, emoji) {
+    return this.client.post(
+      `${this.basePath}/rooms/${roomId}/comments/${commentId}/reactions`,
+      { emoji }
+    );
+  }
+  /**
+   * Remove a reaction from a comment
+   *
+   * Requires: collab:comment permission (server-side RBAC enforced)
+   */
+  async removeReaction(roomId, commentId, emoji) {
+    await this.client.delete(
+      `${this.basePath}/rooms/${roomId}/comments/${commentId}/reactions`,
+      { method: "DELETE", params: { emoji } }
+    );
+  }
+  // Annotations
+  /**
+   * Add an annotation
+   *
+   * Requires: collab:annotate permission
+   */
+  async addAnnotation(roomId, annotation) {
+    return this.client.post(
+      `${this.basePath}/rooms/${roomId}/annotations`,
+      annotation
+    );
+  }
+  /**
+   * List annotations
+   *
+   * Requires: collab:read permission
+   */
+  async listAnnotations(roomId, params) {
+    return this.client.get(
+      `${this.basePath}/rooms/${roomId}/annotations`,
+      { params }
+    );
+  }
+  /**
+   * Update an annotation
+   *
+   * Requires: collab:annotate permission (own) or collab:manage
+   */
+  async updateAnnotation(roomId, annotationId, updates) {
+    return this.client.patch(
+      `${this.basePath}/rooms/${roomId}/annotations/${annotationId}`,
+      updates
+    );
+  }
+  /**
+   * Remove an annotation
+   *
+   * Requires: collab:annotate permission (own) or collab:manage (server-side RBAC enforced)
+   */
+  async removeAnnotation(roomId, annotationId) {
+    await this.client.delete(
+      `${this.basePath}/rooms/${roomId}/annotations/${annotationId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Clear all annotations
+   *
+   * Requires: collab:manage permission
+   */
+  async clearAnnotations(roomId) {
+    return this.client.post(`${this.basePath}/rooms/${roomId}/annotations/clear`);
+  }
+  // Recording
+  /**
+   * Start recording the collaboration session
+   *
+   * Requires: collab:record permission
+   */
+  async startRecording(roomId) {
+    return this.client.post(`${this.basePath}/rooms/${roomId}/recording/start`);
+  }
+  /**
+   * Stop recording
+   *
+   * Requires: collab:record permission
+   */
+  async stopRecording(roomId) {
+    return this.client.post(`${this.basePath}/rooms/${roomId}/recording/stop`);
+  }
+  /**
+   * Get recording status
+   *
+   * Requires: collab:read permission
+   */
+  async getRecordingStatus(roomId) {
+    return this.client.get(`${this.basePath}/rooms/${roomId}/recording`);
+  }
+};
+function createCollabAPI(client) {
+  return new CollabAPI(client);
+}
+
+export {
+  CollabAPI,
+  createCollabAPI
+};

package/dist/chunk-VLQQDYGP.mjs

@@ -0,0 +1,173 @@
+// src/mesh.ts
+var MeshAPI = class {
+  client;
+  basePath = "/v1/mesh";
+  constructor(client) {
+    this.client = client;
+  }
+  // ==========================================================================
+  // Regions
+  // ==========================================================================
+  /**
+   * List mesh regions with optional filters
+   *
+   * Requires: mesh:read permission
+   */
+  async listRegions(params) {
+    const queryParams = {
+      limit: params?.limit,
+      offset: params?.offset,
+      cursor: params?.cursor,
+      status: params?.status,
+      provider: params?.provider
+    };
+    return this.client.get(`${this.basePath}/regions`, {
+      params: queryParams
+    });
+  }
+  /**
+   * Get a region by ID
+   *
+   * Requires: mesh:read permission
+   */
+  async getRegion(regionId) {
+    return this.client.get(`${this.basePath}/regions/${regionId}`);
+  }
+  /**
+   * Get health details for a region
+   *
+   * Requires: mesh:read permission
+   */
+  async getRegionHealth(regionId) {
+    return this.client.get(`${this.basePath}/regions/${regionId}/health`);
+  }
+  // ==========================================================================
+  // Peers
+  // ==========================================================================
+  /**
+   * List mesh peers, optionally filtered by region
+   *
+   * Requires: mesh:read permission
+   */
+  async listPeers(regionId) {
+    const queryParams = {
+      region_id: regionId
+    };
+    return this.client.get(`${this.basePath}/peers`, {
+      params: queryParams
+    });
+  }
+  /**
+   * Add a peer to a region
+   *
+   * Requires: mesh:create permission
+   */
+  async addPeer(regionId, endpoint) {
+    return this.client.post(`${this.basePath}/peers`, {
+      region_id: regionId,
+      endpoint
+    });
+  }
+  /**
+   * Remove a peer
+   *
+   * Requires: mesh:remove permission (server-side RBAC enforced)
+   */
+  async removePeer(peerId) {
+    await this.client.delete(`${this.basePath}/peers/${peerId}`);
+  }
+  // ==========================================================================
+  // Failover Policies
+  // ==========================================================================
+  /**
+   * Create a failover policy
+   *
+   * Requires: mesh:create permission
+   */
+  async createPolicy(request) {
+    return this.client.post(`${this.basePath}/policies`, request);
+  }
+  /**
+   * Update a failover policy
+   *
+   * Requires: mesh:update permission
+   */
+  async updatePolicy(policyId, updates) {
+    return this.client.patch(`${this.basePath}/policies/${policyId}`, updates);
+  }
+  /**
+   * Remove a failover policy
+   *
+   * Requires: mesh:remove permission (server-side RBAC enforced)
+   */
+  async removePolicy(policyId) {
+    await this.client.delete(`${this.basePath}/policies/${policyId}`);
+  }
+  /**
+   * List failover policies
+   *
+   * Requires: mesh:read permission
+   */
+  async listPolicies(params) {
+    return this.client.get(`${this.basePath}/policies`, {
+      params
+    });
+  }
+  // ==========================================================================
+  // Failover Operations
+  // ==========================================================================
+  /**
+   * Trigger a manual failover to a target region
+   *
+   * Requires: mesh:failover permission
+   */
+  async triggerFailover(policyId, targetRegion) {
+    return this.client.post(`${this.basePath}/policies/${policyId}/failover`, {
+      target_region: targetRegion
+    });
+  }
+  /**
+   * Get failover event history for a policy
+   *
+   * Requires: mesh:read permission
+   */
+  async getFailoverHistory(policyId, params) {
+    return this.client.get(
+      `${this.basePath}/policies/${policyId}/events`,
+      { params }
+    );
+  }
+  // ==========================================================================
+  // Replication & Topology
+  // ==========================================================================
+  /**
+   * Get replication status between regions
+   *
+   * Requires: mesh:read permission
+   */
+  async getReplicationStatus(sourceRegion, targetRegion) {
+    const queryParams = {
+      source_region: sourceRegion,
+      target_region: targetRegion
+    };
+    return this.client.get(`${this.basePath}/replication`, {
+      params: queryParams
+    });
+  }
+  /**
+   * Get the full mesh topology (regions, peers, and policies)
+   *
+   * Requires: mesh:read permission
+   */
+  async getTopology() {
+    return this.client.get(`${this.basePath}/topology`);
+  }
+};
+function createMeshAPI(client) {
+  return new MeshAPI(client);
+}
+
+export {
+  MeshAPI,
+  createMeshAPI
+};

package/dist/chunk-VPKZUXZW.mjs

@@ -0,0 +1,53 @@
+// src/slides.ts
+var SlidesAPI = class {
+  client;
+  basePath = "/v1/slides";
+  constructor(client) {
+    this.client = client;
+  }
+  async convert(request) {
+    return this.client.post(this.basePath, request);
+  }
+  async get(conversionId) {
+    return this.client.get(`${this.basePath}/${conversionId}`);
+  }
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  async remove(conversionId) {
+    await this.client.delete(`${this.basePath}/${conversionId}`);
+  }
+  async getProgress(conversionId) {
+    return this.client.get(
+      `${this.basePath}/${conversionId}/progress`
+    );
+  }
+  async addNarration(conversionId, narrations) {
+    return this.client.post(`${this.basePath}/${conversionId}/narration`, {
+      narrations
+    });
+  }
+  async waitForReady(conversionId, options) {
+    const pollInterval = options?.pollInterval || 3e3;
+    const timeout = options?.timeout || 6e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const conversion = await this.get(conversionId);
+      if (conversion.status === "ready") return conversion;
+      if (conversion.status === "failed")
+        throw new Error(`Conversion failed: ${conversion.error || "Unknown"}`);
+      await new Promise((r) => setTimeout(r, pollInterval));
+    }
+    throw new Error(`Conversion timed out after ${timeout}ms`);
+  }
+};
+function createSlidesAPI(client) {
+  return new SlidesAPI(client);
+}
+
+export {
+  SlidesAPI,
+  createSlidesAPI
+};

package/dist/chunk-WS3PEFYJ.mjs

@@ -0,0 +1,60 @@
+// src/drm.ts
+var DrmAPI = class {
+  client;
+  basePath = "/v1/drm";
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create a DRM policy. */
+  async createPolicy(request) {
+    return this.client.post(`${this.basePath}/policies`, request);
+  }
+  /** Get a DRM policy by ID. */
+  async getPolicy(policyId) {
+    return this.client.get(`${this.basePath}/policies/${policyId}`);
+  }
+  /** List DRM policies. */
+  async listPolicies(params) {
+    return this.client.get(`${this.basePath}/policies`, {
+      params
+    });
+  }
+  /** Update a DRM policy. */
+  async updatePolicy(policyId, updates) {
+    return this.client.patch(`${this.basePath}/policies/${policyId}`, updates);
+  }
+  /** Delete a DRM policy. */
+  async removePolicy(policyId) {
+    await this.client.delete(`${this.basePath}/policies/${policyId}`);
+  }
+  /** Get a DRM certificate for a provider. */
+  async getCertificate(provider) {
+    return this.client.get(`${this.basePath}/certificate/${provider}`);
+  }
+  /** Issue a license for an asset. */
+  async issueLicense(assetId, policyId, deviceId) {
+    return this.client.post(`${this.basePath}/license`, {
+      asset_id: assetId,
+      policy_id: policyId,
+      device_id: deviceId
+    });
+  }
+  /** Revoke a license. */
+  async revokeLicense(licenseId) {
+    return this.client.post(`${this.basePath}/license/${licenseId}/revoke`);
+  }
+  /** List licenses for an asset or user. */
+  async listLicenses(params) {
+    return this.client.get(`${this.basePath}/licenses`, {
+      params
+    });
+  }
+};
+function createDrmAPI(client) {
+  return new DrmAPI(client);
+}
+
+export {
+  DrmAPI,
+  createDrmAPI
+};

package/dist/chunk-XGAYMWRH.mjs

@@ -0,0 +1,74 @@
+// src/pulse.ts
+var PulseAPI = class {
+  client;
+  basePath = "/v1/analytics";
+  constructor(client) {
+    this.client = client;
+  }
+  async getStreamAnalytics(streamId, params) {
+    return this.client.get(`${this.basePath}/streams/${streamId}`, {
+      params
+    });
+  }
+  async getViewerAnalytics(params) {
+    return this.client.get(`${this.basePath}/viewers`, {
+      params
+    });
+  }
+  async getQualityMetrics(params) {
+    return this.client.get(`${this.basePath}/quality`, {
+      params
+    });
+  }
+  async getEngagementMetrics(params) {
+    return this.client.get(`${this.basePath}/engagement`, {
+      params
+    });
+  }
+  async getRevenueMetrics(params) {
+    return this.client.get(`${this.basePath}/revenue`, {
+      params
+    });
+  }
+  async getTimeSeries(metric, params) {
+    return this.client.get(`${this.basePath}/timeseries/${metric}`, {
+      params
+    });
+  }
+  async createReport(request) {
+    return this.client.post(`${this.basePath}/reports`, request);
+  }
+  async getReport(reportId) {
+    return this.client.get(`${this.basePath}/reports/${reportId}`);
+  }
+  async listReports(params) {
+    return this.client.get(`${this.basePath}/reports`, {
+      params
+    });
+  }
+  async listDashboards(params) {
+    return this.client.get(`${this.basePath}/dashboards`, {
+      params
+    });
+  }
+  async createDashboard(request) {
+    return this.client.post(`${this.basePath}/dashboards`, request);
+  }
+  async getDashboard(dashboardId) {
+    return this.client.get(`${this.basePath}/dashboards/${dashboardId}`);
+  }
+  async updateDashboard(dashboardId, updates) {
+    return this.client.patch(`${this.basePath}/dashboards/${dashboardId}`, updates);
+  }
+  async removeDashboard(dashboardId) {
+    await this.client.delete(`${this.basePath}/dashboards/${dashboardId}`);
+  }
+};
+function createPulseAPI(client) {
+  return new PulseAPI(client);
+}
+
+export {
+  PulseAPI,
+  createPulseAPI
+};