@unboundcx/sdk 4.13.62 → 4.13.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.13.62",
+  "version": "4.13.66",
   "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/ai/battleCards.js

@@ -366,6 +366,33 @@ export class BattleCardsService {
    *   queueId: 'queue_123'
    * });
    */
+  /**
+   * Search (or list) battle cards assigned to a queue's packs.
+   * Empty query returns the full pack list; a query ranks title/trigger/body.
+   *
+   * @param {Object} options
+   * @param {string} options.queueId
+   * @param {string} [options.query]
+   * @param {string} [options.q]
+   * @returns {Promise<Object>} { results, query }
+   */
+  async searchQueueCards({ queueId, query, q } = {}) {
+    this.sdk.validateParams(
+      { queueId },
+      {
+        queueId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(
+      this.sdk,
+      `/ai/battleCards/queues/${queueId}/cards`,
+      'GET',
+      { query: { q: query || q || '' } },
+    );
+    return result;
+  }
+
   async listQueuePacks({ queueId }) {
     this.sdk.validateParams(
       { queueId },

package/services/fax.js

@@ -263,4 +263,31 @@ export class FaxService {
 
     return await internalRequest(this.sdk, '/fax/status', 'POST', params);
   }
+
+  /**
+   * Retry a failed outbound fax. Resets the same fax document row (status
+   * back to 'pending', clears isError/errorMessage/sipCallId, bumps
+   * sendAttempts) and re-dispatches it through the same media-manager path
+   * as sdk.fax.send() -- only valid for outbound documents currently in
+   * status 'failed'.
+   *
+   * @param {string} id - The fax document ID to retry (required)
+   * @returns {Promise<Object>} Retry result
+   * @returns {string} result.id - The fax document ID
+   * @returns {string} result.status - 'sending' on success, 'failed' on NATS error
+   *
+   * @example
+   * const result = await sdk.fax.retry('158abc123...');
+   * console.log(result.status); // 'sending'
+   */
+  async retry(id) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    return await internalRequest(this.sdk, `/fax/${id}/retry`, 'POST', {});
+  }
 }

package/services/knowledgeBase.js

@@ -21,7 +21,15 @@ export class KnowledgeBaseService {
    *   Each result's source now also includes isPublic, knowledgeBaseId, knowledgeBaseName.
    * @returns {Promise<Object>} Search results with source attribution
    */
-  async search({ query, knowledgeBaseId, limit, filters, rerank, visibility }) {
+  async search({
+    query,
+    knowledgeBaseId,
+    limit,
+    filters,
+    rerank,
+    visibility,
+    taskId,
+  }) {
     this.sdk.validateParams(
       { query },
       {
@@ -30,7 +38,15 @@ export class KnowledgeBaseService {
     );
 
     const params = {
-      body: { query, knowledgeBaseId, limit, filters, rerank, visibility },
+      body: {
+        query,
+        knowledgeBaseId,
+        limit,
+        filters,
+        rerank,
+        visibility,
+        taskId,
+      },
     };
 
     const result = await internalRequest(this.sdk, 
@@ -41,6 +57,34 @@ export class KnowledgeBaseService {
     return result;
   }
 
+  async listQueueKnowledgeBases({ queueId }) {
+    this.sdk.validateParams(
+      { queueId },
+      { queueId: { type: 'string', required: true } },
+    );
+    return internalRequest(
+      this.sdk,
+      `/knowledgeBase/queues/${queueId}/knowledgeBases`,
+      'GET',
+    );
+  }
+
+  async setQueueKnowledgeBases({ queueId, knowledgeBaseIds }) {
+    this.sdk.validateParams(
+      { queueId, knowledgeBaseIds },
+      {
+        queueId: { type: 'string', required: true },
+        knowledgeBaseIds: { type: 'array', required: true },
+      },
+    );
+    return internalRequest(
+      this.sdk,
+      `/knowledgeBase/queues/${queueId}/knowledgeBases`,
+      'PUT',
+      { body: { knowledgeBaseIds } },
+    );
+  }
+
   /**
    * Discover pages available at a URL
    * Checks for sitemaps (auto-discovery + direct sitemap URLs) and returns
@@ -173,6 +217,81 @@ export class KnowledgeBaseService {
     return result;
   }
 
+  /**
+   * List version snapshots for a KB article, newest first
+   *
+   * @param {Object} params
+   * @param {string} params.id - Article ID
+   * @returns {Promise<Object>} { results: [{ id, version, createdAt, createdBy, contentLength, preview }] }
+   */
+  async listArticleVersions({ id }) {
+    this.sdk.validateParams(
+      { id },
+      {
+        id: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(
+      this.sdk,
+      `/knowledgeBase/articles/${id}/versions`,
+      'GET',
+    );
+    return result;
+  }
+
+  /**
+   * Get one full version snapshot (with content) for a KB article
+   *
+   * @param {Object} params
+   * @param {string} params.id - Article ID
+   * @param {string} params.versionId - Version snapshot ID
+   * @returns {Promise<Object>} Full version row including content
+   */
+  async getArticleVersion({ id, versionId }) {
+    this.sdk.validateParams(
+      { id, versionId },
+      {
+        id: { type: 'string', required: true },
+        versionId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(
+      this.sdk,
+      `/knowledgeBase/articles/${id}/versions/${versionId}`,
+      'GET',
+    );
+    return result;
+  }
+
+  /**
+   * Restore a KB article's content to a prior version snapshot.
+   * Snapshots the article's current content as a new version before
+   * overwriting it, then reprocesses if the article is published.
+   *
+   * @param {Object} params
+   * @param {string} params.id - Article ID
+   * @param {string} params.versionId - Version snapshot ID to restore
+   * @returns {Promise<Object>} Updated article record
+   */
+  async restoreArticleVersion({ id, versionId }) {
+    this.sdk.validateParams(
+      { id, versionId },
+      {
+        id: { type: 'string', required: true },
+        versionId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await internalRequest(
+      this.sdk,
+      `/knowledgeBase/articles/${id}/versions/${versionId}/restore`,
+      'POST',
+    );
+    return result;
+  }
+
   /**
    * Get analytics for a knowledge base
    *
@@ -181,6 +300,12 @@ export class KnowledgeBaseService {
    * @param {Object} [params.filters] - Optional date range, source type filters
    * @returns {Promise<Object>} Analytics data
    */
+  async getAccountAnalytics(filters = {}) {
+    return internalRequest(this.sdk, '/knowledgeBase/analytics', 'GET', {
+      query: filters,
+    });
+  }
+
   async getAnalytics({ knowledgeBaseId, ...filters }) {
     this.sdk.validateParams(
       { knowledgeBaseId },
@@ -229,4 +354,55 @@ export class KnowledgeBaseService {
     );
     return result;
   }
+
+  async listTaskPins({ taskId }) {
+    this.sdk.validateParams(
+      { taskId },
+      { taskId: { type: 'string', required: true } },
+    );
+    return internalRequest(
+      this.sdk,
+      `/knowledgeBase/tasks/${taskId}/pins`,
+      'GET',
+    );
+  }
+
+  async pinTaskSource({
+    taskId,
+    sourceId,
+    sourceType,
+    knowledgeBaseId,
+    title,
+  }) {
+    this.sdk.validateParams(
+      { taskId, sourceId },
+      {
+        taskId: { type: 'string', required: true },
+        sourceId: { type: 'string', required: true },
+      },
+    );
+    return internalRequest(
+      this.sdk,
+      `/knowledgeBase/tasks/${taskId}/pins`,
+      'POST',
+      {
+        body: { sourceId, sourceType, knowledgeBaseId, title },
+      },
+    );
+  }
+
+  async unpinTaskSource({ taskId, pinId }) {
+    this.sdk.validateParams(
+      { taskId, pinId },
+      {
+        taskId: { type: 'string', required: true },
+        pinId: { type: 'string', required: true },
+      },
+    );
+    return internalRequest(
+      this.sdk,
+      `/knowledgeBase/tasks/${taskId}/pins/${pinId}`,
+      'DELETE',
+    );
+  }
 }

package/services/taskRouter/WorkerService.js

@@ -195,6 +195,84 @@ export class WorkerService {
     return result;
   }
 
+  /**
+   * Set the authenticated user's own worker paused state
+   * Pauses (or unpauses) the caller's own worker so it stays logged into its queues
+   * but stops receiving new task offers. Requires Contact Center access.
+   *
+   * @param {Object} options - Parameters
+   * @param {boolean} options.paused - Whether the worker should be paused
+   * @returns {Promise<Object>} The updated worker
+   *
+   * @example
+   * // Pause the authenticated user's own worker
+   * const worker = await sdk.taskRouter.worker.setPaused({ paused: true });
+   *
+   * @example
+   * // Unpause
+   * const worker = await sdk.taskRouter.worker.setPaused({ paused: false });
+   */
+  async setPaused(options = {}) {
+    const { paused } = options;
+
+    this.sdk.validateParams(
+      { paused },
+      {
+        paused: { type: 'boolean', required: true },
+      },
+    );
+
+    const params = {
+      body: { paused },
+    };
+
+    const result = await internalRequest(this.sdk,
+      '/taskRouter/workers/me/paused',
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Set another worker's paused state
+   * Pauses (or unpauses) a specific worker by workerId. The caller must be a queue
+   * manager for at least one queue that worker is logged into or assigned to.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.workerId - The worker ID to update (required)
+   * @param {boolean} options.paused - Whether the worker should be paused
+   * @returns {Promise<Object>} The updated worker
+   *
+   * @example
+   * const worker = await sdk.taskRouter.worker.setWorkerPaused({
+   *   workerId: '0860002026012400000006665842155429980',
+   *   paused: true,
+   * });
+   */
+  async setWorkerPaused(options = {}) {
+    const { workerId, paused } = options;
+
+    this.sdk.validateParams(
+      { workerId, paused },
+      {
+        workerId: { type: 'string', required: true },
+        paused: { type: 'boolean', required: true },
+      },
+    );
+
+    const params = {
+      body: { paused },
+    };
+
+    const result = await internalRequest(this.sdk,
+      `/taskRouter/workers/${workerId}/paused`,
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
   /**
    * Automatically login all auto-login queues for a worker
    * When a worker goes available, this logs them into all queues marked with autoLogin = true.