@webex/plugin-meetings 3.0.0-beta.7 → 3.0.0-beta.71

package/src/common/logs/logger-proxy.ts

@@ -0,0 +1,44 @@
+/* eslint-disable no-unused-vars */
+import LoggerConfig from './logger-config';
+
+const LoggerProxy: any = {
+  logger: {
+    info: (args) => {
+      console.error('LoggerProxy->info#NO LOGGER DEFINED');
+    },
+    log: (args) => {
+      console.error('LoggerProxy->log#NO LOGGER DEFINED');
+    },
+    error: (args) => {
+      console.error('LoggerProxy->error#NO LOGGER DEFINED');
+    },
+    warn: (args) => {
+      console.error('LoggerProxy->warn#NO LOGGER DEFINED');
+    },
+    trace: (args) => {
+      console.error('LoggerProxy->trace#NO LOGGER DEFINED');
+    },
+    debug: (args) => {
+      console.error('LoggerProxy->debug#NO LOGGER DEFINED');
+    },
+  },
+};
+
+LoggerProxy.set = (logger) => {
+  if (!LoggerConfig.enable) {
+    LoggerProxy.logger = {
+      info: () => {},
+      log: () => {},
+      error: () => {},
+      warn: () => {},
+      trace: () => {},
+      debug: () => {},
+    };
+  } else {
+    LoggerProxy.logger = logger;
+  }
+};
+
+LoggerProxy.get = () => LoggerProxy.logger;
+
+export default LoggerProxy;

package/src/common/logs/{request.js → request.ts}

