@wave-av/sdk 2.0.1 → 2.0.2

package/dist/chunk-M744Z327.mjs

@@ -0,0 +1,244 @@
+// src/phone.ts
+var PhoneAPI = class {
+  client;
+  basePath = "/v1/phone";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List owned phone numbers
+   *
+   * Requires: phone:read permission
+   */
+  async listNumbers(params) {
+    return this.client.get(
+      `${this.basePath}/numbers`,
+      { params }
+    );
+  }
+  /**
+   * Get a phone number by ID
+   *
+   * Requires: phone:read permission
+   */
+  async getNumber(numberId) {
+    return this.client.get(`${this.basePath}/numbers/${numberId}`);
+  }
+  /**
+   * Search for available phone numbers to purchase
+   *
+   * Requires: phone:read permission
+   */
+  async searchAvailableNumbers(request) {
+    return this.client.post(
+      `${this.basePath}/numbers/available`,
+      request
+    );
+  }
+  /**
+   * Purchase a phone number
+   *
+   * Requires: phone:purchase permission
+   */
+  async purchaseNumber(number, options) {
+    return this.client.post(`${this.basePath}/numbers/purchase`, {
+      number,
+      ...options
+    });
+  }
+  /**
+   * Update a phone number
+   *
+   * Requires: phone:update permission
+   */
+  async updateNumber(numberId, updates) {
+    return this.client.patch(
+      `${this.basePath}/numbers/${numberId}`,
+      updates
+    );
+  }
+  /**
+   * Release a phone number
+   *
+   * Requires: phone:release permission (server-side RBAC enforced)
+   */
+  async releaseNumber(numberId) {
+    await this.client.delete(
+      `${this.basePath}/numbers/${numberId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * Make an outbound call
+   *
+   * Requires: phone:call permission
+   */
+  async makeCall(request) {
+    return this.client.post(`${this.basePath}/calls`, request);
+  }
+  /**
+   * Get a call by ID
+   *
+   * Requires: phone:read permission
+   */
+  async getCall(callId) {
+    return this.client.get(`${this.basePath}/calls/${callId}`);
+  }
+  /**
+   * List calls
+   *
+   * Requires: phone:read permission
+   */
+  async listCalls(params) {
+    return this.client.get(
+      `${this.basePath}/calls`,
+      { params }
+    );
+  }
+  /**
+   * Update an active call
+   *
+   * Requires: phone:call permission
+   */
+  async updateCall(callId, updates) {
+    return this.client.patch(`${this.basePath}/calls/${callId}`, updates);
+  }
+  /**
+   * End an active call
+   *
+   * Requires: phone:call permission
+   */
+  async endCall(callId) {
+    return this.updateCall(callId, { status: "completed" });
+  }
+  /**
+   * Get call recording
+   *
+   * Requires: phone:read permission
+   */
+  async getRecording(callId) {
+    return this.client.get(`${this.basePath}/calls/${callId}/recording`);
+  }
+  /**
+   * Wait for call to end
+   */
+  async waitForCallEnd(callId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 36e5;
+    const startTime = Date.now();
+    const terminalStatuses = [
+      "completed",
+      "failed",
+      "busy",
+      "no_answer",
+      "canceled"
+    ];
+    while (Date.now() - startTime < timeout) {
+      const call = await this.getCall(callId);
+      if (options?.onUpdate) {
+        options.onUpdate(call);
+      }
+      if (terminalStatuses.includes(call.status)) {
+        return call;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Call wait timed out after ${timeout}ms`);
+  }
+  /**
+   * Create a conference room
+   *
+   * Requires: phone:conference permission
+   */
+  async createConference(options) {
+    return this.client.post(`${this.basePath}/conferences`, options);
+  }
+  /**
+   * Get a conference by ID
+   *
+   * Requires: phone:read permission
+   */
+  async getConference(conferenceId) {
+    return this.client.get(
+      `${this.basePath}/conferences/${conferenceId}`
+    );
+  }
+  /**
+   * List conferences
+   *
+   * Requires: phone:read permission
+   */
+  async listConferences(params) {
+    return this.client.get(
+      `${this.basePath}/conferences`,
+      { params }
+    );
+  }
+  /**
+   * Add a participant to a conference
+   *
+   * Requires: phone:conference permission
+   */
+  async addConferenceParticipant(conferenceId, options) {
+    return this.client.post(
+      `${this.basePath}/conferences/${conferenceId}/participants`,
+      options
+    );
+  }
+  /**
+   * Update a conference participant
+   *
+   * Requires: phone:conference permission
+   */
+  async updateConferenceParticipant(conferenceId, callId, updates) {
+    return this.client.patch(
+      `${this.basePath}/conferences/${conferenceId}/participants/${callId}`,
+      updates
+    );
+  }
+  /**
+   * Remove a participant from a conference
+   *
+   * Requires: phone:conference permission (server-side RBAC enforced)
+   */
+  async removeConferenceParticipant(conferenceId, callId) {
+    await this.client.delete(
+      `${this.basePath}/conferences/${conferenceId}/participants/${callId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * End a conference
+   *
+   * Requires: phone:conference permission
+   */
+  async endConference(conferenceId) {
+    return this.client.post(
+      `${this.basePath}/conferences/${conferenceId}/end`
+    );
+  }
+  /**
+   * Validate a phone number
+   *
+   * Requires: phone:read permission
+   */
+  async validateNumber(number) {
+    return this.client.post(`${this.basePath}/validate`, { number });
+  }
+  /**
+   * Get supported countries
+   *
+   * Requires: phone:read permission
+   */
+  async getSupportedCountries() {
+    return this.client.get(`${this.basePath}/countries`);
+  }
+};
+function createPhoneAPI(client) {
+  return new PhoneAPI(client);
+}
+
+export {
+  PhoneAPI,
+  createPhoneAPI
+};

package/dist/chunk-MRFDPPFK.mjs

@@ -0,0 +1,61 @@
+// src/zoom.ts
+var ZoomAPI = class {
+  client;
+  basePath = "/v1/zoom";
+  constructor(client) {
+    this.client = client;
+  }
+  async createMeeting(request) {
+    return this.client.post(`${this.basePath}/meetings`, request);
+  }
+  async getMeeting(meetingId) {
+    return this.client.get(`${this.basePath}/meetings/${meetingId}`);
+  }
+  async endMeeting(meetingId) {
+    await this.client.post(`${this.basePath}/meetings/${meetingId}/end`);
+  }
+  async listMeetings(params) {
+    return this.client.get(`${this.basePath}/meetings`, {
+      params
+    });
+  }
+  async listRooms(params) {
+    return this.client.get(`${this.basePath}/rooms`, {
+      params
+    });
+  }
+  async getRoomStatus(roomId) {
+    return this.client.get(`${this.basePath}/rooms/${roomId}`);
+  }
+  async getRecording(recordingId) {
+    return this.client.get(`${this.basePath}/recordings/${recordingId}`);
+  }
+  async listRecordings(meetingId, params) {
+    const path = meetingId ? `${this.basePath}/meetings/${meetingId}/recordings` : `${this.basePath}/recordings`;
+    return this.client.get(path, {
+      params
+    });
+  }
+  async startRTMS(meetingId, config) {
+    return this.client.post(
+      `${this.basePath}/meetings/${meetingId}/rtms/start`,
+      config
+    );
+  }
+  async stopRTMS(meetingId) {
+    return this.client.post(`${this.basePath}/meetings/${meetingId}/rtms/stop`);
+  }
+  async getRTMSStatus(meetingId) {
+    return this.client.get(
+      `${this.basePath}/meetings/${meetingId}/rtms`
+    );
+  }
+};
+function createZoomAPI(client) {
+  return new ZoomAPI(client);
+}
+
+export {
+  ZoomAPI,
+  createZoomAPI
+};

package/dist/chunk-MXU3Q23F.mjs

@@ -0,0 +1,68 @@
+// src/edge.ts
+var EdgeAPI = class {
+  client;
+  basePath = "/v1/edge";
+  constructor(client) {
+    this.client = client;
+  }
+  async listNodes(params) {
+    return this.client.get(`${this.basePath}/nodes`, {
+      params
+    });
+  }
+  async getNode(nodeId) {
+    return this.client.get(`${this.basePath}/nodes/${nodeId}`);
+  }
+  async getNodeMetrics(nodeId) {
+    return this.client.get(`${this.basePath}/nodes/${nodeId}/metrics`);
+  }
+  async deployWorker(request) {
+    return this.client.post(`${this.basePath}/workers`, request);
+  }
+  async getWorker(workerId) {
+    return this.client.get(`${this.basePath}/workers/${workerId}`);
+  }
+  async updateWorker(workerId, config) {
+    return this.client.patch(`${this.basePath}/workers/${workerId}`, config);
+  }
+  async removeWorker(workerId) {
+    await this.client.delete(`${this.basePath}/workers/${workerId}`);
+  }
+  async listWorkers(params) {
+    return this.client.get(`${this.basePath}/workers`, {
+      params
+    });
+  }
+  async startWorker(workerId) {
+    return this.client.post(`${this.basePath}/workers/${workerId}/start`);
+  }
+  async stopWorker(workerId) {
+    return this.client.post(`${this.basePath}/workers/${workerId}/stop`);
+  }
+  async listPops() {
+    return this.client.get(`${this.basePath}/pops`);
+  }
+  async purgeCache(patterns) {
+    return this.client.post(`${this.basePath}/cache/purge`, { patterns });
+  }
+  async getRoutingRules() {
+    return this.client.get(`${this.basePath}/routing`);
+  }
+  async setRoutingRule(rule) {
+    return this.client.post(`${this.basePath}/routing`, rule);
+  }
+  async removeRoutingRule(ruleId) {
+    await this.client.delete(`${this.basePath}/routing/${ruleId}`);
+  }
+  async getLatencyMap() {
+    return this.client.get(`${this.basePath}/latency-map`);
+  }
+};
+function createEdgeAPI(client) {
+  return new EdgeAPI(client);
+}
+
+export {
+  EdgeAPI,
+  createEdgeAPI
+};

package/dist/chunk-NCVUZ746.mjs

@@ -0,0 +1,60 @@
+// src/connect.ts
+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);
+}
+
+export {
+  ConnectAPI,
+  createConnectAPI
+};

package/dist/chunk-NLQVD2LF.mjs

@@ -0,0 +1,210 @@
+// src/sentiment.ts
+var SentimentAPI = class {
+  client;
+  basePath = "/v1/sentiment";
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Create a sentiment analysis job
+   *
+   * Requires: sentiment:analyze permission
+   */
+  async analyze(request) {
+    return this.client.post(this.basePath, request);
+  }
+  /**
+   * Analyze text directly (synchronous for short text)
+   *
+   * Requires: sentiment:analyze permission
+   */
+  async analyzeText(text, options) {
+    return this.client.post(`${this.basePath}/text`, { text, ...options });
+  }
+  /**
+   * Batch analyze multiple items
+   *
+   * Requires: sentiment:analyze permission
+   */
+  async batchAnalyze(request) {
+    return this.client.post(`${this.basePath}/batch`, request);
+  }
+  /**
+   * Get an analysis by ID
+   *
+   * Requires: sentiment:read permission
+   */
+  async get(analysisId) {
+    return this.client.get(`${this.basePath}/${analysisId}`);
+  }
+  /**
+   * Remove an analysis
+   *
+   * Requires: sentiment:remove permission (server-side RBAC enforced)
+   */
+  async remove(analysisId) {
+    await this.client.delete(
+      `${this.basePath}/${analysisId}`,
+      { method: "DELETE" }
+    );
+  }
+  /**
+   * List analyses
+   *
+   * Requires: sentiment:read permission
+   */
+  async list(params) {
+    return this.client.get(this.basePath, {
+      params
+    });
+  }
+  /**
+   * Get sentiment segments
+   *
+   * Requires: sentiment:read permission
+   */
+  async getSegments(analysisId, params) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/segments`,
+      { params }
+    );
+  }
+  /**
+   * Get sentiment summary
+   *
+   * Requires: sentiment:read permission
+   */
+  async getSummary(analysisId) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/summary`
+    );
+  }
+  /**
+   * Get sentiment trend over time
+   *
+   * Requires: sentiment:read permission
+   */
+  async getTrend(analysisId, options) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/trend`,
+      { params: options }
+    );
+  }
+  /**
+   * Get key emotional moments
+   *
+   * Requires: sentiment:read permission
+   */
+  async getKeyMoments(analysisId, options) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/key-moments`,
+      { params: options }
+    );
+  }
+  /**
+   * Get topic sentiments
+   *
+   * Requires: sentiment:read permission
+   */
+  async getTopicSentiments(analysisId, options) {
+    return this.client.get(
+      `${this.basePath}/${analysisId}/topics`,
+      { params: options }
+    );
+  }
+  /**
+   * Get sentiment by speaker
+   *
+   * Requires: sentiment:read permission
+   */
+  async getSpeakerSentiment(analysisId) {
+    return this.client.get(`${this.basePath}/${analysisId}/speakers`);
+  }
+  /**
+   * Start real-time sentiment analysis
+   *
+   * Requires: sentiment:realtime permission
+   */
+  async startRealtime(streamId, options) {
+    return this.client.post(`${this.basePath}/realtime/start`, {
+      stream_id: streamId,
+      ...options
+    });
+  }
+  /**
+   * Stop real-time analysis
+   *
+   * Requires: sentiment:realtime permission
+   */
+  async stopRealtime(sessionId) {
+    return this.client.post(
+      `${this.basePath}/realtime/${sessionId}/stop`
+    );
+  }
+  /**
+   * Get real-time session status
+   *
+   * Requires: sentiment:read permission
+   */
+  async getRealtimeStatus(sessionId) {
+    return this.client.get(`${this.basePath}/realtime/${sessionId}`);
+  }
+  /**
+   * Compare sentiment between analyses
+   *
+   * Requires: sentiment:read permission
+   */
+  async compare(analysisIds) {
+    return this.client.post(`${this.basePath}/compare`, {
+      analysis_ids: analysisIds
+    });
+  }
+  /**
+   * Export analysis results
+   *
+   * Requires: sentiment:read permission
+   */
+  async exportAnalysis(analysisId, format) {
+    return this.client.post(`${this.basePath}/${analysisId}/export`, { format });
+  }
+  /**
+   * Wait for analysis to complete
+   */
+  async waitForReady(analysisId, options) {
+    const pollInterval = options?.pollInterval || 2e3;
+    const timeout = options?.timeout || 6e5;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const analysis = await this.get(analysisId);
+      if (options?.onProgress) {
+        options.onProgress(analysis);
+      }
+      if (analysis.status === "ready") {
+        return analysis;
+      }
+      if (analysis.status === "failed") {
+        throw new Error(
+          `Sentiment analysis failed: ${analysis.error || "Unknown error"}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Sentiment analysis timed out after ${timeout}ms`);
+  }
+  /**
+   * Get supported languages
+   *
+   * Requires: sentiment:read permission
+   */
+  async getSupportedLanguages() {
+    return this.client.get(`${this.basePath}/languages`);
+  }
+};
+function createSentimentAPI(client) {
+  return new SentimentAPI(client);
+}
+
+export {
+  SentimentAPI,
+  createSentimentAPI
+};