@unboundcx/sdk 2.8.6 → 2.8.7

package/services/taskRouter/WorkerService.js

@@ -0,0 +1,394 @@
+export class WorkerService {
+  constructor(sdk) {
+    this.sdk = sdk;
+  }
+
+  /**
+   * Create a worker in the task router system
+   * Creates a new worker for handling tasks such as phone calls, chat, or email.
+   * If userId is not provided, it will use the authenticated user's ID from the session.
+   *
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.userId] - The user ID to create a worker for. If not provided, uses the authenticated user's ID
+   * @returns {Promise<Object>} Object containing the created worker ID
+   * @returns {string} result.workerId - The unique identifier for the created worker
+   *
+   * @example
+   * // Create worker for authenticated user
+   * const result = await sdk.taskRouter.worker.create();
+   * console.log(result.workerId); // "0860002026012400000006665842155429980"
+   *
+   * @example
+   * // Create worker for specific user
+   * const result = await sdk.taskRouter.worker.create({ userId: '123456' });
+   * console.log(result.workerId); // "0860002026012400000006665842155429980"
+   */
+  async create(options = {}) {
+    const { userId } = options;
+
+    this.sdk.validateParams(
+      { userId },
+      {
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: {},
+    };
+
+    if (userId) {
+      params.body.userId = userId;
+    }
+
+    const result = await this.sdk._fetch('/taskRouter/worker', 'POST', params);
+    return result;
+  }
+
+  /**
+   * Get worker information from the task router system
+   * Retrieves the worker details for a specific user.
+   * If userId is not provided, it will use the authenticated user's ID from the session.
+   *
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.userId] - The user ID to get worker information for. If not provided, uses the authenticated user's ID
+   * @returns {Promise<Object>} Object containing the worker information
+   *
+   * @example
+   * // Get worker for authenticated user
+   * const worker = await sdk.taskRouter.worker.get();
+   * console.log(worker);
+   *
+   * @example
+   * // Get worker for specific user
+   * const worker = await sdk.taskRouter.worker.get({ userId: '123456' });
+   * console.log(worker);
+   */
+  async get(options = {}) {
+    const { userId } = options;
+
+    this.sdk.validateParams(
+      { userId },
+      {
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {};
+
+    if (userId) {
+      params.query = { userId };
+    }
+
+    const result = await this.sdk._fetch('/taskRouter/worker', 'GET', params);
+    return result;
+  }
+
+  /**
+   * Set worker status to available in the task router system
+   * Makes a worker available to receive tasks such as phone calls, chat, or email.
+   * You can specify either workerId or userId. If neither is provided, it will use the authenticated user's ID.
+   *
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.workerId] - The worker ID to set as available
+   * @param {string} [options.userId] - The user ID to set as available. If not provided, uses the authenticated user's ID
+   * @returns {Promise<Object>} Object containing the worker ID
+   * @returns {string} result.workerId - The unique identifier for the worker
+   *
+   * @example
+   * // Set authenticated user's worker to available
+   * const result = await sdk.taskRouter.worker.setAvailable();
+   * console.log(result.workerId);
+   *
+   * @example
+   * // Set specific worker to available by workerId
+   * const result = await sdk.taskRouter.worker.setAvailable({ workerId: '0860002026012400000006665842155429980' });
+   *
+   * @example
+   * // Set specific user's worker to available by userId
+   * const result = await sdk.taskRouter.worker.setAvailable({ userId: '123456' });
+   */
+  async setAvailable(options = {}) {
+    const { workerId, userId } = options;
+
+    this.sdk.validateParams(
+      { workerId, userId },
+      {
+        workerId: { type: 'string', required: false },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: {},
+    };
+
+    if (workerId) {
+      params.body.workerId = workerId;
+    }
+
+    if (userId) {
+      params.body.userId = userId;
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/worker/avaliable',
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Set worker status to offline in the task router system
+   * Makes a worker offline and unavailable to receive tasks.
+   * You can specify either workerId or userId. If neither is provided, it will use the authenticated user's ID.
+   *
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.workerId] - The worker ID to set as offline
+   * @param {string} [options.userId] - The user ID to set as offline. If not provided, uses the authenticated user's ID
+   * @returns {Promise<Object>} Object containing the worker ID
+   * @returns {string} result.workerId - The unique identifier for the worker
+   *
+   * @example
+   * // Set authenticated user's worker to offline
+   * const result = await sdk.taskRouter.worker.setOffline();
+   * console.log(result.workerId);
+   *
+   * @example
+   * // Set specific worker to offline by workerId
+   * const result = await sdk.taskRouter.worker.setOffline({ workerId: '0860002026012400000006665842155429980' });
+   *
+   * @example
+   * // Set specific user's worker to offline by userId
+   * const result = await sdk.taskRouter.worker.setOffline({ userId: '123456' });
+   */
+  async setOffline(options = {}) {
+    const { workerId, userId } = options;
+
+    this.sdk.validateParams(
+      { workerId, userId },
+      {
+        workerId: { type: 'string', required: false },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: {},
+    };
+
+    if (workerId) {
+      params.body.workerId = workerId;
+    }
+
+    if (userId) {
+      params.body.userId = userId;
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/worker/offline',
+      '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.
+   * If userId is not provided, it will use the authenticated user's ID from the session.
+   *
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.userId] - The user ID to auto-login queues for. If not provided, uses the authenticated user's ID
+   * @returns {Promise<Object>} Object containing the userId that was processed
+   * @returns {string} result.userId - The user ID that had auto-login queues processed
+   *
+   * @example
+   * // Auto-login queues for authenticated user
+   * const result = await sdk.taskRouter.worker.queueAutoLogin();
+   * console.log(result.userId);
+   *
+   * @example
+   * // Auto-login queues for specific user
+   * const result = await sdk.taskRouter.worker.queueAutoLogin({ userId: '123456' });
+   * console.log(result.userId);
+   */
+  async queueAutoLogin(options = {}) {
+    const { userId } = options;
+
+    this.sdk.validateParams(
+      { userId },
+      {
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: {},
+    };
+
+    if (userId) {
+      params.body.userId = userId;
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/worker/queueAutoLogin',
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Logout from all queues for a worker
+   * Logs the worker out of all queues they are currently logged into.
+   * If userId is not provided, it will use the authenticated user's ID from the session.
+   *
+   * @param {Object} [options] - Optional parameters
+   * @param {string} [options.userId] - The user ID to logout from all queues. If not provided, uses the authenticated user's ID
+   * @returns {Promise<Object>} Object containing the userId that was processed
+   * @returns {string} result.userId - The user ID that had all queues logged out
+   *
+   * @example
+   * // Logout from all queues for authenticated user
+   * const result = await sdk.taskRouter.worker.queueLogoutAll();
+   * console.log(result.userId);
+   *
+   * @example
+   * // Logout from all queues for specific user
+   * const result = await sdk.taskRouter.worker.queueLogoutAll({ userId: '123456' });
+   * console.log(result.userId);
+   */
+  async queueLogoutAll(options = {}) {
+    const { userId } = options;
+
+    this.sdk.validateParams(
+      { userId },
+      {
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: {},
+    };
+
+    if (userId) {
+      params.body.userId = userId;
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/worker/queueLogoutAll',
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Login to a specific queue
+   * Logs the worker into a specific queue by queueId.
+   * If userId is not provided, it will use the authenticated user's ID from the session.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.queueId - The queue ID to login to (required)
+   * @param {string} [options.userId] - The user ID to login. If not provided, uses the authenticated user's ID
+   * @returns {Promise<Object>} Object containing the userId that was processed
+   * @returns {string} result.userId - The user ID that logged into the queue
+   *
+   * @example
+   * // Login to a queue for authenticated user
+   * const result = await sdk.taskRouter.worker.queueLogin({ queueId: 'queue123' });
+   * console.log(result.userId);
+   *
+   * @example
+   * // Login to a queue for specific user
+   * const result = await sdk.taskRouter.worker.queueLogin({
+   *   queueId: 'queue123',
+   *   userId: '123456'
+   * });
+   * console.log(result.userId);
+   */
+  async queueLogin(options = {}) {
+    const { queueId, userId } = options;
+
+    this.sdk.validateParams(
+      { queueId, userId },
+      {
+        queueId: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: {
+        queueId,
+      },
+    };
+
+    if (userId) {
+      params.body.userId = userId;
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/worker/queueLogin',
+      'PUT',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Logout from a specific queue
+   * Logs the worker out of a specific queue by queueId.
+   * If userId is not provided, it will use the authenticated user's ID from the session.
+   *
+   * @param {Object} options - Parameters
+   * @param {string} options.queueId - The queue ID to logout from (required)
+   * @param {string} [options.userId] - The user ID to logout. If not provided, uses the authenticated user's ID
+   * @returns {Promise<Object>} Object containing the userId that was processed
+   * @returns {string} result.userId - The user ID that logged out of the queue
+   *
+   * @example
+   * // Logout from a queue for authenticated user
+   * const result = await sdk.taskRouter.worker.queueLogout({ queueId: 'queue123' });
+   * console.log(result.userId);
+   *
+   * @example
+   * // Logout from a queue for specific user
+   * const result = await sdk.taskRouter.worker.queueLogout({
+   *   queueId: 'queue123',
+   *   userId: '123456'
+   * });
+   * console.log(result.userId);
+   */
+  async queueLogout(options = {}) {
+    const { queueId, userId } = options;
+
+    this.sdk.validateParams(
+      { queueId, userId },
+      {
+        queueId: { type: 'string', required: true },
+        userId: { type: 'string', required: false },
+      },
+    );
+
+    const params = {
+      body: {
+        queueId,
+      },
+    };
+
+    if (userId) {
+      params.body.userId = userId;
+    }
+
+    const result = await this.sdk._fetch(
+      '/taskRouter/worker/queueLogout',
+      'PUT',
+      params,
+    );
+    return result;
+  }
+}

package/services/taskRouter.js

@@ -0,0 +1,6 @@
+// Import all task router services
+import { TaskRouterService } from './taskRouter/TaskRouterService.js';
+import { WorkerService } from './taskRouter/WorkerService.js';
+
+// Re-export all services
+export { TaskRouterService, WorkerService };

package/services/video.js

@@ -316,6 +316,10 @@ export class VideoService {
       validationSchema.startMicrophoneMuted = { type: 'boolean' };
     if ('startMicrophoneMutedAfter' in update)
       validationSchema.startMicrophoneMutedAfter = { type: 'number' };
+    if ('startRecordingOn' in update)
+      validationSchema.startRecordingOn = { type: 'boolean' };
+    if ('startTranscribingOn' in update)
+      validationSchema.startTranscribingOn = { type: 'boolean' };
     if ('enableChat' in update)
       validationSchema.enableChat = { type: 'boolean' };
 
@@ -378,18 +382,22 @@ export class VideoService {
     return result;
   }
 
-  async describe(roomId) {
+  async describe(roomId, { includeParticipants = false }) {
     this.sdk.validateParams(
-      { roomId },
+      { roomId, includeParticipants },
       {
         roomId: { type: 'string', required: true },
+        includeParticipants: { type: 'boolean', required: false },
       },
     );
 
-    const params = {};
+    const params = {
+      query: {
+        includeParticipants,
+      },
+    };
 
-    const result = await this.sdk._fetch(`/video/${roomId}`, 'GET', params);
-    return result;
+    return await this.sdk._fetch(`/video/${roomId}`, 'GET', params);
   }
 
   async listMeetings(options = {}) {
@@ -730,4 +738,136 @@ export class VideoService {
     );
     return result;
   }
+
+  /**
+   * Create or update user's default video room settings
+   * @param {Object} settings - Video room settings
+   * @param {string} [settings.userId] - Optional userId to update settings for another user
+   * @param {boolean} [settings.waitingRoom] - Enable waiting room by default
+   * @param {boolean} [settings.enableChat] - Enable chat by default
+   * @param {number} [settings.maxVideoResolution] - Max video resolution (1080 or 720)
+   * @param {boolean} [settings.startCameraMuted] - Start with camera muted
+   * @param {number} [settings.startCameraMutedAfter] - Auto-mute cameras after N participants
+   * @param {boolean} [settings.startMicrophoneMuted] - Start with microphone muted
+   * @param {number} [settings.startMicrophoneMutedAfter] - Auto-mute mics after N participants
+   * @param {number} [settings.endMeetingWithoutHostTimeLimit] - Time limit to end meeting without host (seconds)
+   * @param {boolean} [settings.startRecordingOn] - Start recording automatically
+   * @param {boolean} [settings.startTranscribingOn] - Start transcribing automatically
+   * @param {Array<string>} [settings.hosts] - Default hosts to add to every meeting
+   * @param {Array<string>} [settings.participants] - Default participants to add to every meeting
+   * @returns {Promise} Created/updated settings
+   */
+  async createUserSettings(settings = {}) {
+    // Validate optional parameters
+    const validationSchema = {};
+    if ('userId' in settings) validationSchema.userId = { type: 'string' };
+    if ('waitingRoom' in settings)
+      validationSchema.waitingRoom = { type: 'boolean' };
+    if ('enableChat' in settings)
+      validationSchema.enableChat = { type: 'boolean' };
+    if ('maxVideoResolution' in settings)
+      validationSchema.maxVideoResolution = { type: 'number' };
+    if ('startCameraMuted' in settings)
+      validationSchema.startCameraMuted = { type: 'boolean' };
+    if ('startCameraMutedAfter' in settings)
+      validationSchema.startCameraMutedAfter = { type: 'number' };
+    if ('startMicrophoneMuted' in settings)
+      validationSchema.startMicrophoneMuted = { type: 'boolean' };
+    if ('startMicrophoneMutedAfter' in settings)
+      validationSchema.startMicrophoneMutedAfter = { type: 'number' };
+    if ('endMeetingWithoutHostTimeLimit' in settings)
+      validationSchema.endMeetingWithoutHostTimeLimit = { type: 'number' };
+    if ('startRecordingOn' in settings)
+      validationSchema.startRecordingOn = { type: 'boolean' };
+    if ('startTranscribingOn' in settings)
+      validationSchema.startTranscribingOn = { type: 'boolean' };
+    if ('hosts' in settings) validationSchema.hosts = { type: 'array' };
+    if ('participants' in settings)
+      validationSchema.participants = { type: 'array' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(settings, validationSchema);
+    }
+
+    const params = {
+      body: settings,
+    };
+
+    const result = await this.sdk._fetch(
+      '/video/settings/user',
+      'POST',
+      params,
+    );
+    return result;
+  }
+
+  /**
+   * Update user's default video room settings
+   * This is an alias for createOrUpdateUserSettings
+   * @param {Object} settings - Video room settings to update
+   * @returns {Promise} Updated settings
+   */
+  async updateUserSettings(settings = {}) {
+    // Validate optional parameters (same as createOrUpdateUserSettings)
+    const validationSchema = {};
+    if ('userId' in settings) validationSchema.userId = { type: 'string' };
+    if ('waitingRoom' in settings)
+      validationSchema.waitingRoom = { type: 'boolean' };
+    if ('enableChat' in settings)
+      validationSchema.enableChat = { type: 'boolean' };
+    if ('maxVideoResolution' in settings)
+      validationSchema.maxVideoResolution = { type: 'number' };
+    if ('startCameraMuted' in settings)
+      validationSchema.startCameraMuted = { type: 'boolean' };
+    if ('startCameraMutedAfter' in settings)
+      validationSchema.startCameraMutedAfter = { type: 'number' };
+    if ('startMicrophoneMuted' in settings)
+      validationSchema.startMicrophoneMuted = { type: 'boolean' };
+    if ('startMicrophoneMutedAfter' in settings)
+      validationSchema.startMicrophoneMutedAfter = { type: 'number' };
+    if ('endMeetingWithoutHostTimeLimit' in settings)
+      validationSchema.endMeetingWithoutHostTimeLimit = { type: 'number' };
+    if ('startRecordingOn' in settings)
+      validationSchema.startRecordingOn = { type: 'boolean' };
+    if ('startTranscribingOn' in settings)
+      validationSchema.startTranscribingOn = { type: 'boolean' };
+    if ('hosts' in settings) validationSchema.hosts = { type: 'array' };
+    if ('participants' in settings)
+      validationSchema.participants = { type: 'array' };
+
+    if (Object.keys(validationSchema).length > 0) {
+      this.sdk.validateParams(settings, validationSchema);
+    }
+
+    const params = {
+      body: settings,
+    };
+
+    const result = await this.sdk._fetch('/video/settings/user', 'PUT', params);
+    return result;
+  }
+
+  /**
+   * Get user's default video room settings
+   * @param {string} [userId] - Optional userId to get settings for another user
+   * @returns {Promise} User's video room settings
+   */
+  async getUserSettings(userId = null) {
+    const params = {
+      query: {},
+    };
+
+    if (userId) {
+      this.sdk.validateParams(
+        { userId },
+        {
+          userId: { type: 'string', required: true },
+        },
+      );
+      params.query.userId = userId;
+    }
+
+    const result = await this.sdk._fetch('/video/settings/user', 'GET', params);
+    return result;
+  }
 }