@unboundcx/sdk 2.8.6 → 2.8.7

package/services/engagementMetrics.js

@@ -139,7 +139,11 @@ export class EngagementMetricsService {
    * @param {string[]} [options.userIds] - Array of user IDs to filter by
    * @returns {Promise<Object>} All metrics
    */
-  async getDashboardMetrics({ queueIds = [], statuses = [], userIds = [] } = {}) {
+  async getDashboardMetrics({
+    queueIds = [],
+    statuses = [],
+    userIds = [],
+  } = {}) {
     return this.getMetrics({
       queueIds,
       statuses,
@@ -150,4 +154,4 @@ export class EngagementMetricsService {
       includeAgentPerformance: true,
     });
   }
-}
+}

package/services/objects.js

@@ -45,9 +45,13 @@ export class ObjectsService {
       }
     } else if (typeof arg1 === 'object') {
       id = arg1.id;
-      query = { ...arg1 };
-      if (query.id) {
-        delete query.id;
+      if (arg1.query) {
+        query = { ...arg1.query };
+      } else {
+        query = { ...arg1 };
+        if (query.id) {
+          delete query.id;
+        }
       }
     }
 
@@ -63,7 +67,9 @@ export class ObjectsService {
     );
 
     const params = { query };
+
     const result = await this.sdk._fetch(`/object/${id}`, 'GET', params);
+    // console.log(`sdk.objects.byId :: params :: `, params, result);
     return result;
   }
 
