@webex/plugin-meetings 3.8.1-next.4 → 3.8.1-next.41

package/src/meeting/index.ts

@@ -121,6 +121,7 @@ import {
   WEBINAR_ERROR_REGISTRATION_ID,
   JOIN_BEFORE_HOST,
   REGISTRATION_ID_STATUS,
+  STAGE_MANAGER_TYPE,
 } from '../constants';
 import BEHAVIORAL_METRICS from '../metrics/constants';
 import ParameterError from '../common/errors/parameter';
@@ -164,6 +165,8 @@ import {BrbState, createBrbState} from './brbState';
 import MultistreamNotSupportedError from '../common/errors/multistream-not-supported-error';
 import JoinForbiddenError from '../common/errors/join-forbidden-error';
 import {ReachabilityMetrics} from '../reachability/reachability.types';
+import {SetStageOptions, SetStageVideoLayout, UnsetStageVideoLayout} from './request.type';
+import {Invitee} from './type';
 
 // default callback so we don't call an undefined function, but in practice it should never be used
 const DEFAULT_ICE_PHASE_CALLBACK = () => 'JOIN_MEETING_FINAL';
@@ -231,6 +234,14 @@ export type AddMediaOptions = {
   remoteMediaManagerConfig?: RemoteMediaManagerConfiguration; // applies only to multistream meetings
   bundlePolicy?: BundlePolicy; // applies only to multistream meetings
   allowMediaInLobby?: boolean; // allows adding media when in the lobby
+  additionalMediaOptions?: AdditionalMediaOptions; // allows adding additional options like send/receive audio/video
+};
+
+export type AdditionalMediaOptions = {
+  sendVideo?: boolean; // if not specified, default value of videoEnabled is used
+  receiveVideo?: boolean; // if not specified, default value of videoEnabled is used
+  sendAudio?: boolean; // if not specified, default value of audioEnabled true is used
+  receiveAudio?: boolean; // if not specified, default value of audioEnabled true is used
 };
 
 export type CallStateForMetrics = {
@@ -263,8 +274,9 @@ type FetchMeetingInfoParams = {
 };
 
 type MediaReachabilityMetrics = ReachabilityMetrics & {
-  isSubnetReachable: boolean;
-  selectedCluster: string | null;
+  subnet_reachable: boolean;
+  selected_cluster: string | null;
+  selected_subnet: string | null;
 };
 
 /**
@@ -732,10 +744,11 @@ export default class Meeting extends StatelessWebexPlugin {
   /**
    * @param {Object} attrs
    * @param {Object} options
+   * @param {Function} callback - if provided, it will be called with the newly created meeting object as soon as the meeting.id is set
    * @constructor
    * @memberof Meeting
    */
-  constructor(attrs: any, options: object) {
+  constructor(attrs: any, options: object, callback: (meeting: Meeting) => void) {
     super({}, options);
     /**
      * @instance
@@ -761,6 +774,11 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     this.id = uuid.v4();
+
+    if (callback) {
+      callback(this);
+    }
+
     /**
      * Call state used for metrics
      * @instance
@@ -2757,9 +2775,11 @@ export default class Meeting extends StatelessWebexPlugin {
       LOCUSINFO.EVENTS.CONTROLS_MEETING_TRANSCRIPTION_SPOKEN_LANGUAGE_UPDATED,
       ({spokenLanguage}) => {
         if (spokenLanguage) {
-          this.transcription.languageOptions.currentSpokenLanguage = spokenLanguage;
+          if (this.transcription?.languageOptions) {
+            this.transcription.languageOptions.currentSpokenLanguage = spokenLanguage;
+          }
           // @ts-ignore
-          this.webex.internal.voicea.onSpokenLanguageUpdate(spokenLanguage);
+          this.webex.internal.voicea.onSpokenLanguageUpdate(spokenLanguage, this.id);
 
           Trigger.trigger(
             this,
@@ -2768,7 +2788,7 @@ export default class Meeting extends StatelessWebexPlugin {
               function: 'setupLocusControlsListener',
             },
             EVENT_TRIGGERS.MEETING_TRANSCRIPTION_SPOKEN_LANGUAGE_UPDATED,
-            {spokenLanguage}
+            {spokenLanguage, meetingId: this.id}
           );
         }
       }
@@ -3045,12 +3065,16 @@ export default class Meeting extends StatelessWebexPlugin {
       // There is no concept of local/remote share for whiteboard
       // It does not matter who requested to share the whiteboard, everyone gets the same view
       else if (whiteboardShare.disposition === FLOOR_ACTION.GRANTED) {
-        // WHITEBOARD - sharing whiteboard
-        // Webinar attendee should receive whiteboard as remote share
-        newShareStatus =
-          this.locusInfo?.info?.isWebinar && this.webinar?.selfIsAttendee
-            ? SHARE_STATUS.REMOTE_SHARE_ACTIVE
-            : SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+        if (this.locusInfo?.info?.isWebinar && this.webinar?.selfIsAttendee) {
+          // WHITEBOARD - sharing whiteboard
+          // Webinar attendee should receive whiteboard as remote share
+          newShareStatus = SHARE_STATUS.REMOTE_SHARE_ACTIVE;
+        } else if (this.guest) {
+          // If user is a guest to a meeting, they should receive whiteboard as remote share
+          newShareStatus = SHARE_STATUS.REMOTE_SHARE_ACTIVE;
+        } else {
+          newShareStatus = SHARE_STATUS.WHITEBOARD_SHARE_ACTIVE;
+        }
       }
       // or if content share is either released or null and whiteboard share is either released or null, no one is sharing
       else if (
@@ -3816,49 +3840,44 @@ export default class Meeting extends StatelessWebexPlugin {
 
   /**
    * Invite a guest to the call that isn't normally part of this call
-   * @param {Object} invitee
+   * @param {Invitee} invitee
    * @param {String} invitee.emailAddress
    * @param {String} invitee.email
    * @param {String} invitee.phoneNumber
    * @param {Boolean} [alertIfActive]
+   * @param {Boolean} [invitee.skipEmailValidation]
+   * @param {Boolean} [invitee.isInternalNumber]
    * @returns {Promise} see #members.addMember
    * @public
    * @memberof Meeting
    */
-  public invite(
-    invitee: {
-      emailAddress: string;
-      email: string;
-      phoneNumber: string;
-      roles: Array<string>;
-    },
-    alertIfActive = true
-  ) {
+  public invite(invitee: Invitee, alertIfActive = true) {
     return this.members.addMember(invitee, alertIfActive);
   }
 
   /**
    * Cancel an outgoing phone call invitation made during a meeting
-   * @param {Object} invitee
+   * @param {Invitee} invitee
    * @param {String} invitee.phoneNumber
    * @returns {Promise} see #members.cancelPhoneInvite
    * @public
    * @memberof Meeting
    */
-  public cancelPhoneInvite(invitee: {phoneNumber: string}) {
+  public cancelPhoneInvite(invitee: Invitee) {
     return this.members.cancelPhoneInvite(invitee);
   }
 
   /**
-   * Cancel an SIP call invitation made during a meeting
-   * @param {Object} invitee
+   * Cancel an SIP/phone call invitation made during a meeting
+   * @param {Invitee} invitee
    * @param {String} invitee.memberId
-   * @returns {Promise} see #members.cancelSIPInvite
+   * @param {Boolean} [invitee.isInternalNumber] - When cancel phone invitation, if the number is internal
+   * @returns {Promise} see #members.cancelInviteByMemberId
    * @public
    * @memberof Meeting
    */
-  public cancelSIPInvite(invitee: {memberId: string}) {
-    return this.members.cancelSIPInvite(invitee);
+  public cancelInviteByMemberId(invitee: Invitee) {
+    return this.members.cancelInviteByMemberId(invitee);
   }
 
   /**
@@ -4156,6 +4175,9 @@ export default class Meeting extends StatelessWebexPlugin {
           isClosedCaptionActive: MeetingUtil.isClosedCaptionActive(this.userDisplayHints),
           canStartManualCaption: MeetingUtil.canStartManualCaption(this.userDisplayHints),
           canStopManualCaption: MeetingUtil.canStopManualCaption(this.userDisplayHints),
+          isLocalRecordingStarted: MeetingUtil.isLocalRecordingStarted(this.userDisplayHints),
+          isLocalRecordingStopped: MeetingUtil.isLocalRecordingStopped(this.userDisplayHints),
+          isLocalRecordingPaused: MeetingUtil.isLocalRecordingPaused(this.userDisplayHints),
           isManualCaptionActive: MeetingUtil.isManualCaptionActive(this.userDisplayHints),
           isSaveTranscriptsEnabled: MeetingUtil.isSaveTranscriptsEnabled(this.userDisplayHints),
           isWebexAssistantActive: MeetingUtil.isWebexAssistantActive(this.userDisplayHints),
@@ -7754,8 +7776,21 @@ export default class Meeting extends StatelessWebexPlugin {
       shareVideoEnabled = true,
       remoteMediaManagerConfig,
       bundlePolicy = 'max-bundle',
+      additionalMediaOptions = {},
     } = options;
 
+    const {
+      sendVideo: rawSendVideo,
+      receiveVideo: rawReceiveVideo,
+      sendAudio: rawSendAudio,
+      receiveAudio: rawReceiveAudio,
+    } = additionalMediaOptions;
+
+    const sendVideo = videoEnabled && (rawSendVideo ?? true);
+    const receiveVideo = videoEnabled && (rawReceiveVideo ?? true);
+    const sendAudio = audioEnabled && (rawSendAudio ?? true);
+    const receiveAudio = audioEnabled && (rawReceiveAudio ?? true);
+
     this.allowMediaInLobby = options?.allowMediaInLobby;
 
     // If the user is unjoined or guest waiting in lobby dont allow the user to addMedia
@@ -7791,11 +7826,11 @@ export default class Meeting extends StatelessWebexPlugin {
     // when audioEnabled/videoEnabled is true, we set sendAudio/sendVideo to true even before any streams are published
     // to avoid doing an extra SDP exchange when they are published for the first time
     this.mediaProperties.setMediaDirection({
-      sendAudio: audioEnabled,
-      sendVideo: videoEnabled,
+      sendAudio,
+      sendVideo,
       sendShare: false,
-      receiveAudio: audioEnabled,
-      receiveVideo: videoEnabled,
+      receiveAudio,
+      receiveVideo,
       receiveShare: shareAudioEnabled || shareVideoEnabled,
     });
 
@@ -8363,6 +8398,10 @@ export default class Meeting extends StatelessWebexPlugin {
     }
 
     if (whiteboard) {
+      // @ts-ignore
+      this.webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp({
+        key: 'internal.client.share.initiated',
+      });
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.share.initiated',
@@ -8422,11 +8461,17 @@ export default class Meeting extends StatelessWebexPlugin {
     const whiteboard = this.locusInfo.mediaShares.find((element) => element.name === 'whiteboard');
 
     if (whiteboard) {
+      // @ts-ignore
+      this.webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp({
+        key: 'internal.client.share.stopped',
+      });
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.share.stopped',
         payload: {
           mediaType: 'whiteboard',
+          // @ts-ignore
+          shareDuration: this.webex.internal.newMetrics.callDiagnosticLatencies.getShareDuration(),
         },
         options: {
           meetingId: this.id,
@@ -8584,12 +8629,18 @@ export default class Meeting extends StatelessWebexPlugin {
     }
     this.screenShareFloorState = ScreenShareFloorStatus.RELEASED;
     if (content) {
+      // @ts-ignore
+      this.webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp({
+        key: 'internal.client.share.stopped',
+      });
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.share.stopped',
         payload: {
           mediaType: 'share',
           shareInstanceId: this.localShareInstanceId,
+          // @ts-ignore
+          shareDuration: this.webex.internal.newMetrics.callDiagnosticLatencies.getShareDuration(),
         },
         options: {meetingId: this.id},
       });
@@ -9566,6 +9617,11 @@ export default class Meeting extends StatelessWebexPlugin {
       this.shareCAEventSentStatus.transmitStart = false;
       this.shareCAEventSentStatus.transmitStop = false;
 
+      // @ts-ignore
+      this.webex.internal.newMetrics.callDiagnosticLatencies.saveTimestamp({
+        key: 'internal.client.share.initiated',
+      });
+
       // @ts-ignore
       this.webex.internal.newMetrics.submitClientEvent({
         name: 'client.share.initiated',
@@ -9721,21 +9777,91 @@ export default class Meeting extends StatelessWebexPlugin {
       return total;
     }, 0);
 
+    const selectedSubnetFirstOctet = this.mediaServerIp?.split('.')[0];
+
     let isSubnetReachable = null;
-    if (totalSuccessCases > 0) {
-      // @ts-ignore
-      isSubnetReachable = this.webex.meetings.reachability.isSubnetReachable(this.mediaServerIp);
+    if (totalSuccessCases > 0 && selectedSubnetFirstOctet) {
+      isSubnetReachable =
+        // @ts-ignore
+        this.webex.meetings.reachability.isSubnetReachable(selectedSubnetFirstOctet);
     }
 
-    let selectedCluster = null;
-    if (this.mediaConnections && this.mediaConnections.length > 0) {
-      selectedCluster = this.mediaConnections[0].mediaAgentCluster;
-    }
+    const selectedCluster = this.mediaConnections?.[0]?.mediaAgentCluster ?? null;
 
     return {
       ...reachabilityMetrics,
-      isSubnetReachable,
-      selectedCluster,
+      subnet_reachable: isSubnetReachable,
+      selected_cluster: selectedCluster,
+      selected_subnet: selectedSubnetFirstOctet ? `${selectedSubnetFirstOctet}.X.X.X` : null,
     };
   }
+
+  /**
+   * Set the stage for the meeting
+   *
+   * @param {SetStageOptions} options Options to use when setting the stage
+   * @returns {Promise} The locus request
+   */
+  setStage({
+    activeSpeakerProportion = 0.5,
+    customBackground,
+    customLogo,
+    customNameLabel,
+    importantParticipants,
+    lockAttendeeViewOnStage = false,
+    showActiveSpeaker = false,
+  }: SetStageOptions = {}) {
+    const videoLayout: SetStageVideoLayout = {
+      overrideDefault: true,
+      lockAttendeeViewOnStageOnly: lockAttendeeViewOnStage,
+      stageParameters: {
+        activeSpeakerProportion,
+        showActiveSpeaker: {show: showActiveSpeaker, order: 0},
+        stageManagerType: 0,
+      },
+    };
+
+    if (importantParticipants?.length) {
+      videoLayout.stageParameters.importantParticipants = importantParticipants.map(
+        (importantParticipant, index) => ({...importantParticipant, order: index + 1})
+      );
+    }
+
+    if (customLogo) {
+      if (!videoLayout.customLayouts) {
+        videoLayout.customLayouts = {};
+      }
+      videoLayout.customLayouts.logo = customLogo;
+      // eslint-disable-next-line no-bitwise
+      videoLayout.stageParameters.stageManagerType |= STAGE_MANAGER_TYPE.LOGO;
+    }
+
+    if (customBackground) {
+      if (!videoLayout.customLayouts) {
+        videoLayout.customLayouts = {};
+      }
+      videoLayout.customLayouts.background = customBackground;
+      // eslint-disable-next-line no-bitwise
+      videoLayout.stageParameters.stageManagerType |= STAGE_MANAGER_TYPE.BACKGROUND;
+    }
+
+    if (customNameLabel) {
+      videoLayout.nameLabelStyle = customNameLabel;
+      // eslint-disable-next-line no-bitwise
+      videoLayout.stageParameters.stageManagerType |= STAGE_MANAGER_TYPE.NAME_LABEL;
+    }
+
+    return this.meetingRequest.synchronizeStage(this.locusUrl, videoLayout);
+  }
+
+  /**
+   * Unset the stage for the meeting
+   *
+   * @returns {Promise} The locus request
+   */
+  unsetStage() {
+    const videoLayout: UnsetStageVideoLayout = {overrideDefault: false};
+
+    return this.meetingRequest.synchronizeStage(this.locusUrl, videoLayout);
+  }
 }

package/src/meeting/request.ts

@@ -32,6 +32,7 @@ import {
   BrbOptions,
   ToggleReactionsOptions,
   PostMeetingDataConsentOptions,
+  SynchronizeVideoLayout,
 } from './request.type';
 import MeetingUtil from './util';
 import {AnnotationInfo} from '../annotation/annotation.types';
@@ -969,4 +970,19 @@ export default class MeetingRequest extends StatelessWebexPlugin {
       },
     });
   }
+
+  /**
+   * Synchronize the stage for a meeting
+   *
+   * @param {LocusUrl} locusUrl The locus URL
+   * @param {SetStageVideoLayout} videoLayout The video layout to synchronize
+   * @returns {Promise} The locus request
+   */
+  synchronizeStage(locusUrl: string, videoLayout: SynchronizeVideoLayout) {
+    return this.locusDeltaRequest({
+      method: HTTP_VERBS.PATCH,
+      uri: `${locusUrl}/${CONTROLS}`,
+      body: {videoLayout},
+    });
+  }
 }

package/src/meeting/request.type.ts

@@ -25,3 +25,67 @@ export type PostMeetingDataConsentOptions = {
   deviceUrl: string;
   selfId: string;
 };
+
+export type StageCustomLogoPositions =
+  | 'LowerLeft'
+  | 'LowerMiddle'
+  | 'LowerRight'
+  | 'UpperLeft'
+  | 'UpperMiddle'
+  | 'UpperRight';
+
+export type StageNameLabelType = 'Primary' | 'PrimaryInverted' | 'Secondary' | 'SecondaryInverted';
+
+export type StageCustomBackground = {
+  url: string;
+  [others: string]: unknown;
+};
+
+export type StageCustomLogo = {
+  url: string;
+  position: StageCustomLogoPositions;
+  [others: string]: unknown;
+};
+
+export type StageCustomNameLabel = {
+  accentColor: string;
+  background: {color: string};
+  border: {color: string};
+  content: {displayName: {color: string}; subtitle: {color: string}};
+  decoration: {color: string};
+  fadeOut?: {delay: number};
+  type: StageNameLabelType;
+  [others: string]: unknown;
+};
+
+export type SetStageOptions = {
+  activeSpeakerProportion?: number;
+  customBackground?: StageCustomBackground;
+  customLogo?: StageCustomLogo;
+  customNameLabel?: StageCustomNameLabel;
+  importantParticipants?: {mainCsi: number; participantId: string}[];
+  lockAttendeeViewOnStage?: boolean;
+  showActiveSpeaker?: boolean;
+};
+
+export type SetStageVideoLayout = {
+  overrideDefault: true;
+  lockAttendeeViewOnStageOnly: boolean;
+  stageParameters: {
+    importantParticipants?: {participantId: string; mainCsi: number; order: number}[];
+    showActiveSpeaker: {show: boolean; order: number};
+    activeSpeakerProportion: number;
+    stageManagerType: number;
+  };
+  customLayouts?: {
+    background?: StageCustomBackground;
+    logo?: StageCustomLogo;
+  };
+  nameLabelStyle?: StageCustomNameLabel;
+};
+
+export type UnsetStageVideoLayout = {
+  overrideDefault: false;
+};
+
+export type SynchronizeVideoLayout = SetStageVideoLayout | UnsetStageVideoLayout;

package/src/meeting/type.ts

@@ -0,0 +1,9 @@
+export type Invitee = {
+  memberId: string;
+  emailAddress: string;
+  email: string;
+  phoneNumber: string;
+  roles: Array<string>;
+  skipEmailValidation?: boolean;
+  isInternalNumber?: boolean;
+};

package/src/meeting/util.ts

@@ -208,6 +208,10 @@ const MeetingUtil = {
     meeting.simultaneousInterpretation.cleanUp();
     meeting.locusMediaRequest = undefined;
 
+    meeting.webex?.internal?.newMetrics?.callDiagnosticMetrics?.clearEventLimitsForCorrelationId(
+      meeting.correlationId
+    );
+
     // make sure we send last metrics before we close the peerconnection
     const stopStatsAnalyzer = meeting.statsAnalyzer
       ? meeting.statsAnalyzer.stopAnalyzer()
@@ -542,6 +546,15 @@ const MeetingUtil = {
   canStartManualCaption: (displayHints) =>
     displayHints.includes(DISPLAY_HINTS.MANUAL_CAPTION_START),
 
+  isLocalRecordingStarted: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCAL_RECORDING_STATUS_STARTED),
+
+  isLocalRecordingStopped: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCAL_RECORDING_STATUS_STOPPED),
+
+  isLocalRecordingPaused: (displayHints) =>
+    displayHints.includes(DISPLAY_HINTS.LOCAL_RECORDING_STATUS_PAUSED),
+
   canStopManualCaption: (displayHints) => displayHints.includes(DISPLAY_HINTS.MANUAL_CAPTION_STOP),
 
   isManualCaptionActive: (displayHints) =>

package/src/meetings/index.ts

@@ -1560,11 +1560,12 @@ export default class Meetings extends WebexPlugin {
       {
         // @ts-ignore
         parent: this.webex,
+      },
+      (newMeeting) => {
+        this.meetingCollection.set(newMeeting);
       }
     );
 
-    this.meetingCollection.set(meeting);
-
     try {
       // if no participant has joined the scheduled meeting (meaning meeting is not active) and we get a locusEvent,
       // it means the meeting will start in 5-6 min. In that case, we want to fetchMeetingInfo

package/src/members/index.ts

@@ -30,6 +30,7 @@ import MembersUtil from './util';
 import {ReceiveSlotManager} from '../multistream/receiveSlotManager';
 import {MediaRequestManager} from '../multistream/mediaRequestManager';
 import {ServerRoleShape} from './types';
+import {Invitee} from '../meeting/type';
 
 /**
  * Members Update Event
@@ -800,18 +801,18 @@ export default class Members extends StatelessWebexPlugin {
 
   /**
    * Adds a guest Member to the associated meeting
-   * @param {String} invitee
+   * @param {Invitee} invitee
    * @param {Boolean} [alertIfActive]
    * @returns {Promise}
    * @memberof Members
    */
-  addMember(invitee: any, alertIfActive?: boolean) {
+  addMember(invitee: Invitee, alertIfActive?: boolean) {
     if (!this.locusUrl) {
       return Promise.reject(
         new ParameterError('The associated locus url for this meeting object must be defined.')
       );
     }
-    if (MembersUtil.isInvalidInvitee(invitee)) {
+    if (invitee?.skipEmailValidation !== true && MembersUtil.isInvalidInvitee(invitee)) {
       return Promise.reject(
         new ParameterError(
           'The invitee must be defined with either a valid email, emailAddress or phoneNumber property.'
@@ -825,11 +826,11 @@ export default class Members extends StatelessWebexPlugin {
 
   /**
    * Cancels an outgoing PSTN call to the associated meeting
-   * @param {String} invitee
+   * @param {Invitee} invitee
    * @returns {Promise}
    * @memberof Members
    */
-  cancelPhoneInvite(invitee: any) {
+  cancelPhoneInvite(invitee: Invitee) {
     if (!this.locusUrl) {
       return Promise.reject(
         new ParameterError('The associated locus url for this meeting object must be defined.')
@@ -846,12 +847,14 @@ export default class Members extends StatelessWebexPlugin {
   }
 
   /**
-   * Cancels an SIP call to the associated meeting
-   * @param {String} invitee
+   * Cancels an SIP/phone call to the associated meeting
+   * @param {Invitee} invitee
+   * @param {String} invitee.memberId - The memberId of the invitee
+   * @param {Boolean} [invitee.isInternalNumber] - When cancel phone invitation, if the number is internal
    * @returns {Promise}
    * @memberof Members
    */
-  cancelSIPInvite(invitee: any) {
+  cancelInviteByMemberId(invitee: Invitee) {
     if (!this.locusUrl) {
       return Promise.reject(
         new ParameterError('The associated locus url for this meeting object must be defined.')
@@ -862,9 +865,9 @@ export default class Members extends StatelessWebexPlugin {
         new ParameterError('The invitee must be defined with a memberId property.')
       );
     }
-    const options = MembersUtil.cancelSIPInviteOptions(invitee, this.locusUrl);
+    const options = MembersUtil.cancelInviteByMemberIdOptions(invitee, this.locusUrl);
 
-    return this.membersRequest.cancelSIPInvite(options);
+    return this.membersRequest.cancelInviteByMemberId(options);
   }
 
   /**

package/src/members/request.ts

@@ -285,14 +285,14 @@ export default class MembersRequest extends StatelessWebexPlugin {
    * @throws {Error} if the options are not valid and complete, must have invitee with memberId AND locusUrl
    * @memberof MembersRequest
    */
-  cancelSIPInvite(options: any) {
+  cancelInviteByMemberId(options: any) {
     if (!options?.invitee?.memberId || !options?.locusUrl) {
       throw new ParameterError(
         'invitee must be passed and the associated locus url for this meeting object must be defined.'
       );
     }
 
-    const requestParams = MembersUtil.generateCancelSIPInviteRequestParams(options);
+    const requestParams = MembersUtil.generateCancelInviteByMemberIdRequestParams(options);
 
     return this.locusDeltaRequest(requestParams);
   }

package/src/members/util.ts

@@ -1,4 +1,5 @@
 import uuid from 'uuid';
+import {has} from 'lodash';
 import {
   HTTP_VERBS,
   CONTROLS,
@@ -13,6 +14,7 @@ import {
 } from '../constants';
 
 import {RoleAssignmentOptions, RoleAssignmentRequest, ServerRoleShape} from './types';
+import {Invitee} from '../meeting/type';
 
 const MembersUtil = {
   /**
@@ -47,6 +49,9 @@ const MembersUtil = {
         address:
           options.invitee.emailAddress || options.invitee.email || options.invitee.phoneNumber,
         ...(options.invitee.roles ? {roles: options.invitee.roles} : {}),
+        ...(has(options.invitee, 'isInternalNumber')
+          ? {isInternalNumber: options.invitee.isInternalNumber}
+          : {}),
       },
     ],
     alertIfActive: options.alertIfActive,
@@ -101,12 +106,16 @@ const MembersUtil = {
     return requestParams;
   },
 
-  isInvalidInvitee: (invitee) => {
+  isInvalidInvitee: (invitee: Invitee) => {
     if (!(invitee && (invitee.email || invitee.emailAddress || invitee.phoneNumber))) {
       return true;
     }
 
     if (invitee.phoneNumber) {
+      if (invitee.isInternalNumber) {
+        return !DIALER_REGEX.INTERNAL_NUMBER.test(invitee.phoneNumber);
+      }
+
       return !DIALER_REGEX.E164_FORMAT.test(invitee.phoneNumber);
     }
 
@@ -371,17 +380,20 @@ const MembersUtil = {
     return requestParams;
   },
 
-  cancelSIPInviteOptions: (invitee, locusUrl) => ({
+  cancelInviteByMemberIdOptions: (invitee, locusUrl) => ({
     invitee,
     locusUrl,
   }),
 
-  generateCancelSIPInviteRequestParams: (options) => {
+  generateCancelInviteByMemberIdRequestParams: (options) => {
+    const {memberId, isInternalNumber} = options.invitee;
+    const hasIsInternalNumberProp = has(options.invitee, 'isInternalNumber');
     const body = {
       actionType: _REMOVE_,
       invitees: [
         {
-          address: options.invitee.memberId,
+          address: memberId,
+          ...(hasIsInternalNumberProp ? {isInternalNumber} : {}),
         },
       ],
     };