@wave-av/sdk 2.0.1 → 2.0.2

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

package/dist/collab-types.mjs

@@ -0,0 +1 @@
+import "./chunk-YLCQKCZL.mjs";

package/dist/collab.js

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

package/dist/collab.mjs

@@ -0,0 +1,10 @@
+import {
+  CollabAPI,
+  createCollabAPI
+} from "./chunk-V5DWA5P4.mjs";
+import "./chunk-YLCQKCZL.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  CollabAPI,
+  createCollabAPI
+};

package/dist/connect.js

@@ -0,0 +1,85 @@
+"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/connect.ts
+var connect_exports = {};
+__export(connect_exports, {
+  ConnectAPI: () => ConnectAPI,
+  createConnectAPI: () => createConnectAPI
+});
+module.exports = __toCommonJS(connect_exports);
+var ConnectAPI = class {
+  client;
+  basePath = "/v1/integrations";
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  async get(integrationId) {
+    return this.client.get(`${this.basePath}/${integrationId}`);
+  }
+  async enable(request) {
+    return this.client.post(this.basePath, request);
+  }
+  async disable(integrationId) {
+    await this.client.post(`${this.basePath}/${integrationId}/disable`);
+  }
+  async configure(integrationId, config) {
+    return this.client.patch(`${this.basePath}/${integrationId}`, { config });
+  }
+  async testConnection(integrationId) {
+    return this.client.post(
+      `${this.basePath}/${integrationId}/test`
+    );
+  }
+  async listWebhooks(integrationId) {
+    const path = integrationId ? `${this.basePath}/${integrationId}/webhooks` : "/v1/webhooks";
+    return this.client.get(path);
+  }
+  async createWebhook(integrationId, request) {
+    return this.client.post(`${this.basePath}/${integrationId}/webhooks`, request);
+  }
+  async updateWebhook(webhookId, updates) {
+    return this.client.patch(`/v1/webhooks/${webhookId}`, updates);
+  }
+  async removeWebhook(webhookId) {
+    await this.client.delete(`/v1/webhooks/${webhookId}`);
+  }
+  async listDeliveries(webhookId, params) {
+    return this.client.get(
+      `/v1/webhooks/${webhookId}/deliveries`,
+      { params }
+    );
+  }
+  async retryDelivery(deliveryId) {
+    return this.client.post(`/v1/webhooks/deliveries/${deliveryId}/retry`);
+  }
+};
+function createConnectAPI(client) {
+  return new ConnectAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConnectAPI,
+  createConnectAPI
+});

package/dist/connect.mjs

@@ -0,0 +1,9 @@
+import {
+  ConnectAPI,
+  createConnectAPI
+} from "./chunk-NCVUZ746.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  ConnectAPI,
+  createConnectAPI
+};

package/dist/creator.js

@@ -0,0 +1,79 @@
+"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/creator.ts
+var creator_exports = {};
+__export(creator_exports, {
+  CreatorAPI: () => CreatorAPI,
+  createCreatorAPI: () => createCreatorAPI
+});
+module.exports = __toCommonJS(creator_exports);
+var CreatorAPI = class {
+  client;
+  basePath = "/v1/creators";
+  constructor(client) {
+    this.client = client;
+  }
+  async getProfile(creatorId) {
+    return this.client.get(`${this.basePath}/${creatorId}`);
+  }
+  async updateProfile(creatorId, request) {
+    return this.client.patch(`${this.basePath}/${creatorId}`, request);
+  }
+  async getRevenue(creatorId, params) {
+    return this.client.get(`${this.basePath}/${creatorId}/revenue`, {
+      params
+    });
+  }
+  async listSubscriptions(creatorId, params) {
+    return this.client.get(
+      `${this.basePath}/${creatorId}/subscriptions`,
+      { params }
+    );
+  }
+  async listTips(creatorId, params) {
+    return this.client.get(`${this.basePath}/${creatorId}/tips`, {
+      params
+    });
+  }
+  async createTipJar(creatorId, config) {
+    return this.client.post(`${this.basePath}/${creatorId}/tip-jar`, config);
+  }
+  async listPayouts(creatorId, params) {
+    return this.client.get(`${this.basePath}/${creatorId}/payouts`, {
+      params
+    });
+  }
+  async requestPayout(creatorId, request) {
+    return this.client.post(`${this.basePath}/${creatorId}/payouts`, request);
+  }
+  async getAnalytics(creatorId, params) {
+    return this.client.get(`${this.basePath}/${creatorId}/analytics`, {
+      params
+    });
+  }
+};
+function createCreatorAPI(client) {
+  return new CreatorAPI(client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreatorAPI,
+  createCreatorAPI
+});

package/dist/creator.mjs

@@ -0,0 +1,9 @@
+import {
+  CreatorAPI,
+  createCreatorAPI
+} from "./chunk-LVOVF6XC.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  CreatorAPI,
+  createCreatorAPI
+};

package/dist/desktop.js

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

package/dist/desktop.mjs

@@ -0,0 +1,9 @@
+import {
+  DesktopAPI,
+  createDesktopAPI
+} from "./chunk-4DG4OBRD.mjs";
+import "./chunk-Y6FXYEAI.mjs";
+export {
+  DesktopAPI,
+  createDesktopAPI
+};

package/dist/distribution.js

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