@unboundcx/sdk 2.8.2 → 2.8.4

package/base.js

@@ -195,6 +195,7 @@ export class BaseSDK {
     params.headers = headers;
 
     // Try transport plugins first
+    console.log(`sdk :: request :: forceFetch:${forceFetch} :: endpoint:${endpoint}`);
     const transport = await this._getAvailableTransport(forceFetch);
     let response;
     if (transport) {
@@ -224,6 +225,9 @@ export class BaseSDK {
       }
     } else {
       // No transport available, fallback to HTTP
+      if (forceFetch && process.env.AUTH_V3_TOKEN_TYPE_OVERRIDE) {
+        params.headers['x-token-type-override'] = process.env.AUTH_V3_TOKEN_TYPE_OVERRIDE;
+      }
       return this._httpRequest(endpoint, method, params, returnRawResponse);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "Official JavaScript SDK for the Unbound API - A comprehensive toolkit for integrating with Unbound's communication, AI, and data management services",
   "main": "index.js",
   "type": "module",

package/services/login.js

@@ -51,13 +51,14 @@ export class LoginService {
     return true;
   }
 
-  async validate() {
+  async validate(forceFetch = true) {
+    console.log('login :: validate :: forceFetch', forceFetch);
     const options = {};
     const validation = await this.sdk._fetch(
       '/login/validate',
       'POST',
       options,
-      true,
+      forceFetch,
     );
     return validation;
   }

package/services/storage.js

@@ -410,7 +410,7 @@ export class StorageService {
       },
     );
 
-    const params = {};
+    const params = { returnRawResponse: true };
     if (download) {
       params.query = { download: 'true' };
     }
@@ -420,7 +420,7 @@ export class StorageService {
       url += `/storage/${path.startsWith('/') ? path.slice(1) : path}`;
     }
 
-    const result = await this.sdk._fetch(url, 'GET', params);
+    const result = await this.sdk._fetch(url, 'GET', params, true);
     return result;
   }
 

package/services/video.js

@@ -28,6 +28,7 @@ export class VideoService {
 
     const params = {
       body: {
+        room,
         password,
         email,
         name,
@@ -43,6 +44,56 @@ export class VideoService {
     return result;
   }
 
+  async joinRoomSip({
+    room,
+    password,
+    phoneNumber,
+    engagementSessionId,
+    voiceChannelId,
+    serverId,
+    meetingJoinType = 'outboundApi',
+  }) {
+    this.sdk.validateParams(
+      {
+        room,
+        password,
+        phoneNumber,
+        engagementSessionId,
+        voiceChannelId,
+        serverId,
+        meetingJoinType,
+      },
+      {
+        room: { type: 'string', required: true },
+        password: { type: 'string', required: false },
+        phoneNumber: { type: 'string', required: true },
+        engagementSessionId: { type: 'string', required: false },
+        voiceChannelId: { type: 'string', required: true },
+        serverId: { type: 'string', required: true },
+        meetingJoinType: { type: 'string', required: true },
+      },
+    );
+
+    const params = {
+      body: {
+        room,
+        password,
+        phoneNumber,
+        engagementSessionId,
+        voiceChannelId,
+        serverId,
+        meetingJoinType,
+        isSip: true,
+      },
+    };
+    const result = await this.sdk._fetch(
+      `/video/${room}/join`,
+      'POST',
+      params,
+      true,
+    );
+    return result;
+  }
   async updateParticipant(roomId, participantId, update) {
     this.sdk.validateParams(
       { roomId, participantId, update },
@@ -141,6 +192,7 @@ export class VideoService {
     password,
     startTime,
     endTime,
+    isAllDay,
     duration,
     durationUnit,
     timezone,
@@ -151,6 +203,7 @@ export class VideoService {
     startCameraMutedAfter,
     startMicrophoneMuted,
     startMicrophoneMutedAfter,
+    enableChat,
     engagementSessionId,
   }) {
     this.sdk.validateParams(
@@ -159,6 +212,7 @@ export class VideoService {
         password,
         startTime,
         endTime,
+        isAllDay,
         duration,
         durationUnit,
         timezone,
@@ -169,6 +223,7 @@ export class VideoService {
         startCameraMutedAfter,
         startMicrophoneMuted,
         startMicrophoneMutedAfter,
+        enableChat,
         engagementSessionId,
       },
       {
@@ -176,6 +231,7 @@ export class VideoService {
         password: { type: 'string', required: false },
         startTime: { type: 'string', required: false },
         endTime: { type: 'string', required: false },
+        isAllDay: { type: 'boolean', required: false },
         duration: { type: 'number', required: false },
         durationUnit: { type: 'string', required: false },
         timezone: { type: 'string', required: false },
@@ -186,6 +242,7 @@ export class VideoService {
         startCameraMutedAfter: { type: 'number', required: false },
         startMicrophoneMuted: { type: 'boolean', required: false },
         startMicrophoneMutedAfter: { type: 'number', required: false },
+        enableChat: { type: 'boolean', required: false },
         engagementSessionId: { type: 'string', required: false },
       },
     );
@@ -195,6 +252,7 @@ export class VideoService {
         password,
         startTime,
         endTime,
+        isAllDay,
         duration,
         durationUnit,
         timezone,
@@ -205,6 +263,7 @@ export class VideoService {
         startCameraMutedAfter,
         startMicrophoneMuted,
         startMicrophoneMutedAfter,
+        enableChat,
         engagementSessionId,
       },
     };
@@ -241,6 +300,8 @@ export class VideoService {
       validationSchema.startMicrophoneMuted = { type: 'boolean' };
     if ('startMicrophoneMutedAfter' in update)
       validationSchema.startMicrophoneMutedAfter = { type: 'number' };
+    if ('enableChat' in update)
+      validationSchema.enableChat = { type: 'boolean' };
 
     if (Object.keys(validationSchema).length > 0) {
       this.sdk.validateParams(update, validationSchema);
@@ -255,6 +316,28 @@ export class VideoService {
     return result;
   }
 
+  async updateRoomBot(roomId, { isRecording, isTranscribing }) {
+    this.sdk.validateParams(
+      { roomId, isRecording, isTranscribing },
+      {
+        roomId: { type: 'string', required: true },
+        isRecording: { type: 'boolean', required: false },
+        isTranscribing: { type: 'boolean', required: false },
+      },
+    );
+    const update = {
+      isRecording,
+      isTranscribing,
+    };
+    const params = {
+      body: {
+        ...update,
+      },
+    };
+    const result = await this.sdk._fetch(`/video/${roomId}/bot`, 'PUT', params);
+    return result;
+  }
+
   async placeCall(roomId, phoneNumber, callerIdNumber) {
     this.sdk.validateParams(
       { roomId, phoneNumber, callerIdNumber },
@@ -472,4 +555,149 @@ export class VideoService {
     const result = await this.sdk._fetch('/video/survey', 'POST', params);
     return result;
   }
+
+  /**
+   * Post a chat message to a video room
+   * @param {string} roomId - The video room ID
+   * @param {Array} content - Message content as JSON array (TipTap format)
+   * @param {string} [storageId] - Optional storage ID for attachments
+   * @returns {Promise} Created feed message
+   */
+  async postChatMessage(roomId, content, storageId = null) {
+    this.sdk.validateParams(
+      { roomId, content },
+      {
+        roomId: { type: 'string', required: true },
+        content: { type: 'array', required: true },
+      },
+    );
+
+    const body = {
+      content,
+    };
+
+    if (storageId) {
+      body.storageId = storageId;
+    }
+
+    const params = { body };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/chat`,
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Get chat messages from a video room
+   * @param {string} roomId - The video room ID
+   * @param {Object} [options={}] - Query options
+   * @param {string} [options.select] - Fields to select
+   * @param {number} [options.limit] - Limit number of results
+   * @param {string} [options.nextId] - Cursor for next page
+   * @param {string} [options.previousId] - Cursor for previous page
+   * @param {string} [options.orderByDirection] - 'ASC' or 'DESC'
+   * @param {boolean} [options.expandDetails] - Whether to expand details
+   * @returns {Promise} Chat messages with participant info
+   */
+  async getChatMessages(roomId, options = {}) {
+    this.sdk.validateParams(
+      { roomId },
+      {
+        roomId: { type: 'string', required: true },
+      },
+    );
+
+    // Validate optional parameters
+    const validationSchema = {};
+    if ('select' in options) validationSchema.select = { type: 'string' };
+    if ('limit' in options) validationSchema.limit = { type: 'number' };
+    if ('nextId' in options) validationSchema.nextId = { type: 'string' };
+    if ('previousId' in options)
+      validationSchema.previousId = { type: 'string' };
+    if ('orderByDirection' in options)
+      validationSchema.orderByDirection = { type: 'string' };
+    if ('expandDetails' in options)
+      validationSchema.expandDetails = { type: 'boolean' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(options, validationSchema);
+    }
+
+    const params = {
+      query: options,
+    };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/chat`,
+      'GET',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Edit a chat message in a video room
+   * Only the participant who created the message can edit it
+   * @param {string} roomId - The video room ID
+   * @param {string} messageId - The message ID to edit
+   * @param {Array} content - Updated message content as JSON array (TipTap format)
+   * @param {string} [storageId] - Optional storage ID for attachments
+   * @returns {Promise} Updated feed message
+   */
+  async editChatMessage(roomId, messageId, content, storageId = null) {
+    this.sdk.validateParams(
+      { roomId, messageId, content },
+      {
+        roomId: { type: 'string', required: true },
+        messageId: { type: 'string', required: true },
+        content: { type: 'array', required: true },
+      },
+    );
+
+    const body = {
+      content,
+    };
+
+    if (storageId) {
+      body.storageId = storageId;
+    }
+
+    const params = { body };
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/chat/${messageId}`,
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Delete a chat message from a video room
+   * Hosts can delete any message, participants can only delete their own
+   * @param {string} roomId - The video room ID
+   * @param {string} messageId - The message ID to delete
+   * @returns {Promise} Deletion result
+   */
+  async deleteChatMessage(roomId, messageId) {
+    this.sdk.validateParams(
+      { roomId, messageId },
+      {
+        roomId: { type: 'string', required: true },
+        messageId: { type: 'string', required: true },
+      },
+    );
+
+    const params = {};
+
+    const result = await this.sdk._fetch(
+      `/video/${roomId}/chat/${messageId}`,
+      'DELETE',
+      params,
+    );
+    return result;
+  }
 }

package/services/voice.js

@@ -3,101 +3,48 @@ export class VoiceService {
     this.sdk = sdk;
   }
 
-  async createCall({
+  async call({
     to,
     from,
-    connectionId,
-    callerId,
+    callerIdName,
+    callerIdNumber,
     timeout,
-    machineDetection,
-    machineDetectionTimeout,
-    recordingChannels,
-    record,
-    recordingFormat,
-    recordingTrack,
-    recordingMaxLength,
-    transcribe,
-    transcribeLanguage,
-    webhookUrl,
-    commandId,
-    clientState,
-    customHeaders,
-    sipAuthUsername,
-    sipAuthPassword,
-    sipTransport,
-    sipHeaders,
-    ringTimeout,
-    answeringMachineDetection,
-    detectWordOrPhrase,
-    billingGroupId,
-    answerUrl,
-    answerMethod,
+    confirmAnswer,
+    app,
+    variables,
+    engagementSessionId,
+    voiceChannelId,
+    serverId,
   }) {
     this.sdk.validateParams(
-      { to },
+      {},
       {
-        to: { type: 'string', required: true },
+        to: { type: 'string', required: false },
         from: { type: 'string', required: false },
-        connectionId: { type: 'string', required: false },
-        callerId: { type: 'string', required: false },
+        callerIdName: { type: 'string', required: false },
+        callerIdNumber: { type: 'string', required: false },
         timeout: { type: 'number', required: false },
-        machineDetection: { type: 'boolean', required: false },
-        machineDetectionTimeout: { type: 'number', required: false },
-        recordingChannels: { type: 'string', required: false },
-        record: { type: 'boolean', required: false },
-        recordingFormat: { type: 'string', required: false },
-        recordingTrack: { type: 'string', required: false },
-        recordingMaxLength: { type: 'number', required: false },
-        transcribe: { type: 'boolean', required: false },
-        transcribeLanguage: { type: 'string', required: false },
-        webhookUrl: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
-        clientState: { type: 'string', required: false },
-        customHeaders: { type: 'array', required: false },
-        sipAuthUsername: { type: 'string', required: false },
-        sipAuthPassword: { type: 'string', required: false },
-        sipTransport: { type: 'string', required: false },
-        sipHeaders: { type: 'array', required: false },
-        ringTimeout: { type: 'number', required: false },
-        answeringMachineDetection: { type: 'string', required: false },
-        detectWordOrPhrase: { type: 'string', required: false },
-        billingGroupId: { type: 'string', required: false },
-        answerUrl: { type: 'string', required: false },
-        answerMethod: { type: 'string', required: false },
+        confirmAnswer: { type: 'boolean', required: false },
+        app: { type: 'object', required: false },
+        variables: { type: 'object', required: false },
+        engagementSessionId: { type: 'string', required: false },
+        voiceChannelId: { type: 'string', required: false },
+        serverId: { type: 'string', required: false },
       },
     );
 
-    const callData = { to };
+    const callData = {};
+    if (to) callData.to = to;
     if (from) callData.from = from;
-    if (connectionId) callData.connectionId = connectionId;
-    if (callerId) callData.callerId = callerId;
-    if (timeout) callData.timeout = timeout;
-    if (machineDetection !== undefined)
-      callData.machineDetection = machineDetection;
-    if (machineDetectionTimeout)
-      callData.machineDetectionTimeout = machineDetectionTimeout;
-    if (recordingChannels) callData.recordingChannels = recordingChannels;
-    if (record !== undefined) callData.record = record;
-    if (recordingFormat) callData.recordingFormat = recordingFormat;
-    if (recordingTrack) callData.recordingTrack = recordingTrack;
-    if (recordingMaxLength) callData.recordingMaxLength = recordingMaxLength;
-    if (transcribe !== undefined) callData.transcribe = transcribe;
-    if (transcribeLanguage) callData.transcribeLanguage = transcribeLanguage;
-    if (webhookUrl) callData.webhookUrl = webhookUrl;
-    if (commandId) callData.commandId = commandId;
-    if (clientState) callData.clientState = clientState;
-    if (customHeaders) callData.customHeaders = customHeaders;
-    if (sipAuthUsername) callData.sipAuthUsername = sipAuthUsername;
-    if (sipAuthPassword) callData.sipAuthPassword = sipAuthPassword;
-    if (sipTransport) callData.sipTransport = sipTransport;
-    if (sipHeaders) callData.sipHeaders = sipHeaders;
-    if (ringTimeout) callData.ringTimeout = ringTimeout;
-    if (answeringMachineDetection)
-      callData.answeringMachineDetection = answeringMachineDetection;
-    if (detectWordOrPhrase) callData.detectWordOrPhrase = detectWordOrPhrase;
-    if (billingGroupId) callData.billingGroupId = billingGroupId;
-    if (answerUrl) callData.answerUrl = answerUrl;
-    if (answerMethod) callData.answerMethod = answerMethod;
+    if (callerIdName) callData.callerIdName = callerIdName;
+    if (callerIdNumber) callData.callerIdNumber = callerIdNumber;
+    if (timeout !== undefined) callData.timeout = timeout;
+    if (confirmAnswer !== undefined) callData.confirmAnswer = confirmAnswer;
+    if (app) callData.app = app;
+    if (variables) callData.variables = variables;
+    if (engagementSessionId) callData.engagementSessionId = engagementSessionId;
+    if (voiceChannelId) callData.voiceChannelId = voiceChannelId;
+    if (serverId) callData.serverId = serverId;
 
     const params = {
       body: callData,
@@ -107,462 +54,209 @@ export class VoiceService {
     return result;
   }
 
-  async hangup(callControlId, clientState, commandId) {
+  async hangup(voiceChannelId) {
     this.sdk.validateParams(
-      { callControlId },
+      { voiceChannelId },
       {
-        callControlId: { type: 'string', required: true },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
+        voiceChannelId: { type: 'string', required: true },
       },
     );
 
-    const hangupData = {};
-    if (clientState) hangupData.clientState = clientState;
-    if (commandId) hangupData.commandId = commandId;
-
-    const params = {
-      body: hangupData,
-    };
-
     const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/hangup`,
-      'POST',
-      params,
+      `/voice/calls/${voiceChannelId}`,
+      'DELETE',
     );
     return result;
   }
 
-  async hold(callControlId, audioUrl, clientState, commandId) {
+  async hold(channels) {
     this.sdk.validateParams(
-      { callControlId },
+      { channels },
       {
-        callControlId: { type: 'string', required: true },
-        audioUrl: { type: 'string', required: false },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
+        channels: { type: 'array', required: true },
       },
     );
 
-    const holdData = {};
-    if (audioUrl) holdData.audioUrl = audioUrl;
-    if (clientState) holdData.clientState = clientState;
-    if (commandId) holdData.commandId = commandId;
-
     const params = {
-      body: holdData,
+      body: { channels },
     };
 
-    const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/hold`,
-      'POST',
-      params,
-    );
+    const result = await this.sdk._fetch('/voice/calls/hold', 'PUT', params);
     return result;
   }
 
-  async unhold(callControlId, clientState, commandId) {
+  async mute(voiceChannelId, action = 'mute', direction = 'in') {
     this.sdk.validateParams(
-      { callControlId },
+      { voiceChannelId },
       {
-        callControlId: { type: 'string', required: true },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
+        voiceChannelId: { type: 'string', required: true },
+        action: { type: 'string', required: false },
+        direction: { type: 'string', required: false },
       },
     );
 
-    const unholdData = {};
-    if (clientState) unholdData.clientState = clientState;
-    if (commandId) unholdData.commandId = commandId;
-
     const params = {
-      body: unholdData,
+      body: { action, direction },
     };
 
     const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/unhold`,
-      'POST',
+      `/voice/calls/mute/${voiceChannelId}`,
+      'PUT',
       params,
     );
     return result;
   }
 
-  async mute(callControlId, clientState, commandId) {
-    this.sdk.validateParams(
-      { callControlId },
-      {
-        callControlId: { type: 'string', required: true },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
-      },
-    );
-
-    const muteData = {};
-    if (clientState) muteData.clientState = clientState;
-    if (commandId) muteData.commandId = commandId;
-
-    const params = {
-      body: muteData,
-    };
-
-    const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/mute`,
-      'POST',
-      params,
-    );
-    return result;
+  async unmute(voiceChannelId, direction = 'in') {
+    return this.mute(voiceChannelId, 'unmute', direction);
   }
 
-  async unmute(callControlId, clientState, commandId) {
+  async sendDtmf(voiceChannelId, dtmf) {
     this.sdk.validateParams(
-      { callControlId },
+      { voiceChannelId, dtmf },
       {
-        callControlId: { type: 'string', required: true },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
-      },
-    );
-
-    const unmuteData = {};
-    if (clientState) unmuteData.clientState = clientState;
-    if (commandId) unmuteData.commandId = commandId;
-
-    const params = {
-      body: unmuteData,
-    };
-
-    const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/unmute`,
-      'POST',
-      params,
-    );
-    return result;
-  }
-
-  async sendDtmf(callControlId, dtmf, clientState, commandId) {
-    this.sdk.validateParams(
-      { callControlId, dtmf },
-      {
-        callControlId: { type: 'string', required: true },
+        voiceChannelId: { type: 'string', required: true },
         dtmf: { type: 'string', required: true },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
       },
     );
 
-    const dtmfData = { dtmf };
-    if (clientState) dtmfData.clientState = clientState;
-    if (commandId) dtmfData.commandId = commandId;
-
     const params = {
-      body: dtmfData,
+      body: { dtmf },
     };
 
     const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/send_dtmf`,
+      `/voice/calls/dtmf/${voiceChannelId}`,
       'POST',
       params,
     );
     return result;
   }
 
-  async record(
-    callControlId,
-    recordingChannels,
-    recordingFormat,
-    recordingMaxLength,
-    recordingTerminators,
-    recordingBeep,
-    recordingPlayBeep,
-    clientState,
-    commandId,
-  ) {
+  async record(voiceChannelId, action = 'start', direction = 'both') {
     this.sdk.validateParams(
-      { callControlId },
+      { voiceChannelId },
       {
-        callControlId: { type: 'string', required: true },
-        recordingChannels: { type: 'string', required: false },
-        recordingFormat: { type: 'string', required: false },
-        recordingMaxLength: { type: 'number', required: false },
-        recordingTerminators: { type: 'string', required: false },
-        recordingBeep: { type: 'boolean', required: false },
-        recordingPlayBeep: { type: 'boolean', required: false },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
+        voiceChannelId: { type: 'string', required: true },
+        action: { type: 'string', required: false },
+        direction: { type: 'string', required: false },
       },
     );
 
-    const recordData = {};
-    if (recordingChannels) recordData.recordingChannels = recordingChannels;
-    if (recordingFormat) recordData.recordingFormat = recordingFormat;
-    if (recordingMaxLength) recordData.recordingMaxLength = recordingMaxLength;
-    if (recordingTerminators)
-      recordData.recordingTerminators = recordingTerminators;
-    if (recordingBeep !== undefined) recordData.recordingBeep = recordingBeep;
-    if (recordingPlayBeep !== undefined)
-      recordData.recordingPlayBeep = recordingPlayBeep;
-    if (clientState) recordData.clientState = clientState;
-    if (commandId) recordData.commandId = commandId;
-
     const params = {
-      body: recordData,
+      body: { action, direction },
     };
 
     const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/record_start`,
+      `/voice/calls/record/${voiceChannelId}`,
       'POST',
       params,
     );
     return result;
   }
 
-  async stopRecording(callControlId, clientState, commandId) {
-    this.sdk.validateParams(
-      { callControlId },
-      {
-        callControlId: { type: 'string', required: true },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
-      },
-    );
-
-    const stopData = {};
-    if (clientState) stopData.clientState = clientState;
-    if (commandId) stopData.commandId = commandId;
+  async stopRecording(voiceChannelId, direction = 'both') {
+    return this.record(voiceChannelId, 'stop', direction);
+  }
 
-    const params = {
-      body: stopData,
-    };
+  async pauseRecording(voiceChannelId, direction = 'both') {
+    return this.record(voiceChannelId, 'pause', direction);
+  }
 
-    const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/record_stop`,
-      'POST',
-      params,
-    );
-    return result;
+  async resumeRecording(voiceChannelId, direction = 'both') {
+    return this.record(voiceChannelId, 'resume', direction);
   }
 
   async transcribe(
-    callControlId,
-    transcriptionEngine,
-    transcriptionLanguage,
-    transcriptionFormat,
-    clientState,
-    commandId,
+    voiceChannelId,
+    action = 'start',
+    direction = 'in',
+    forwardText,
+    forwardRtp,
   ) {
     this.sdk.validateParams(
-      { callControlId },
+      { voiceChannelId },
       {
-        callControlId: { type: 'string', required: true },
-        transcriptionEngine: { type: 'string', required: false },
-        transcriptionLanguage: { type: 'string', required: false },
-        transcriptionFormat: { type: 'string', required: false },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
+        voiceChannelId: { type: 'string', required: true },
+        action: { type: 'string', required: false },
+        direction: { type: 'string', required: false },
+        forwardText: { type: 'object', required: false },
+        forwardRtp: { type: 'object', required: false },
       },
     );
 
-    const transcribeData = {};
-    if (transcriptionEngine)
-      transcribeData.transcriptionEngine = transcriptionEngine;
-    if (transcriptionLanguage)
-      transcribeData.transcriptionLanguage = transcriptionLanguage;
-    if (transcriptionFormat)
-      transcribeData.transcriptionFormat = transcriptionFormat;
-    if (clientState) transcribeData.clientState = clientState;
-    if (commandId) transcribeData.commandId = commandId;
+    const bodyData = { action, direction };
+    if (forwardText) bodyData.forwardText = forwardText;
+    if (forwardRtp) bodyData.forwardRtp = forwardRtp;
 
     const params = {
-      body: transcribeData,
+      body: bodyData,
     };
 
     const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/transcription_start`,
+      `/voice/calls/transcribe/${voiceChannelId}`,
       'POST',
       params,
     );
     return result;
   }
 
-  async stopTranscribing(callControlId, clientState, commandId) {
-    this.sdk.validateParams(
-      { callControlId },
-      {
-        callControlId: { type: 'string', required: true },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
-      },
-    );
-
-    const stopData = {};
-    if (clientState) stopData.clientState = clientState;
-    if (commandId) stopData.commandId = commandId;
-
-    const params = {
-      body: stopData,
-    };
-
-    const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/transcription_stop`,
-      'POST',
-      params,
-    );
-    return result;
+  async stopTranscribing(voiceChannelId, direction = 'in') {
+    return this.transcribe(voiceChannelId, 'stop', direction);
   }
 
-  async transfer(
-    callControlId,
+  async transfer({
+    channels,
     to,
-    from,
-    answerUrl,
-    answerMethod,
-    clientState,
-    commandId,
-  ) {
-    this.sdk.validateParams(
-      { callControlId, to },
-      {
-        callControlId: { type: 'string', required: true },
-        to: { type: 'string', required: true },
-        from: { type: 'string', required: false },
-        answerUrl: { type: 'string', required: false },
-        answerMethod: { type: 'string', required: false },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
-      },
-    );
-
-    const transferData = { to };
-    if (from) transferData.from = from;
-    if (answerUrl) transferData.answerUrl = answerUrl;
-    if (answerMethod) transferData.answerMethod = answerMethod;
-    if (clientState) transferData.clientState = clientState;
-    if (commandId) transferData.commandId = commandId;
-
-    const params = {
-      body: transferData,
-    };
-
-    const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/transfer`,
-      'POST',
-      params,
-    );
-    return result;
-  }
-
-  async createConference({
-    name,
-    recordingChannels,
-    recordingFormat,
-    recordingMaxLength,
-    recordingTerminators,
-    webhookUrl,
-    commandId,
-    clientState,
+    callerIdName,
+    callerIdNumber,
+    timeout,
+    voiceApp,
   }) {
     this.sdk.validateParams(
-      { name },
+      { channels },
       {
-        name: { type: 'string', required: true },
-        recordingChannels: { type: 'string', required: false },
-        recordingFormat: { type: 'string', required: false },
-        recordingMaxLength: { type: 'number', required: false },
-        recordingTerminators: { type: 'string', required: false },
-        webhookUrl: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
-        clientState: { type: 'string', required: false },
-      },
-    );
-
-    const conferenceData = { name };
-    if (recordingChannels) conferenceData.recordingChannels = recordingChannels;
-    if (recordingFormat) conferenceData.recordingFormat = recordingFormat;
-    if (recordingMaxLength)
-      conferenceData.recordingMaxLength = recordingMaxLength;
-    if (recordingTerminators)
-      conferenceData.recordingTerminators = recordingTerminators;
-    if (webhookUrl) conferenceData.webhookUrl = webhookUrl;
-    if (commandId) conferenceData.commandId = commandId;
-    if (clientState) conferenceData.clientState = clientState;
-
-    const params = {
-      body: conferenceData,
-    };
-
-    const result = await this.sdk._fetch('/voice/conferences', 'POST', params);
-    return result;
-  }
-
-  async joinConference(
-    callControlId,
-    conferenceId,
-    startConferenceOnEnter,
-    endConferenceOnExit,
-    muted,
-    hold,
-    holdAudioUrl,
-    clientState,
-    commandId,
-  ) {
-    this.sdk.validateParams(
-      { callControlId, conferenceId },
-      {
-        callControlId: { type: 'string', required: true },
-        conferenceId: { type: 'string', required: true },
-        startConferenceOnEnter: { type: 'boolean', required: false },
-        endConferenceOnExit: { type: 'boolean', required: false },
-        muted: { type: 'boolean', required: false },
-        hold: { type: 'boolean', required: false },
-        holdAudioUrl: { type: 'string', required: false },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
+        channels: { type: 'array', required: true },
+        to: { type: 'string', required: false },
+        callerIdName: { type: 'string', required: false },
+        callerIdNumber: { type: 'string', required: false },
+        timeout: { type: 'number', required: false },
+        voiceApp: { type: 'object', required: false },
       },
     );
 
-    const joinData = { conferenceId };
-    if (startConferenceOnEnter !== undefined)
-      joinData.startConferenceOnEnter = startConferenceOnEnter;
-    if (endConferenceOnExit !== undefined)
-      joinData.endConferenceOnExit = endConferenceOnExit;
-    if (muted !== undefined) joinData.muted = muted;
-    if (hold !== undefined) joinData.hold = hold;
-    if (holdAudioUrl) joinData.holdAudioUrl = holdAudioUrl;
-    if (clientState) joinData.clientState = clientState;
-    if (commandId) joinData.commandId = commandId;
+    const bodyData = { channels };
+    if (to) bodyData.to = to;
+    if (callerIdName) bodyData.callerIdName = callerIdName;
+    if (callerIdNumber) bodyData.callerIdNumber = callerIdNumber;
+    if (timeout !== undefined) bodyData.timeout = timeout;
+    if (voiceApp) bodyData.voiceApp = voiceApp;
 
     const params = {
-      body: joinData,
+      body: bodyData,
     };
 
     const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/conference_join`,
+      '/voice/calls/transfer',
       'POST',
       params,
     );
     return result;
   }
 
-  async leaveConference(callControlId, clientState, commandId) {
+  async conference(channels) {
     this.sdk.validateParams(
-      { callControlId },
+      { channels },
       {
-        callControlId: { type: 'string', required: true },
-        clientState: { type: 'string', required: false },
-        commandId: { type: 'string', required: false },
+        channels: { type: 'array', required: true },
       },
     );
 
-    const leaveData = {};
-    if (clientState) leaveData.clientState = clientState;
-    if (commandId) leaveData.commandId = commandId;
-
     const params = {
-      body: leaveData,
+      body: { channels },
     };
 
     const result = await this.sdk._fetch(
-      `/voice/calls/${callControlId}/actions/conference_leave`,
+      '/voice/calls/conference',
       'POST',
       params,
     );