@unboundcx/sdk 4.8.5 → 4.8.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unboundcx/sdk",
-  "version": "4.8.5",
+  "version": "4.8.8",
   "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.js

@@ -642,6 +642,32 @@ export class SpeechToTextService {
     return result;
   }
 
+  /**
+   * Synchronously transcribe a stored audio file (batch STT).
+   * Counterpart to stream(): give it a storage file id, get the transcript
+   * back in the response (typically ~1-3s for voicemail-length audio).
+   *
+   * @param {Object} options
+   * @param {string} options.storageId - Storage file id of the audio (WAV by default).
+   * @param {string} [options.language] - Language hint (default 'en').
+   * @param {string} [options.encoding] - Audio encoding (default 'WAV').
+   * @returns {Promise<{transcription: string|null, language: string|null, duration: number|null}>}
+   */
+  async file({ storageId, language, encoding } = {}) {
+    this.sdk.validateParams(
+      { storageId, language, encoding },
+      {
+        storageId: { type: 'string', required: true },
+        language: { type: 'string', required: false },
+        encoding: { type: 'string', required: false },
+      },
+    );
+    const body = { storageId };
+    if (language !== undefined) body.language = language;
+    if (encoding !== undefined) body.encoding = encoding;
+    return await this.sdk._fetch('/ai/stt/file', 'POST', { body });
+  }
+
   /**
    * Create a real-time streaming transcription session
    * Returns an EventEmitter-based stream for sending audio and receiving transcripts

package/services/directory.js

@@ -15,27 +15,33 @@ export class DirectoryService {
   }
 
   /**
-   * Add a person or company to directory favorites. Reactivates a
-   * soft-deleted favorite on unique conflict.
+   * Add a person, company, user, or queue to directory favorites.
+   * Reactivates a soft-deleted favorite on unique conflict.
    *
    * @param {Object} params
-   * @param {string} params.objectType - 'person' or 'company' (required).
+   * @param {string} params.objectType - 'person', 'company', 'user', or 'queue' (required).
    * @param {string} params.objectId - Id of the favorited record (required).
    * @param {string[]} [params.channelIds] - Channel ids to pin for this favorite.
+   * @param {string} [params.channelId] - Channel id to pin for this favorite.
+   * @param {string} [params.numberField] - Number field to associate with this favorite.
    * @returns {Promise<Object>} The created (or reactivated) favorite.
    */