@@ -97,6 +103,7 @@ export class ObjectsService {
         previousId = null,
         orderByDirection = 'DESC',
         expandDetails = false,
+        meta = {},
       } = args[0];
 
       this.sdk.validateParams(
@@ -109,6 +116,7 @@ export class ObjectsService {
           previousId,
           orderByDirection,
           expandDetails,
+          meta,
         },
         {
           object: { type: 'string', required: true },
@@ -119,6 +127,7 @@ export class ObjectsService {
           previousId: { type: 'string', required: false },
           orderByDirection: { type: 'string', required: false },
           expandDetails: { type: 'boolean', required: false },
+          meta: { type: 'object', required: false },
         },
       );
 

package/services/phoneNumbers.js

@@ -110,10 +110,21 @@ export class PhoneNumbersService {
       voiceAppMetaData,
       voiceRecordTypeId,
       messagingRecordTypeId,
+      recordCalls,
     },
   ) {
     this.sdk.validateParams(
-      { id },
+      {
+        id,
+        messagingWebHookUrl,
+        voiceWebHookUrl,
+        voiceAppExternalUrl,
+        voiceAppExternalMethod,
+        voiceApp,
+        voiceRecordTypeId,
+        messagingRecordTypeId,
+        recordCalls,
+      },
       {
         id: { type: 'string', required: true },
         name: { type: 'string', required: false },
@@ -122,9 +133,9 @@ export class PhoneNumbersService {
         voiceAppExternalUrl: { type: 'string', required: false },
         voiceAppExternalMethod: { type: 'string', required: false },
         voiceApp: { type: 'string', required: false },
-        voiceAppMetaData: { type: 'object', required: false },
         voiceRecordTypeId: { type: 'string', required: false },
         messagingRecordTypeId: { type: 'string', required: false },
+        recordCalls: { type: 'boolean', required: false },
       },
     );
 
@@ -142,6 +153,7 @@ export class PhoneNumbersService {
     if (voiceRecordTypeId) updateData.voiceRecordTypeId = voiceRecordTypeId;
     if (messagingRecordTypeId)
       updateData.messagingRecordTypeId = messagingRecordTypeId;
+    if (recordCalls !== undefined) updateData.recordCalls = recordCalls;
 
     const params = {
       body: updateData,
@@ -187,10 +199,83 @@ export class PhoneNumbersService {
     return result;
   }
 
-  async getRoutingOptions() {
+  /**
+   * Get routing options for phone numbers or extensions
+   *
+   * Supports multiple query modes:
+   * 1. Get list of valid app types with metadata (appType: 'list')
+   * 2. Get all application types (default)
+   * 3. Get details for a specific application type
+   * 4. Get versions for a specific workflow
+   *
+   * @param {Object} [options] - Query options
+   * @param {string} [options.mode] - Context mode: 'phoneNumbers' (default) or 'extensions'
+   * @param {string} [options.type] - Filter by routing type: 'voice' or 'messaging'
+   * @param {string} [options.appType] - 'list' for metadata, or specific app type: 'workflows', 'extensions', 'voiceApps', 'users'
+   * @param {string} [options.workflowId] - Get versions for a specific workflow ID
+   * @param {string} [options.search] - Search/filter by name
+   * @returns {Promise<Object>} Routing options based on query parameters
+   * @example
+   * // Get metadata about available app types
+   * const metadata = await sdk.phoneNumbers.getRoutingOptions({ appType: 'list' });
+   * // Returns: { types: [{ key: 'voiceApps', label: 'Voice Applications', description: '...', ... }] }
+   *
+   * // Get all application types for phone numbers (default)
+   * const all = await sdk.phoneNumbers.getRoutingOptions();
+   * // Returns: { voiceApps: [...], workflows: [...], extensions: [...], webhooks: [...] }
+   *
+   * // Get routing options for extensions
+   * const extensionOptions = await sdk.phoneNumbers.getRoutingOptions({ mode: 'extensions' });
+   * // Returns: { voiceApps: [...], workflows: [...], users: [...] }
+   *
+   * // Get only voice routing options
+   * const voice = await sdk.phoneNumbers.getRoutingOptions({ type: 'voice' });
+   *
+   * // Get all workflows with their versions
+   * const workflows = await sdk.phoneNumbers.getRoutingOptions({ appType: 'workflows' });
+   *
+   * // Get all users (for extension routing)
+   * const users = await sdk.phoneNumbers.getRoutingOptions({ mode: 'extensions', appType: 'users' });
+   *
+   * // Get versions for a specific workflow
+   * const versions = await sdk.phoneNumbers.getRoutingOptions({ workflowId: 'wf_123' });
+   *
+   * // Search workflows by name
+   * const filtered = await sdk.phoneNumbers.getRoutingOptions({ appType: 'workflows', search: 'customer' });
+   */
+  async getRoutingOptions({ mode, type, appType, workflowId, search } = {}) {
+    const validationSchema = {};
+    const args = arguments[0] || {};
+
+    if ('mode' in args)
+      validationSchema.mode = { type: 'string', required: false };
+    if ('type' in args)
+      validationSchema.type = { type: 'string', required: false };
+    if ('appType' in args)
+      validationSchema.appType = { type: 'string', required: false };
+    if ('workflowId' in args)
+      validationSchema.workflowId = { type: 'string', required: false };
+    if ('search' in args)
+      validationSchema.search = { type: 'string', required: false };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(args, validationSchema);
+    }
+
+    const params = {
+      query: {
+        mode,
+        type,
+        appType,
+        workflowId,
+        search,
+      },
+    };
+
     const result = await this.sdk._fetch(
       '/phoneNumbers/routing-options',
       'GET',
+      params,
     );
     return result;
   }

package/services/sipEndpoints.js

@@ -3,23 +3,45 @@ export class SipEndpointsService {
     this.sdk = sdk;
   }
 
-  async create({ recordTypeId, type, userId, name }) {
+  /**
+   * Create a new SIP endpoint
+   * @param {Object} options - The endpoint configuration
+   * @param {string} options.recordTypeId - Record type ID for permissions
+   * @param {string} options.userId - User ID to associate with this endpoint
+   * @param {string} options.type - Endpoint type: 'webRtc' or 'ipPhone'
+   * @param {string} options.name - Endpoint name
+   * @param {string} options.macAddress - MAC address for ipPhone type
+   * @param {Object} options - Additional provisioning fields (timezone, vlanId, etc.)
+   * @returns {Promise<Object>} Created endpoint
+   */
+  async create(options) {
+    const {
+      recordTypeId,
+      userId,
+      type,
+      name,
+      macAddress,
+      useSecureCalling,
+      ...provisioningFields
+    } = options;
+
     this.sdk.validateParams(
-      { recordTypeId, type, userId, name },
+      { type, useSecureCalling },
       {
-        recordTypeId: { type: 'string', required: false },
         type: { type: 'string', required: true },
-        userId: { type: 'string', required: false },
-        name: { type: 'string', required: false },
+        useSecureCalling: { type: 'boolean', required: false },
       },
     );
 
     const params = {
       body: {
         recordTypeId,
-        type,
         userId,
+        type,
+        useSecureCalling,
         name,
+        macAddress,
+        ...provisioningFields, // Include all provisioning fields
       },
     };
 
@@ -27,23 +49,53 @@ export class SipEndpointsService {
     return result;
   }
 
+  /**
+   * Get the authenticated user's WebRTC endpoint details
+   * @returns {Promise<Object>} WebRTC endpoint configuration
+   */
   async getWebRtcDetails() {
-    const params = {};
-    const result = await this.sdk._fetch('/sipEndpoints', 'GET', params, true);
+    const result = await this.sdk._fetch('/sipEndpoints/webrtc', 'GET');
     return result;
   }
 
-  async getUsersWebRtc() {
-    const result = await this.sdk._fetch('/sipEndpoints/users/webrtc', 'GET');
-    return result;
-  }
+  /**
+   * Update a SIP endpoint
+   * @param {string} endpointId - The endpoint ID
+   * @param {Object} options - The fields to update
+   * @param {string} options.name - Endpoint name
+   * @param {string} options.userId - User ID to associate with this endpoint
+   * * @param {string} options.useSecureCalling - provision with TLS / secure calling
+   * @param {string} options.macAddress - MAC address
+   * @param {boolean} options.useIceAccelerator - Enable/disable ICE accelerator
+   * @param {Object} options - Additional provisioning fields (timezone, vlanId, etc.)
+   * @returns {Promise<Object>} Updated endpoint
+   */
+  async update(endpointId, options) {
+    this.sdk.validateParams(
+      { endpointId },
+      {
+        endpointId: { type: 'string', required: true },
+      },
+    );
 
-  async list() {
-    const result = await this.sdk._fetch('/sipEndpoints/list', 'GET');
+    const params = {
+      body: { ...options }, // Pass all options through
+    };
+
+    const result = await this.sdk._fetch(
+      `/sipEndpoints/${endpointId}`,
+      'PUT',
+      params,
+    );
     return result;
   }
 
-  async get(endpointId) {
+  /**
+   * Delete a SIP endpoint
+   * @param {string} endpointId - The endpoint ID
+   * @returns {Promise<Object>} Deletion result
+   */
+  async delete(endpointId) {
     this.sdk.validateParams(
       { endpointId },
       {
@@ -51,39 +103,59 @@ export class SipEndpointsService {
       },
     );
 
-    const result = await this.sdk._fetch(`/sipEndpoints/${endpointId}`, 'GET');
+    const result = await this.sdk._fetch(
+      `/sipEndpoints/${endpointId}`,
+      'DELETE',
+    );
     return result;
   }
 
-  async update(endpointId, { displayName, description, enabled }) {
+  /**
+   * Reboot a SIP endpoint (forces re-registration)
+   * @param {string} endpointId - The endpoint ID
+   * @returns {Promise<Object>} Reboot result
+   */
+  async reboot(endpointId) {
     this.sdk.validateParams(
       { endpointId },
       {
         endpointId: { type: 'string', required: true },
-        displayName: { type: 'string', required: false },
-        description: { type: 'string', required: false },
-        enabled: { type: 'boolean', required: false },
       },
     );
 
-    const updateData = {};
-    if (displayName) updateData.displayName = displayName;
-    if (description) updateData.description = description;
-    if (enabled !== undefined) updateData.enabled = enabled;
+    const result = await this.sdk._fetch(
+      `/sipEndpoints/${endpointId}/reboot`,
+      'POST',
+    );
+    return result;
+  }
 
-    const params = {
-      body: updateData,
-    };
+  /**
+   * Change the access secret for a SIP endpoint
+   * @param {string} endpointId - The endpoint ID
+   * @returns {Promise<Object>} New endpoint credentials
+   */
+  async changeAccessSecret(endpointId) {
+    this.sdk.validateParams(
+      { endpointId },
+      {
+        endpointId: { type: 'string', required: true },
+      },
+    );
 
     const result = await this.sdk._fetch(
-      `/sipEndpoints/${endpointId}`,
-      'PUT',
-      params,
+      `/sipEndpoints/${endpointId}/secret`,
+      'POST',
     );
     return result;
   }
 
-  async delete(endpointId) {
+  /**
+   * Change the provisioning secret for a SIP endpoint
+   * @param {string} endpointId - The endpoint ID
+   * @returns {Promise<Object>} New endpoint credentials
+   */
+  async changeProvisioningSecret(endpointId) {
     this.sdk.validateParams(
       { endpointId },
       {
@@ -92,8 +164,8 @@ export class SipEndpointsService {
     );
 
     const result = await this.sdk._fetch(
-      `/sipEndpoints/${endpointId}`,
-      'DELETE',
+      `/sipEndpoints/${endpointId}/secret/provisioning`,
+      'POST',
     );
     return result;
   }

package/services/storage.js

@@ -213,8 +213,25 @@ export class StorageService {
     formFields,
     endpoint = '/storage/upload',
     method = 'POST',
+    onProgress = null,
+    skipClamscan = false,
   ) {
     const isNode = typeof window === 'undefined';
+
+    // In browser with progress callback: Use XMLHttpRequest
+    if (!isNode && onProgress && typeof onProgress === 'function') {
+      return this._performUploadWithProgress(
+        file,
+        fileName,
+        formFields,
+        endpoint,
+        method,
+        onProgress,
+        skipClamscan,
+      );
+    }
+
+    // Default behavior: Use fetch via sdk._fetch
     let formData, headers;
 
     if (isNode) {
@@ -227,6 +244,15 @@ export class StorageService {
       headers = result.headers;
     }
 
+    if (process?.env?.AUTH_V3_TOKEN_TYPE_OVERRIDE) {
+      headers['x-token-type-override'] =
+        process.env.AUTH_V3_TOKEN_TYPE_OVERRIDE;
+    }
+
+    if (skipClamscan && process?.env?.CLAMSCAN_OVERRIDE_KEY) {
+      headers['x-clamscan-override-key'] = process.env.CLAMSCAN_OVERRIDE_KEY;
+    }
+
     const params = {
       body: formData,
       headers,
@@ -235,6 +261,123 @@ export class StorageService {
     return await this.sdk._fetch(endpoint, method, params, true);
   }
 
+  // Upload with progress tracking using XMLHttpRequest
+  async _performUploadWithProgress(
+    file,
+    fileName,
+    formFields,
+    endpoint,
+    method,
+    onProgress,
+    skipClamscan = false,
+  ) {
+    const { formData } = this._createBrowserFormData(
+      file,
+      fileName,
+      formFields,
+    );
+
+    return new Promise((resolve, reject) => {
+      const xhr = new XMLHttpRequest();
+
+      const startTime = Date.now();
+
+      // Progress tracking
+      xhr.upload.onprogress = (event) => {
+        if (event.lengthComputable) {
+          const percentComplete = (event.loaded / event.total) * 100;
+          const elapsed = (Date.now() - startTime) / 1000; // seconds
+          const speed = event.loaded / elapsed; // bytes per second
+
+          onProgress({
+            loaded: event.loaded,
+            total: event.total,
+            percentage: percentComplete,
+            speed: speed, // bytes/sec
+          });
+        }
+      };
+
+      xhr.onload = () => {
+        if (xhr.status >= 200 && xhr.status < 300) {
+          try {
+            const response = JSON.parse(xhr.responseText);
+            resolve(response);
+          } catch (e) {
+            reject(new Error('Invalid JSON response'));
+          }
+        } else {
+          try {
+            const errorResponse = JSON.parse(xhr.responseText);
+            reject(errorResponse);
+          } catch (e) {
+            reject(new Error(`Upload failed with status ${xhr.status}`));
+          }
+        }
+      };
+
+      xhr.onerror = () => reject(new Error('Network error during upload'));
+      xhr.onabort = () => reject(new Error('Upload aborted'));
+
+      // Build URL with auth headers
+      const url = `${this.sdk.fullUrl}${endpoint}`;
+      xhr.open(method, url, true);
+
+      // IMPORTANT: Include credentials (cookies) for authentication
+      xhr.withCredentials = true;
+
+      // Add auth headers
+      if (this.sdk.token) {
+        xhr.setRequestHeader('Authorization', `Bearer ${this.sdk.token}`);
+      }
+      if (this.sdk.fwRequestId) {
+        xhr.setRequestHeader('x-request-id-fw', this.sdk.fwRequestId);
+      }
+      if (this.sdk.callId) {
+        xhr.setRequestHeader('x-call-id', this.sdk.callId);
+      }
+
+      // Add environment variable override headers
+      if (process?.env?.AUTH_V3_TOKEN_TYPE_OVERRIDE) {
+        xhr.setRequestHeader(
+          'x-token-type-override',
+          process.env.AUTH_V3_TOKEN_TYPE_OVERRIDE,
+        );
+      }
+      if (skipClamscan && process?.env?.CLAMSCAN_OVERRIDE_KEY) {
+        xhr.setRequestHeader(
+          'x-clamscan-override-key',
+          process.env.CLAMSCAN_OVERRIDE_KEY,
+        );
+      }
+
+      xhr.send(formData);
+    });
+  }
+  /*
+
+
+Response:
+{
+    "uploaded": [
+        {
+            "id": "017d0120251229hvdxjod4486582468133095",
+            "fileName": "sip-messages-20251223T195443.txt",
+            "fileSize": 18979,
+            "url": "https://masterc.api.dev-d01.app1svc.com/storage/017d0120251229hvdxjod4486582468133095.txt",
+            "mimeType": "text/plain",
+            "s3Regions": [
+                "d01",
+                "d03"
+            ],
+            "isPublic": false
+        }
+    ],
+    "viruses": [],
+    "errors": []
+}
+
+*/
   async upload({
     classification = 'generic',
     folder,
@@ -246,6 +389,8 @@ export class StorageService {
     relatedId,
     createAccessKey = false,
     accessKeyExpiresIn,
+    onProgress,
+    _options,
   }) {
     this.sdk.validateParams(
       {
@@ -270,7 +415,7 @@ export class StorageService {
         expireAfter: { type: 'string', required: false },
         relatedId: { type: 'string', required: false },
         createAccessKey: { type: 'boolean', required: false },
-        accessKeyExpiresIn: { type: 'string', required: false },
+        accessKeyExpiresIn: { type: 'number', required: false },
       },
     );
 
@@ -288,11 +433,20 @@ export class StorageService {
     if (accessKeyExpiresIn)
       formFields.push(['accessKeyExpiresIn', accessKeyExpiresIn]);
 
-    return this._performUpload(file, fileName, formFields);
+    return this._performUpload(
+      file,
+      fileName,
+      formFields,
+      '/storage/upload',
+      'POST',
+      onProgress,
+      _options?.skipScan,
+    );
   }
 
   async uploadFiles(files, options = {}) {
-    const { classification, expireAfter, isPublic, metadata } = options;
+    const { classification, expireAfter, isPublic, metadata, _options } =
+      options;
 
     // Validate files parameter
     if (!files) {
@@ -392,6 +546,10 @@ export class StorageService {
       if (metadata) formData.append('metadata', JSON.stringify(metadata));
     }
 
+    if (_options?.skipScan && process?.env?.CLAMSCAN_OVERRIDE_KEY) {
+      headers['x-clamscan-override-key'] = process.env.CLAMSCAN_OVERRIDE_KEY;
+    }
+
     const params = {
       body: formData,
       headers,
@@ -467,13 +625,19 @@ export class StorageService {
     return result;
   }
 
-  async uploadProfileImage({ file, classification = 'user_images', fileName }) {
+  async uploadProfileImage({
+    file,
+    classification = 'user_images',
+    fileName,
+    userId,
+  }) {
     this.sdk.validateParams(
-      { file, classification },
+      { file, classification, userId },
       {
         file: { type: 'object', required: true },
         classification: { type: 'string', required: true },
         fileName: { type: 'string', required: false },
+        userId: { type: 'string', required: false },
       },
     );
 
@@ -488,6 +652,7 @@ export class StorageService {
     // Build form fields exactly like the regular upload but only include classification
     const formFields = [];
     formFields.push(['classification', classification]);
+    formFields.push(['userId', userId]);
 
     // Use the correct profile image endpoint with proper FormData
     return this._performUpload(
@@ -535,12 +700,14 @@ export class StorageService {
   }
 
   async listFiles(options = {}) {
-    const { classification, limit, offset, orderBy, orderDirection } = options;
+    const { classification, folder, limit, offset, orderBy, orderDirection } =
+      options;
 
     // Validate optional parameters
     const validationSchema = {};
     if ('classification' in options)
       validationSchema.classification = { type: 'string' };
+    if ('folder' in options) validationSchema.folder = { type: 'string' };
     if ('limit' in options) validationSchema.limit = { type: 'number' };
     if ('offset' in options) validationSchema.offset = { type: 'number' };
     if ('orderBy' in options) validationSchema.orderBy = { type: 'string' };
@@ -749,6 +916,7 @@ export class StorageService {
       country,
       expireAfter,
       relatedId,
+      _options,
     },
   ) {
     this.sdk.validateParams(
@@ -784,6 +952,8 @@ export class StorageService {
         formFields,
         `/storage/${storageId}`,
         'PUT',
+        null,
+        _options?.skipScan,
       );
     } else {
       // If only updating metadata, use JSON request