@unboundcx/sdk 2.8.6 → 2.8.8

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/portals.js

@@ -3,6 +3,28 @@ export class PortalsService {
     this.sdk = sdk;
   }
 
+  /**
+   * Creates a new portal for the authenticated account.
+   *
+   * @param {object} params
+   * @param {string} params.name - Display name of the portal.
+   * @param {string} params.domain - Custom domain for the portal (e.g. `portal.example.com`).
+   *   A CNAME DNS record pointing to the platform's portal host is required.
+   * @param {object} [params.settings] - Optional portal configuration settings.
+   * @param {boolean} [params.isPublic] - Whether the portal is publicly accessible without
+   *   authentication. Defaults to private if omitted.
+   * @param {string} [params.customCss] - Optional custom CSS injected into the portal.
+   * @param {string} [params.customJs] - Optional custom JavaScript injected into the portal.
+   * @param {string} [params.favicon] - Optional URL or asset reference for the portal favicon.
+   * @param {string} [params.logo] - Optional URL or asset reference for the portal logo.
+   * @returns {Promise<{
+   *   id: string,
+   *   accountId: string,
+   *   name: string,
+   *   domain: string,
+   *   dns: Array<{ type: string, name: string, value: string, description: string }>
+   * }>} The newly created portal, including DNS records needed to configure the custom domain.
+   */
   async create({
     name,
     domain,
@@ -43,6 +65,29 @@ export class PortalsService {
     return result;
   }
 
+  /**
+   * Updates an existing portal's properties.
+   *
+   * Only the fields provided will be updated; omitted fields are left unchanged.
+   *
+   * @param {string} portalId - The ID of the portal to update.
+   * @param {object} updates
+   * @param {string} [updates.name] - New display name for the portal.
+   * @param {string} [updates.domain] - New custom domain for the portal.
+   * @param {object} [updates.settings] - Updated portal configuration settings.
+   * @param {boolean} [updates.isPublic] - Updated public accessibility flag.
+   * @param {string} [updates.customCss] - Updated custom CSS for the portal.
+   * @param {string} [updates.customJs] - Updated custom JavaScript for the portal.
+   * @param {string} [updates.favicon] - Updated favicon URL or asset reference.
+   * @param {string} [updates.logo] - Updated logo URL or asset reference.
+   * @returns {Promise<{
+   *   id: string,
+   *   updatedBy: string,
+   *   updatedAt: string,
+   *   name?: string,
+   *   domain?: string
+   * }>} The updated portal fields along with audit metadata.
+   */
   async update(
     portalId,
     { name, domain, settings, isPublic, customCss, customJs, favicon, logo },
@@ -80,6 +125,12 @@ export class PortalsService {
     return result;
   }
 
+  /**
+   * Deletes a portal by ID.
+   *
+   * @param {string} portalId - The ID of the portal to delete.
+   * @returns {Promise<{ message: string }>} Confirmation message on success.
+   */
   async delete(portalId) {
     this.sdk.validateParams(
       { portalId },
@@ -92,6 +143,12 @@ export class PortalsService {
     return result;
   }
 
+  /**
+   * Retrieves a portal by ID.
+   *
+   * @param {string} portalId - The ID of the portal to retrieve.
+   * @returns {Promise<object>} The full portal record.
+   */
   async get(portalId) {
     this.sdk.validateParams(
       { portalId },
@@ -104,6 +161,17 @@ export class PortalsService {
     return result;
   }
 
+  /**
+   * Retrieves public portal information by domain.
+   *
+   * This is an unauthenticated endpoint used by portal front-ends to look up
+   * their own configuration based on the domain they are served from.
+   *
+   * @param {string} domain - The custom domain of the portal to look up
+   *   (e.g. `portal.example.com`).
+   * @returns {Promise<{ id: string, name: string, domain: string }>}
+   *   The public-facing portal fields. Sensitive account data is excluded.
+   */
   async getPublic(domain) {
     this.sdk.validateParams(
       { domain },
@@ -120,11 +188,32 @@ export class PortalsService {
     return result;
   }
 
+  /**
+   * Lists all portals belonging to the authenticated account.
+   *
+   * @returns {Promise<{ portals: object[] }>} An object containing an array of portal records.
+   */
   async list() {
     const result = await this.sdk._fetch('/portals', 'GET');
     return result;
   }
 
+  /**
+   * Verifies that a portal's custom domain has the correct DNS configuration.
+   *
+   * Checks that the domain has a valid CNAME record pointing to the platform's
+   * portal host. Use the `dns` records returned from `create()` to know the
+   * expected target value.
+   *
+   * @param {string} portalId - The ID of the portal whose DNS should be verified.
+   * @returns {Promise<{
+   *   portalId: string,
+   *   domain: string,
+   *   expectedTarget: string,
+   *   dns: object
+   * }>} The DNS verification result, including the expected CNAME target and
+   *   the actual resolution details.
+   */
   async verifyDns(portalId) {
     this.sdk.validateParams(
       { portalId },

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;
   }