-  async addFavorite({ objectType, objectId, channelIds }) {
+  async addFavorite({ objectType, objectId, channelIds, channelId, numberField }) {
     this.sdk.validateParams(
-      { objectType, objectId, channelIds },
+      { objectType, objectId, channelIds, channelId, numberField },
       {
         objectType: { type: 'string', required: true },
         objectId: { type: 'string', required: true },
         channelIds: { type: 'array', required: false },
+        channelId: { type: 'string', required: false },
+        numberField: { type: 'string', required: false },
       },
     );
 
     const body = { objectType, objectId };
     if (channelIds !== undefined) body.channelIds = channelIds;
+    if (channelId !== undefined) body.channelId = channelId;
+    if (numberField !== undefined) body.numberField = numberField;
 
     const params = { body };
 
@@ -49,21 +55,27 @@ export class DirectoryService {
    * @param {string} favoriteId - Id of the favorite to update (required).
    * @param {Object} params
    * @param {string[]} [params.channelIds]
+   * @param {string} [params.channelId]
+   * @param {string} [params.numberField]
    * @param {number} [params.sortOrder]
    * @returns {Promise<Object>} The updated favorite.
    */
-  async updateFavorite(favoriteId, { channelIds, sortOrder } = {}) {
+  async updateFavorite(favoriteId, { channelIds, channelId, numberField, sortOrder } = {}) {
     this.sdk.validateParams(
-      { favoriteId, channelIds, sortOrder },
+      { favoriteId, channelIds, channelId, numberField, sortOrder },
       {
         favoriteId: { type: 'string', required: true },
         channelIds: { type: 'array', required: false },
+        channelId: { type: 'string', required: false },
+        numberField: { type: 'string', required: false },
         sortOrder: { type: 'number', required: false },
       },
     );
 
     const body = {};
     if (channelIds !== undefined) body.channelIds = channelIds;
+    if (channelId !== undefined) body.channelId = channelId;
+    if (numberField !== undefined) body.numberField = numberField;
     if (sortOrder !== undefined) body.sortOrder = sortOrder;
 
     const params = { body };
@@ -121,4 +133,58 @@ export class DirectoryService {
     );
     return result;
   }
+
+  /**
+   * List the current user's directory contacts.
+   *
+   * @returns {Promise<{contacts: Object[]}>}
+   */
+  async listContacts() {
+    const result = await this.sdk._fetch('/directory/contacts', 'GET');
+    return result;
+  }
+
+  /**
+   * Add a person or company to directory contacts.
+   *
+   * @param {Object} params
+   * @param {string} params.objectType - 'person' or 'company' (required).
+   * @param {string} params.objectId - Id of the contacted record (required).
+   * @returns {Promise<Object>} The created contact.
+   */
+  async addContact({ objectType, objectId }) {
+    this.sdk.validateParams(
+      { objectType, objectId },
+      {
+        objectType: { type: 'string', required: true },
+        objectId: { type: 'string', required: true },
+      },
+    );
+
+    const params = { body: { objectType, objectId } };
+
+    const result = await this.sdk._fetch('/directory/contacts', 'POST', params);
+    return result;
+  }
+
+  /**
+   * Remove a directory contact.
+   *
+   * @param {string} contactId - Id of the contact to remove (required).
+   * @returns {Promise<Object>}
+   */
+  async removeContact(contactId) {
+    this.sdk.validateParams(
+      { contactId },
+      {
+        contactId: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/directory/contacts/${contactId}`,
+      'DELETE',
+    );
+    return result;
+  }
 }

package/services/inbox.js

@@ -9,8 +9,8 @@ export class InboxService {
    *
    * @param {Object} params
    * @param {string|string[]} [params.types] - Source kinds to include
-   *   ('call','voicemail','fax','sms'). Pass an array or a comma-joined
-   *   string; omit to include all kinds.
+   *   ('call','voicemail','fax','sms','meeting'). Pass an array or a
+   *   comma-joined string; omit to include all kinds.
    * @param {number} [params.limit] - Max items to return.
    * @param {string} [params.before] - UTC cursor 'YYYY-MM-DD HH:mm:ss';
    *   only items strictly older than this are returned.
@@ -82,10 +82,10 @@ export class InboxService {
   }
 
   /**
-   * Fetch inbox stats (calls/talk time/missed/unread voicemail) for the
-   * current user.
+   * Fetch inbox stats (calls/talk time/missed/unread voicemail/meetings) for
+   * the current user.
    *
-   * @returns {Promise<{callsToday: number, talkTimeSeconds: number, missedToday: number, unreadVoicemail: number, oldestUnreadVoicemailAt: string|null}>}
+   * @returns {Promise<{callsToday: number, talkTimeSeconds: number, missedToday: number, unreadVoicemail: number, oldestUnreadVoicemailAt: string|null, meetingsToday: number, meetingMinutesToday: number}>}
    */
   async stats() {
     const result = await this.sdk._fetch('/inbox/stats', 'GET');

package/services/taskRouter/CCService.js

@@ -0,0 +1,302 @@
+export class CCService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Resolve the caller's Contact Center queue scope + role.
+   * Managers see every non-deleted queue; agents see only the queues they
+   * belong to (queueUsers).
+   *
+   * @returns {Promise<Object>} result
+   * @returns {boolean} result.isManager - Whether the caller has queue-manager scope
+   * @returns {string|null} result.workerId - The caller's own worker id, if any
+   * @returns {Array<Object>} result.queues - Accessible queues [{id, name, slaThreshold}]
+   *
+   * @example
+   * const scope = await sdk.taskRouter.cc.getScope();
+   * console.log(scope.isManager, scope.queues.length);
+   */
+  async getScope() {
+    const result = await this.sdk._fetch('/taskRouter/cc/scope', 'GET', {});
+    return result;
+  }
+
+  /**
+   * Get a live Contact Center snapshot (KPIs, per-queue summaries, team roster
+   * with active tasks) scoped to a set of queues.
+   *
+   * @param {Object} [options] - Parameters
+   * @param {string[]} [options.queueIds] - Queue ids to scope to (must be a subset of the caller's accessible queues). Omit/empty for full scope.
+   * @returns {Promise<Object>} result
+   * @returns {Object} result.kpis - Aggregate KPIs (inQueueNow, longestWaitSec, myHandledToday, myAvgHandleSecToday, slaTodayPct, slaTargetPct)
+   * @returns {Array<Object>} result.queues - Per-queue summaries (id, name, waiting, longestWaitSec, agentsAvailable, agentsTotal, slaPct, health)
+   * @returns {Array<Object>} result.team - Team roster with active tasks
+   *
+   * @example
+   * const snapshot = await sdk.taskRouter.cc.getSnapshot({ queueIds: ['q1', 'q2'] });
+   * console.log(snapshot.kpis.inQueueNow);
+   */
+  async getSnapshot(options = {}) {
+    const { queueIds } = options;
+
+    this.sdk.validateParams(
+      { queueIds },
+      {
+        queueIds: { type: 'array', required: false },
+      },
+    );
+
+    const params = {};
+    if (queueIds && queueIds.length) {
+      params.query = { queueIds: queueIds.join(',') };
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/cc/snapshot',
+      'GET',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Get on-queue session history for a worker (self allowed; another
+   * worker's sessions require the queue-manager scope).
+   *
+   * @param {Object} [options] - Parameters
+   * @param {string} [options.workerId] - Worker id to fetch sessions for (defaults to the caller's own worker)
+   * @param {string} [options.from] - ISO-8601 range start
+   * @param {string} [options.to] - ISO-8601 range end
+   * @returns {Promise<Object>} result
+   * @returns {Array<Object>} result.sessions - [{id, startedAt, endedAt, onQueueSec, breakSec, doneCount}]
+   *
+   * @example
+   * const { sessions } = await sdk.taskRouter.cc.getSessions({ workerId: 'w1', from: '2026-08-12T00:00:00Z', to: '2026-08-19T00:00:00Z' });
+   */
+  async getSessions(options = {}) {
+    const { workerId, from, to } = options;
+
+    this.sdk.validateParams(
+      { workerId, from, to },
+      {
+        workerId: { type: 'string', required: false },
+        from: { type: 'string', required: false },
+        to: { type: 'string', required: false },
+      },
+    );
+
+    const query = {};
+    if (workerId) query.workerId = workerId;
+    if (from) query.from = from;
+    if (to) query.to = to;
+
+    const result = await this.sdk._fetch('/taskRouter/cc/sessions', 'GET', {
+      query,
+    });
+    return result;
+  }
+
+  /**
+   * Get windowed composite agent rankings (top/struggling) per queue + an
+   * 'all' rollup, scored from sentiment/SLA/volume/acceptance. `struggling`
+   * arrays are only present when the caller has the queue-manager scope
+   * (see `strugglingIncluded` on the result).
+   *
+   * @param {Object} [options] - Parameters
+   * @param {string[]} [options.queueIds] - Queue ids to scope to (must be a subset of the caller's accessible queues). Omit/empty for full scope.
+   * @param {string} options.from - ISO-8601 window start
+   * @param {string} options.to - ISO-8601 window end
+   * @returns {Promise<Object>} result
+   * @returns {Object} result.queues - Per-queue rankings, keyed by queueId: `{ top: [{workerId,name,score}], struggling?: [...] }`
+   * @returns {Object} result.all - Same shape, aggregated across every scoped queue
+   * @returns {boolean} result.strugglingIncluded - Whether `struggling` arrays were included
+   *
+   * @example
+   * const { queues, all } = await sdk.taskRouter.cc.getRankings({
+   *   queueIds: ['q1'],
+   *   from: '2026-08-12T00:00:00Z',
+   *   to: '2026-08-19T00:00:00Z',
+   * });
+   * console.log(all.top[0].name, all.top[0].score);
+   */
+  async getRankings(options = {}) {
+    const { queueIds, from, to } = options;
+
+    this.sdk.validateParams(
+      { queueIds, from, to },
+      {
+        queueIds: { type: 'array', required: false },
+        from: { type: 'string', required: true },
+        to: { type: 'string', required: true },
+      },
+    );
+
+    const query = { from, to };
+    if (queueIds && queueIds.length) {
+      query.queueIds = queueIds.join(',');
+    }
+
+    const result = await this.sdk._fetch('/taskRouter/cc/rankings', 'GET', {
+      query,
+    });
+    return result;
+  }
+
+  /**
+   * Set a queue's composite ranking-weights override. Manager-only
+   * (`taskrouter:queue:manage`). Weights must be integers 0-100 that sum to
+   * exactly 100.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.queueId - Queue id to update
+   * @param {Object} options.weights - `{sentiment, sla, volume, acceptance}` ints summing to 100
+   * @returns {Promise<Object>} result
+   * @returns {string} result.queueId
+   * @returns {Object} result.rankingWeights - The stored weights
+   *
+   * @example
+   * await sdk.taskRouter.cc.setQueueRankingWeights({
+   *   queueId: 'q1',
+   *   weights: { sentiment: 35, sla: 25, volume: 20, acceptance: 20 },
+   * });
+   */
+  async setQueueRankingWeights(options = {}) {
+    const { queueId, weights } = options;
+
+    this.sdk.validateParams(
+      { queueId, weights },
+      {
+        queueId: { type: 'string', required: true },
+        weights: { type: 'object', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/taskRouter/cc/queues/${queueId}/rankingWeights`,
+      'PUT',
+      { body: weights },
+    );
+    return result;
+  }
+
+  /**
+   * Get one agent's Contact Center performance summary (KPIs, per-day
+   * charts, live tasks, on-queue sessions) over a date/date-range, with a
+   * comparison window for deltas. Self allowed; another worker's summary
+   * requires the queue-manager scope.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.workerId - Worker id to summarize
+   * @param {string} options.from - ISO-8601 window start
+   * @param {string} options.to - ISO-8601 window end
+   * @param {string} [options.compareFrom] - ISO-8601 comparison window start (defaults to the preceding equal-length period)
+   * @param {string} [options.compareTo] - ISO-8601 comparison window end
+   * @returns {Promise<Object>} result
+   * @returns {Object} result.kpis - tasksHandled, offersAccepted, avgHandleSec, slaMet, avgSentiment, composite, onQueue
+   * @returns {Array<Object>} result.tasksPerDay - [{date, count}]
+   * @returns {Array<Object>} result.trend - [{date, sentiment, slaPct}]
+   * @returns {Array<Object>} result.liveNow - Current tasks (only when the window includes today)
+   * @returns {Array<Object>} result.sessions - On-queue session log
+   *
+   * @example
+   * const summary = await sdk.taskRouter.cc.getAgentSummary({
+   *   workerId: 'w1',
+   *   from: '2026-08-12T00:00:00Z',
+   *   to: '2026-08-19T00:00:00Z',
+   * });
+   * console.log(summary.kpis.tasksHandled.value);
+   */
+  async getAgentSummary(options = {}) {
+    const { workerId, from, to, compareFrom, compareTo } = options;
+
+    this.sdk.validateParams(
+      { workerId, from, to, compareFrom, compareTo },
+      {
+        workerId: { type: 'string', required: true },
+        from: { type: 'string', required: true },
+        to: { type: 'string', required: true },
+        compareFrom: { type: 'string', required: false },
+        compareTo: { type: 'string', required: false },
+      },
+    );
+
+    const query = { from, to };
+    if (compareFrom) query.compareFrom = compareFrom;
+    if (compareTo) query.compareTo = compareTo;
+
+    const result = await this.sdk._fetch(
+      `/taskRouter/cc/agents/${workerId}/summary`,
+      'GET',
+      { query },
+    );
+    return result;
+  }
+
+  /**
+   * Log a worker into or out of a queue. Manager-only
+   * (`taskrouter:queue:manage`). Mutates the worker's queue membership
+   * through task-router (audited).
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.workerId - Worker id to update
+   * @param {string} options.queueId - Queue id to log in/out of
+   * @param {'login'|'logout'} options.action - Whether to add or remove the queue
+   * @returns {Promise<Object>} result
+   * @returns {string} result.workerId
+   * @returns {string} result.status
+   * @returns {Array<string>} result.queues - The worker's updated queue list
+   *
+   * @example
+   * await sdk.taskRouter.cc.setWorkerQueue({ workerId: 'w1', queueId: 'q1', action: 'login' });
+   */
+  async setWorkerQueue(options = {}) {
+    const { workerId, queueId, action } = options;
+
+    this.sdk.validateParams(
+      { workerId, queueId, action },
+      {
+        workerId: { type: 'string', required: true },
+        queueId: { type: 'string', required: true },
+        action: { type: 'string', required: true },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/taskRouter/cc/workers/${workerId}/queues`,
+      'PUT',
+      { body: { queueId, action } },
+    );
+    return result;
+  }
+
+  /**
+   * Force a worker offline (out of every queue), closing their on-queue
+   * session. Manager-only (`taskrouter:queue:manage`, audited).
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.workerId - Worker id to log out
+   * @returns {Promise<Object>} result
+   * @returns {string} result.workerId
+   * @returns {string} result.status
+   * @returns {Array<string>} result.queues
+   *
+   * @example
+   * await sdk.taskRouter.cc.forceLogoutWorker({ workerId: 'w1' });
+   */
+  async forceLogoutWorker(options = {}) {
+    const { workerId } = options;
+
+    this.sdk.validateParams(
+      { workerId },
+      { workerId: { type: 'string', required: true } },
+    );
+
+    const result = await this.sdk._fetch(
+      `/taskRouter/cc/workers/${workerId}/forceLogout`,
+      'POST',
+      {},
+    );
+    return result;
+  }
+}

package/services/taskRouter/MetricsService.js

@@ -108,4 +108,58 @@ export class MetricsService {
     );
     return result;
   }
+
+  /**
+   * Get windowed queue/company metrics with a compare-window delta, per
+   * queue + an 'all' rollup (avg wait, avg handle, service level, longest
+   * wait, live depth/workers, and a waiting-count sparkline).
+   *
+   * @param {Object} params - Parameters
+   * @param {string[]} [params.queueIds] - Queue ids to scope to. Omit/empty for all queues.
+   * @param {string} params.from - ISO-8601 window start
+   * @param {string} params.to - ISO-8601 window end
+   * @param {string} params.compareFrom - ISO-8601 compare-window start
+   * @param {string} params.compareTo - ISO-8601 compare-window end
+   * @returns {Promise<Object>} result
+   * @returns {Object} result.window - `{from, to}`
+   * @returns {Object} result.compare - `{from, to}`
+   * @returns {Object} result.all - Rollup across every scoped queue (avgWaitSec, avgHandleSec, serviceLevelPct, longestWaitSec, depth, workersAvailable, workersTotal, waitingSparkline, deltas)
+   * @returns {Object} result.queues - Same shape as `result.all`, keyed by queueId
+   *
+   * @example
+   * const { all, queues } = await sdk.taskRouter.metrics.getWindow({
+   *   queueIds: ['q1', 'q2'],
+   *   from: '2026-08-19T22:00:00Z',
+   *   to: '2026-08-19T23:00:00Z',
+   *   compareFrom: '2026-08-19T21:00:00Z',
+   *   compareTo: '2026-08-19T22:00:00Z',
+   * });
+   * console.log(all.serviceLevelPct, all.deltas.serviceLevelPct);
+   */
+  async getWindow(params = {}) {
+    const { queueIds, from, to, compareFrom, compareTo } = params;
+
+    this.sdk.validateParams(
+      { queueIds, from, to, compareFrom, compareTo },
+      {
+        queueIds: { type: 'array', required: false },
+        from: { type: 'string', required: true },
+        to: { type: 'string', required: true },
+        compareFrom: { type: 'string', required: false },
+        compareTo: { type: 'string', required: false },
+      },
+    );
+
+    const query = { from, to };
+    if (queueIds && queueIds.length) query.queueIds = queueIds.join(',');
+    if (compareFrom) query.compareFrom = compareFrom;
+    if (compareTo) query.compareTo = compareTo;
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/metrics/window',
+      'GET',
+      { query },
+    );
+    return result;
+  }
 }

package/services/taskRouter/TaskRouterService.js

@@ -1,6 +1,7 @@
 import { WorkerService } from './WorkerService.js';
 import { TaskService } from './TaskService.js';
 import { MetricsService } from './MetricsService.js';
+import { CCService } from './CCService.js';
 
 export class TaskRouterService {
   constructor(sdk) {
@@ -8,5 +9,6 @@ export class TaskRouterService {
     this.worker = new WorkerService(sdk);
     this.task = new TaskService(sdk);
     this.metrics = new MetricsService(sdk);
+    this.cc = new CCService(sdk);
   }
 }

package/services/video.js

@@ -230,6 +230,7 @@ export class VideoService {
     calendarProvider,
     vocabularyTerms,
     shareOcrEnabled,
+    earlyJoinMinutes,
   }) {
     this.sdk.validateParams(
       {
@@ -259,6 +260,7 @@ export class VideoService {
         calendarProvider,
         vocabularyTerms,
         shareOcrEnabled,
+        earlyJoinMinutes,
       },
       {
         name: { type: 'string', required: false },
@@ -287,6 +289,9 @@ export class VideoService {
         calendarProvider: { type: 'string', required: false },
         vocabularyTerms: { type: 'array', required: false },
         shareOcrEnabled: { type: 'boolean', required: false },
+        // 0 = strict at startTime, 5 = 5-min early window (api rejects
+        // other values); omit for no schedule-window enforcement.
+        earlyJoinMinutes: { type: 'number', required: false },
       },
     );
     const params = {
@@ -317,6 +322,7 @@ export class VideoService {
         calendarProvider,
         vocabularyTerms,
         shareOcrEnabled,
+        earlyJoinMinutes,
       },
     };
     const result = await this.sdk._fetch(`/video`, 'POST', params);
@@ -362,6 +368,8 @@ export class VideoService {
       validationSchema.vocabularyTerms = { type: 'array' };
     if ('shareOcrEnabled' in update)
       validationSchema.shareOcrEnabled = { type: 'boolean' };
+    if ('earlyJoinMinutes' in update)
+      validationSchema.earlyJoinMinutes = { type: 'number' };
 
     if (Object.keys(validationSchema).length > 0) {
       this.sdk.validateParams(update, validationSchema);
@@ -1411,4 +1419,140 @@ export class VideoService {
     );
     return result;
   }
+
+  /**
+   * Get (or lazily create) the calling user's personal meeting room for this
+   * account. Every account user has exactly one; the first call provisions
+   * it server-side.
+   *
+   * NOTE: implemented flat (`getPersonalRoom`/`updatePersonalRoom`/
+   * `regeneratePersonalRoomPin`/`resolvePersonalRoom`) rather than the
+   * `sdk.video.personalRoom.{get,update,regeneratePin}` namespace named in
+   * the meet-hub plan — this file has no existing nested-namespace
+   * precedent, so flat matches every other method here.
+   *
+   * @returns {Promise<{personalRoom: {id: string, slug: string, url: string|null, dialInPin: string, guestsCanStart: boolean}}>}
+   */
+  async getPersonalRoom() {
+    const result = await this.sdk._fetch('/video/personal-room', 'GET');
+    return result;
+  }
+
+  /**
+   * Update the calling user's personal meeting room (slug and/or
+   * guests-can-start). Omit a field to leave it unchanged.
+   *
+   * @param {Object} [update]
+   * @param {string} [update.slug] - New slug (3-32 chars, lowercase/numbers/hyphens, not reserved). 409-equivalent BadRequestError on collision.
+   * @param {boolean} [update.guestsCanStart] - Whether guests can start the room without the host present.
+   * @returns {Promise<{personalRoom: {id: string, slug: string, url: string|null, dialInPin: string, guestsCanStart: boolean}}>}
+   */
+  async updatePersonalRoom({ slug, guestsCanStart, password } = {}) {
+    const validationSchema = {};
+    if (slug !== undefined) validationSchema.slug = { type: 'string' };
+    if (guestsCanStart !== undefined)
+      validationSchema.guestsCanStart = { type: 'boolean' };
+    // Static room passcode — 4-6 digits (api-enforced); applied to every
+    // session the room link mints.
+    if (password !== undefined) validationSchema.password = { type: 'string' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(
+        { slug, guestsCanStart, password },
+        validationSchema,
+      );
+    }
+
+    const body = {};
+    if (slug !== undefined) body.slug = slug;
+    if (guestsCanStart !== undefined) body.guestsCanStart = guestsCanStart;
+    if (password !== undefined) body.password = password;
+
+    const params = { body };
+    const result = await this.sdk._fetch(
+      '/video/personal-room',
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Regenerate the dial-in PIN for the calling user's personal meeting room.
+   *
+   * @returns {Promise<{personalRoom: {id: string, dialInPin: string}}>}
+   */
+  async regeneratePersonalRoomPin() {
+    const result = await this.sdk._fetch(
+      '/video/personal-room/regenerate-pin',
+      'POST',
+      {},
+    );
+    return result;
+  }
+
+  /**
+   * Live availability dry-run for a personal-room slug (settings editor).
+   *
+   * @param {string} slug - Candidate slug.
+   * @returns {Promise<{slug: string, available: boolean, reason?: 'invalid'|'taken'}>}
+   */
+  async checkPersonalRoomSlug(slug) {
+    this.sdk.validateParams(
+      { slug },
+      { slug: { type: 'string', required: true } },
+    );
+    const result = await this.sdk._fetch(
+      `/video/personal-room/slug-available?slug=${encodeURIComponent(slug)}`,
+      'GET',
+      {},
+    );
+    return result;
+  }
+
+  /**
+   * Regenerate the static web passcode for the calling user's personal
+   * meeting room (a separate secret from the dial-in PIN). Sessions minted
+   * after this use the new value.
+   *
+   * @returns {Promise<{personalRoom: {id: string, password: string}}>}
+   */
+  async regeneratePersonalRoomPassword() {
+    const result = await this.sdk._fetch(
+      '/video/personal-room/regenerate-password',
+      'POST',
+      {},
+    );
+    return result;
+  }
+
+  /**
+   * Resolve a personal-room slug to a live session (join page). Guest-capable
+   * — mints/claims a fresh meeting if none is live, or returns the already
+   * -claimed session; if the caller is an unauthenticated guest and the room
+   * doesn't allow guests to start, returns `waitingForHost: true` instead.
+   * Guests only receive `password` when they supply the room's static
+   * passcode; otherwise `passwordRequired: true` is returned and the join
+   * page should prompt.
+   *
+   * @param {string} slug - The personal room's slug.
+   * @param {{password?: string}} [options] - The room's static passcode, when known.
+   * @returns {Promise<{claimed: boolean, meetingId?: string, friendlyName?: string, password?: string, passwordRequired?: boolean, waitingForHost?: boolean}>}
+   */
+  async resolvePersonalRoom(slug, { password } = {}) {
+    this.sdk.validateParams(
+      { slug, password },
+      {
+        slug: { type: 'string', required: true },
+        password: { type: 'string', required: false },
+      },
+    );
+
+    const result = await this.sdk._fetch(
+      `/video/personal-room/resolve/${slug}`,
+      'POST',
+      { body: { password } },
+    );
+    return result;
+  }
 }