@@ -6,13 +6,15 @@ import LoggerProxy from './logger-proxy';
  * @class LogsRequest
  */
 export default class LogsRequest {
+  webex: any;
+
   /**
    *
    * @param {Object} options
    * @param {Object} options.webex Webex SDK instance
    * @param {ClientMetrics} metrics
    */
-  constructor(options) {
+  constructor(options: {webex: object}) {
     this.webex = options.webex;
   }
 
@@ -28,20 +30,31 @@ export default class LogsRequest {
    * @returns {Promise.<String>} Feedback ID
    * @memberof LogsRequest
    */
-  async uploadLogs(options = {}) {
+  async uploadLogs(
+    options: {
+      feedbackId?: string;
+      locusId?: string;
+      correlationId?: string;
+      callStart?: string;
+      meetingId?: string;
+    } = {}
+  ) {
     const id = options.feedbackId || uuid.v4();
-    const {
-      locusId, correlationId, meetingId, callStart
-    } = options;
+    const {locusId, correlationId, meetingId, callStart} = options;
 
-    LoggerProxy.logger.info(`Logs:request#uploadLogs --> uploading user logs for feedbackId: ${id}`);
+    LoggerProxy.logger.info(
+      `Logs:request#uploadLogs --> uploading user logs for feedbackId: ${id}`
+    );
 
     try {
       await this.webex.internal.support.submitLogs({
-        feedbackId: id, locusId, correlationId, meetingId, callStart
+        feedbackId: id,
+        locusId,
+        correlationId,
+        meetingId,
+        callStart,
       });
-    }
-    catch (error) {
+    } catch (error) {
       LoggerProxy.logger.error('Logs:request#uploadLogs --> uploading user logs failed', error);
 
       return Promise.reject(error);

package/src/common/queue.ts

@@ -23,7 +23,7 @@ export default class SimpleQueue {
    * @param {object} item
    * @returns {undefined}
    */
-  enqueue(item) {
+  enqueue(item: object) {
     this.queue.push(item);
   }
 
@@ -48,4 +48,3 @@ export default class SimpleQueue {
     return this.queue.length;
   }
 }
-

package/src/{config.js → config.ts}

@@ -1,5 +1,6 @@
 import {
-  deviceType
+  // @ts-ignore
+  deviceType,
 } from '@webex/common';
 
 export default {
@@ -15,7 +16,7 @@ export default {
       receiveVideo: true,
       pstn: false,
       sendShare: false,
-      receiveShare: false
+      receiveShare: false,
     },
     reconnection: {
       enabled: false,
@@ -24,7 +25,7 @@ export default {
       // Timeout duration to wait for ICE to reconnect if a disconnect is received.
       iceReconnectionTimeout: 10000,
       // Amount of times attempting to rejoin a meeting during reconnect
-      maxRejoinAttempts: 3
+      maxRejoinAttempts: 3,
     },
     stats: {
       // Enable the webrtc stats analyzer that emits quality degradation events
@@ -40,7 +41,7 @@ export default {
       // Once packet loss hits this ratio, the video will downgrade
       videoPacketLossRatioThreshold: 9, // comparison of packets lost / packets received
       rttThreshold: 500, // 500 ms noticeable quality lag begins based on bandwidth of user
-      jitterThreshold: 500 // 500 ms noticeable quality lag begins based on bandwidth of user
+      jitterThreshold: 500, // 500 ms noticeable quality lag begins based on bandwidth of user
     },
     metrics: {
       // change to your client name else data will be muddled
@@ -54,30 +55,30 @@ export default {
       mqaMetricsInterval: 60000,
       // send to cisco internal MQA data automatically
       // we already send CA
-      autoSendMQA: true
+      autoSendMQA: true,
     },
     logging: {
       enable: true,
-      verboseEvents: true
+      verboseEvents: true,
     },
     resolution: {
       maxWidth: 1280,
       maxHeight: 720,
       idealWidth: 1280,
-      idealHeight: 720
+      idealHeight: 720,
     },
     screenResolution: {
       maxWidth: 1920,
       maxHeight: 1080,
       idealWidth: 1920,
-      idealHeight: 1080
+      idealHeight: 1080,
     },
     bandwidth: {
       // please note, these are the maximum bandwidth values
       // the server supports, minimums have to be tested
       audio: 64000,
       video: 4000000,
-      startBitrate: 2000
+      startBitrate: 2000,
     },
     screenFrameRate: 10,
     videoShareFrameRate: 30,
@@ -87,11 +88,15 @@ export default {
     enableRtx: true,
     receiveTranscription: false,
     enableExtmap: false,
+    enableAutomaticLLM: false,
     experimental: {
       enableMediaNegotiatedEvent: false,
       enableUnifiedMeetings: false,
       enableAdhocMeetings: false,
-      enableTurnDiscovery: false,
-    }
-  }
+      enableTurnDiscovery: true,
+    },
+    degradationPreferences: {
+      maxMacroblocksLimit: 8192,
+    },
+  },
 };

package/src/constants.ts

@@ -1,3 +1,4 @@
+// @ts-ignore
 import {hydraTypes} from '@webex/common';
 
 // *********** LOWERCASE / CAMELCASE STRINGS ************
@@ -10,6 +11,7 @@ export const ANSWER = 'answer';
 
 export const CALL = 'call';
 export const CORRELATION_ID = 'correlationId';
+export const MEETINGNUMBER = 'meetingNumber';
 export const CONVERSATION_URL = 'conversationUrl';
 export const CALENDAR = 'calendar';
 export const CALENDAR_EVENTS_API = 'calendarEvents';
@@ -92,6 +94,7 @@ export const _JOINED_ = 'JOINED';
 
 export const _LOCUS_ID_ = 'LOCUS_ID';
 export const _LEFT_ = 'LEFT';
+export const _MOVED_ = 'MOVED';
 
 export const _MEETING_LINK_ = 'MEETING_LINK';
 export const _MEETING_UUID_ = 'MEETING_UUID';
@@ -287,6 +290,7 @@ export const EVENT_TRIGGERS = {
   MEETING_STOPPED_RECORDING: 'meeting:recording:stopped',
   MEETING_STARTED_RECEIVING_TRANSCRIPTION: 'meeting:receiveTranscription:started',
   MEETING_STOPPED_RECEIVING_TRANSCRIPTION: 'meeting:receiveTranscription:stopped',
+  MEETING_RECEIVE_REACTIONS: 'meeting:receiveReactions',
   MEETING_PAUSED_RECORDING: 'meeting:recording:paused',
   MEETING_RESUMED_RECORDING: 'meeting:recording:resumed',
   MEETING_ADDED: 'meeting:added',
@@ -295,6 +299,8 @@ export const EVENT_TRIGGERS = {
   MEETING_RINGING_STOP: 'meeting:ringingStop',
   MEETING_SELF_LOBBY_WAITING: 'meeting:self:lobbyWaiting',
   MEETING_SELF_GUEST_ADMITTED: 'meeting:self:guestAdmitted',
+  MEETING_SELF_VIDEO_MUTED_BY_OTHERS: 'meeting:self:videoMutedByOthers',
+  MEETING_SELF_VIDEO_UNMUTED_BY_OTHERS: 'meeting:self:videoUnmutedByOthers',
   MEETING_SELF_MUTED_BY_OTHERS: 'meeting:self:mutedByOthers',
   MEETING_SELF_UNMUTED_BY_OTHERS: 'meeting:self:unmutedByOthers',
   MEETING_SELF_REQUESTED_TO_UNMUTE: 'meeting:self:requestedToUnmute',
@@ -303,7 +309,11 @@ export const EVENT_TRIGGERS = {
   MEETING_SELF_IS_SHARING_BLOCKED: 'meeting:self:isSharingBlocked',
   MEETING_CONTROLS_LAYOUT_UPDATE: 'meeting:layout:update',
   MEETING_ENTRY_EXIT_TONE_UPDATE: 'meeting:entryExitTone:update',
+  MEETING_BREAKOUTS_UPDATE: 'meeting:breakouts:update',
+  MEETING_BREAKOUTS_CLOSING: 'meeting:breakouts:closing',
+  MEETING_BREAKOUTS_MESSAGE: 'meeting:breakouts:message',
   MEMBERS_UPDATE: 'members:update',
+  MEMBERS_CLEAR: 'members:clear',
   MEMBERS_CONTENT_UPDATE: 'members:content:update',
   MEMBERS_HOST_UPDATE: 'members:host:update',
   MEMBERS_SELF_UPDATE: 'members:self:update',
@@ -330,7 +340,7 @@ export const EVENT_TRIGGERS = {
   REMOTE_VIDEO_SOURCE_COUNT_CHANGED: 'media:remoteVideoSourceCountChanged',
   REMOTE_AUDIO_SOURCE_COUNT_CHANGED: 'media:remoteAudioSourceCountChanged',
   REMOTE_MEDIA_AUDIO_CREATED: 'media:remoteAudio:created',
-  REMOTE_MEDIA_SCREEN_SHARE_AUDIO_CREATED: 'media:remoteScrenShareAudio:created',
+  REMOTE_MEDIA_SCREEN_SHARE_AUDIO_CREATED: 'media:remoteScreenShareAudio:created',
   REMOTE_MEDIA_VIDEO_LAYOUT_CHANGED: 'media:remoteVideo:layoutChanged',
 };
 
@@ -372,6 +382,7 @@ export const CALL_REMOVED_REASON = {
 export const SHARE_STOPPED_REASON = {
   SELF_STOPPED: 'SELF_STOPPED',
   MEETING_REJOIN: 'MEETING_REJOIN',
+  MEDIA_RECONNECTION: 'MEDIA_RECONNECTION',
 };
 
 export const EVENTS = {
@@ -447,6 +458,11 @@ export const ERROR_DICTIONARY = {
     MESSAGE: 'Captcha is required.',
     CODE: 8,
   },
+  BREAKOUT_EDIT: {
+    NAME: 'BreakoutEditLockedError',
+    MESSAGE: 'Edit lock token mismatch',
+    CODE: 9,
+  },
 };
 
 export const FLOOR_ACTION = {
@@ -468,6 +484,7 @@ export const HTTP_VERBS = {
   POST: 'POST',
   GET: 'GET',
   PATCH: 'PATCH',
+  DELETE: 'DELETE',
 };
 
 // https://developer.mozilla.org/en-US/docs/Web/API/RTCPeerConnection/iceGatheringState
@@ -513,15 +530,59 @@ export const LOCUS = {
   SYNCDEBUG: 'sync_debug',
 };
 
+export const BREAKOUTS = {
+  STATUS: {
+    CLOSING: 'CLOSING',
+    CLOSED: 'CLOSED',
+    PENDING: 'PENDING',
+    OPEN: 'OPEN',
+  },
+  EVENTS: {
+    BREAKOUTS_CLOSING: 'BREAKOUTS_CLOSING',
+    MESSAGE: 'MESSAGE',
+    MEMBERS_UPDATE: 'MEMBERS_UPDATE',
+  },
+  SESSION_TYPES: {
+    MAIN: 'MAIN',
+    BREAKOUT: 'BREAKOUT',
+  },
+  SESSION_STATES: {
+    ACTIVE: 'active',
+    ASSIGNED: 'assigned',
+    ALLOWED: 'allowed',
+    ASSIGNED_CURRENT: 'assignedCurrent',
+    REQUESTED: 'requested',
+  },
+  BREAKOUTS_SUPPORTED: 'BREAKOUTS_SUPPORTED',
+  ACTION: {
+    START: 'START',
+    CLOSE: 'CLOSE',
+    DELETE: 'DELETE',
+  },
+  ERROR_CODE: {
+    EDIT_LOCK_TOKEN_MISMATCH: 201409024,
+    EDIT_NOT_AUTHORIZED: 201403007,
+  },
+  DEFAULT_DURATION: 60000,
+  EDIT_LOCK_STATUS: {
+    LOCKED: 'LOCKED',
+    NOT_LOCKED: 'NOT_LOCKED',
+    UNKNOWN: 'UNKNOWN',
+  },
+  DEFAULT_TTL: 30,
+};
+
 export const LOCUSINFO = {
   EVENTS: {
     CONTROLS_MEETING_LAYOUT_UPDATED: 'CONTROLS_MEETING_LAYOUT_UPDATED',
     CONTROLS_RECORDING_UPDATED: 'CONTROLS_RECORDING_UPDATED',
     CONTROLS_MEETING_TRANSCRIBE_UPDATED: 'CONTROLS_MEETING_TRANSCRIBE_UPDATED',
+    CONTROLS_MEETING_BREAKOUT_UPDATED: 'CONTROLS_MEETING_BREAKOUT_UPDATED',
     CONTROLS_MEETING_CONTAINER_UPDATED: 'CONTROLS_MEETING_CONTAINER_UPDATED',
     CONTROLS_ENTRY_EXIT_TONE_UPDATED: 'CONTROLS_ENTRY_EXIT_TONE_UPDATED',
     SELF_UNADMITTED_GUEST: 'SELF_UNADMITTED_GUEST',
     SELF_ADMITTED_GUEST: 'SELF_ADMITTED_GUEST',
+    SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED: 'SELF_REMOTE_VIDEO_MUTE_STATUS_UPDATED',
     SELF_REMOTE_MUTE_STATUS_UPDATED: 'SELF_REMOTE_MUTE_STATUS_UPDATED',
     LOCAL_UNMUTE_REQUESTED: 'LOCAL_UNMUTE_REQUESTED',
     LOCAL_UNMUTE_REQUIRED: 'LOCAL_UNMUTE_REQUIRED',
@@ -539,6 +600,10 @@ export const LOCUSINFO = {
     EMBEDDED_APPS_UPDATED: 'EMBEDDED_APPS_UPDATED',
     SELF_CANNOT_VIEW_PARTICIPANT_LIST_CHANGE: 'SELF_CANNOT_VIEW_PARTICIPANT_LIST_CHANGE',
     SELF_IS_SHARING_BLOCKED_CHANGE: 'SELF_IS_SHARING_BLOCKED_CHANGE',
+    SELF_MEETING_BREAKOUTS_CHANGED: 'SELF_MEETING_BREAKOUTS_CHANGED',
+    MEDIA_INACTIVITY: 'MEDIA_INACTIVITY',
+    LINKS_SERVICES: 'LINKS_SERVICES',
+    SELF_MODERATOR_OR_COHOST_UPGRADE: 'SELF_MODERATOR_OR_COHOST_UPGRADE',
   },
 };
 
@@ -551,6 +616,9 @@ export const LOCUSEVENT = {
   // delta events
   DIFFERENCE: 'locus.difference',
 
+  // Breakout sessions
+  BREAKOUT_ROSTER: 'breakout.roster',
+
   // screen sharing
   FLOOR_GRANTED: 'locus.floor_granted',
   FLOOR_RELEASED: 'locus.floor_released',
@@ -721,13 +789,33 @@ export const DISPLAY_HINTS = {
   DISPLAY_NON_ENGLISH_ASR: 'DISPLAY_NON_ENGLISH_ASR',
   TRANSCRIPTION_CONTROL_START: 'TRANSCRIPTION_CONTROL_START',
   TRANSCRIPTION_CONTROL_STOP: 'TRANSCRIPTION_CONTROL_STOP',
+  SAVE_TRANSCRIPTS_ENABLED: 'SAVE_TRANSCRIPTS_ENABLED',
   WEBEX_ASSISTANT_STATUS_ACTIVE: 'WEBEX_ASSISTANT_STATUS_ACTIVE',
   WAITING_FOR_OTHERS: 'WAITING_FOR_OTHERS',
+  ENABLE_REACTIONS: 'ENABLE_REACTIONS',
+  DISABLE_REACTIONS: 'DISABLE_REACTIONS',
+  REACTIONS_ACTIVE: 'REACTIONS_ACTIVE',
+  REACTIONS_INACTIVE: 'REACTIONS_INACTIVE',
+  ENABLE_MUTE_ON_ENTRY: 'ENABLE_MUTE_ON_ENTRY',
+  DISABLE_MUTE_ON_ENTRY: 'DISABLE_MUTE_ON_ENTRY',
+  ENABLE_HARD_MUTE: 'ENABLE_HARD_MUTE',
+  DISABLE_HARD_MUTE: 'DISABLE_HARD_MUTE',
+  MUTE_ALL: 'MUTE_ALL',
+  UNMUTE_ALL: 'UNMUTE_ALL',
+  PRESENTER_CONTROL: 'PRESENTER_CONTROL',
+
+  // breakout session
+  BREAKOUT_MANAGEMENT: 'BREAKOUT_MANAGEMENT',
+  UCF_SUPPRESS_BREAKOUTS_SUPPORT: 'UCF_SUPPRESS_BREAKOUTS_SUPPORT',
+  DISABLE_ASK_FOR_HELP: 'DISABLE_ASK_FOR_HELP',
+  DISABLE_BREAKOUT_PREASSIGNMENTS: 'DISABLE_BREAKOUT_PREASSIGNMENTS',
+  DISABLE_LOBBY_TO_BREAKOUT: 'DISABLE_LOBBY_TO_BREAKOUT',
 };
 
 export const SELF_ROLES = {
   COHOST: 'COHOST',
   MODERATOR: 'MODERATOR',
+  ATTENDEE: 'ATTENDEE',
 };
 
 export const MEETING_STATE = {
@@ -812,7 +900,9 @@ export const RESOURCE = {
 };
 
 export const REACHABILITY = {
-  localStorage: 'reachability.result',
+  localStorageResult: 'reachability.result',
+  localStorageJoinCookie: 'reachability.joinCookie',
+  namespace: 'Reachability',
 };
 
 export const ROAP = {
@@ -847,9 +937,6 @@ export const NETWORK_TYPE = {
 };
 
 export const STATS = {
-  AUDIO_CORRELATE: 'audio',
-  VIDEO_CORRELATE: 'video',
-  SHARE_CORRELATE: 'share',
   SEND_DIRECTION: 'send',
   RECEIVE_DIRECTION: 'recv',
   REMOTE: 'remote',

package/src/controls-options-manager/constants.ts

@@ -0,0 +1,5 @@
+const ENABLED = 'enabled';
+const CAN_SET = 'canSet';
+const CAN_UNSET = 'canUnset';
+
+export {ENABLED, CAN_SET, CAN_UNSET};

package/src/controls-options-manager/enums.ts

@@ -0,0 +1,7 @@
+enum Setting {
+  disallowUnmute = 'DisallowUnmute',
+  muteOnEntry = 'MuteOnEntry',
+  muted = 'Muted',
+}
+
+export default Setting;

package/src/controls-options-manager/index.ts

@@ -0,0 +1,240 @@
+import {camelCase} from 'lodash';
+import PermissionError from '../common/errors/permission';
+import {CONTROLS, HTTP_VERBS} from '../constants';
+import MeetingRequest from '../meeting/request';
+import LoggerProxy from '../common/logs/logger-proxy';
+import Setting from './enums';
+import Util from './util';
+import {CAN_SET, CAN_UNSET, ENABLED} from './constants';
+
+/**
+ * docs
+ * https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html
+ * https://confluence-eng-gpk2.cisco.com/conf/display/LOCUS/Hard+Mute+and+Audio+Privacy#HardMuteandAudioPrivacy-SelfMuteonEntry
+ * https://confluence-eng-gpk2.cisco.com/conf/pages/viewpage.action?spaceKey=UC&title=WEBEX-124454%3A+UCF%3A+Hard+mute+support+for+Teams+joining+Webex+meeting
+ * https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-180867
+ * https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-393351
+ */
+
+/**
+ * @description ControlsOptionsManager is responsible for handling the behavior of participant controls when somebody joins a meeting
+ * @export
+ * @private
+ * @class Recording
+ */
+export default class ControlsOptionsManager {
+  /**
+   * @instance
+   * @type {MeetingRequest}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private request: MeetingRequest;
+
+  /**
+   * @instance
+   * @type {Array}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private displayHints: Array<string> = [];
+
+  /**
+   * @instance
+   * @type {string}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private locusUrl: string;
+
+  /**
+   * @param {MeetingRequest} request
+   * @param {Object} options
+   * @constructor
+   * @memberof ControlsOptionsManager
+   */
+  constructor(
+    request: MeetingRequest,
+    options?: {
+      locusUrl: string;
+      displayHints?: Array<string>;
+    }
+  ) {
+    this.initialize(request);
+    this.set(options);
+  }
+
+  /**
+   * @param {MeetingRequest} request
+   * @returns {void}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private initialize(request: MeetingRequest) {
+    this.request = request;
+  }
+
+  /**
+   * @param {Object} options
+   * @returns {void}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public set(options?: {locusUrl: string; displayHints?: Array<string>}) {
+    this.extract(options);
+  }
+
+  /**
+   * @param {string} url
+   * @returns {void}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public setLocusUrl(url: string) {
+    this.locusUrl = url;
+  }
+
+  /**
+   * @param {Array} hints
+   * @returns {void}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public setDisplayHints(hints: Array<string>) {
+    this.displayHints = hints;
+  }
+
+  /**
+   * @returns {string}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public getLocusUrl() {
+    return this.locusUrl;
+  }
+
+  /**
+   * @returns {Array}
+   * @public
+   * @memberof ControlsOptionsManager
+   */
+  public getDisplayHints() {
+    return this.displayHints;
+  }
+
+  /**
+   * @param {Object} options
+   * @returns {void}
+   * @private
+   * @memberof ControlsOptionsManager
+   */
+  private extract(options?: {locusUrl: string; displayHints?: Array<string>}) {
+    this.setDisplayHints(options?.displayHints);
+    this.setLocusUrl(options?.locusUrl);
+  }
+
+  /**
+   * @param {Setting} setting
+   * @private
+   * @memberof ControlsOptionsManager
+   * @returns {Promise}
+   */
+  private setControls(setting: {[key in Setting]?: boolean}): Promise<any> {
+    LoggerProxy.logger.log(
+      `ControlsOptionsManager:index#setControls --> ${JSON.stringify(setting)}`
+    );
+
+    const body: Record<string, any> = {};
+    let error: PermissionError;
+
+    let shouldSkipCheckToMergeBody = false;
+
+    Object.entries(setting).forEach(([key, value]) => {
+      if (
+        !shouldSkipCheckToMergeBody &&
+        !Util?.[`${value ? CAN_SET : CAN_UNSET}${key}`](this.displayHints)
+      ) {
+        error = new PermissionError(`${key} [${value}] not allowed, due to moderator property.`);
+      }
+
+      if (error) {
+        return;
+      }
+
+      switch (key) {
+        case Setting.muted:
+          shouldSkipCheckToMergeBody = true;
+          body.audio = body.audio
+            ? {...body.audio, [camelCase(key)]: value}
+            : {[camelCase(key)]: value};
+          break;
+
+        case Setting.disallowUnmute:
+        case Setting.muteOnEntry:
+          if (Object.keys(setting).includes(Setting.muted)) {
+            body.audio = body.audio
+              ? {...body.audio, [camelCase(key)]: value}
+              : {[camelCase(key)]: value};
+            body.audio[camelCase(key)] = value;
+          } else {
+            body[camelCase(key)] = {[ENABLED]: value};
+          }
+          break;
+
+        default:
+          error = new PermissionError(`${key} [${value}] not allowed, due to moderator property.`);
+      }
+    });
+
+    if (error) {
+      return Promise.reject(error);
+    }
+
+    // @ts-ignore
+    return this.request.request({
+      uri: `${this.locusUrl}/${CONTROLS}`,
+      body,
+      method: HTTP_VERBS.PATCH,
+    });
+  }
+
+  /**
+   * @public
+   * @param {boolean} enabled
+   * @memberof ControlsOptionsManager
+   * @returns {Promise}
+   */
+  public setMuteOnEntry(enabled: boolean): Promise<any> {
+    return this.setControls({[Setting.muteOnEntry]: enabled});
+  }
+
+  /**
+   * @public
+   * @param {boolean} enabled
+   * @memberof ControlsOptionsManager
+   * @returns {Promise}
+   */
+  public setDisallowUnmute(enabled: boolean): Promise<any> {
+    return this.setControls({[Setting.disallowUnmute]: enabled});
+  }
+
+  /**
+   * @public
+   * @param {boolean} mutedEnabled
+   * @param {boolean} disallowUnmuteEnabled
+   * @param {boolean} muteOnEntryEnabled
+   * @memberof ControlsOptionsManager
+   * @returns {Promise}
+   */
+  public setMuteAll(
+    mutedEnabled: boolean,
+    disallowUnmuteEnabled: boolean,
+    muteOnEntryEnabled: boolean
+  ): Promise<any> {
+    return this.setControls({
+      [Setting.muted]: mutedEnabled,
+      [Setting.disallowUnmute]: disallowUnmuteEnabled,
+      [Setting.muteOnEntry]: muteOnEntryEnabled,
+    });
+  }
+}