@webex/plugin-meetings 2.60.0 → 2.60.1-next.1

package/dist/meeting/index.d.ts

@@ -1,23 +1,58 @@
 /// <reference types="node" />
 import { StatelessWebexPlugin } from '@webex/webex-core';
+import { ClientEvent, ClientEventLeaveReason } from '@webex/internal-plugin-metrics';
+import { LocalStream, LocalCameraStream, LocalDisplayStream, LocalSystemAudioStream, LocalMicrophoneStream } from '@webex/media-helpers';
 import { StatsAnalyzer } from '../statsAnalyzer';
 import NetworkQualityMonitor from '../networkQualityMonitor';
 import Roap from '../roap/index';
+import { type BundlePolicy } from '../media';
 import MediaProperties from '../media/properties';
 import ReconnectionManager from '../reconnection-manager';
 import MeetingRequest from './request';
 import Members from '../members/index';
 import Transcription from '../transcription';
-import { ReactionType, SkinToneType } from '../reactions/reactions.type';
+import { NETWORK_STATUS } from '../constants';
+import { ReceiveSlotManager } from '../multistream/receiveSlotManager';
+import { MediaRequestManager } from '../multistream/mediaRequestManager';
+import { Configuration as RemoteMediaManagerConfiguration, RemoteMediaManager } from '../multistream/remoteMediaManager';
+import { ReactionServerType, SkinToneType } from '../reactions/reactions.type';
 import InMeetingActions from './in-meeting-actions';
 import RecordingController from '../recording-controller';
 import ControlsOptionsManager from '../controls-options-manager';
+import { LocusMediaRequest } from './locusMediaRequest';
+export type LocalStreams = {
+    microphone?: LocalMicrophoneStream;
+    camera?: LocalCameraStream;
+    screenShare?: {
+        audio?: LocalSystemAudioStream;
+        video?: LocalDisplayStream;
+    };
+};
+export type AddMediaOptions = {
+    localStreams?: LocalStreams;
+    audioEnabled?: boolean;
+    videoEnabled?: boolean;
+    shareAudioEnabled?: boolean;
+    shareVideoEnabled?: boolean;
+    remoteMediaManagerConfig?: RemoteMediaManagerConfiguration;
+    bundlePolicy?: BundlePolicy;
+    allowMediaInLobby?: boolean;
+};
+export type CallStateForMetrics = {
+    correlationId?: string;
+    joinTrigger?: string;
+    loginType?: string;
+};
 export declare const MEDIA_UPDATE_TYPE: {
-    ALL: string;
-    AUDIO: string;
-    VIDEO: string;
-    SHARE: string;
+    TRANSCODED_MEDIA_CONNECTION: string;
+    SHARE_FLOOR_REQUEST: string;
+    UPDATE_MEDIA: string;
 };
+export declare enum ScreenShareFloorStatus {
+    PENDING = "floor_request_pending",
+    GRANTED = "floor_request_granted",
+    RELEASED = "floor_released"
+}
 /**
  * MediaDirection
  * @typedef {Object} MediaDirection
@@ -29,15 +64,6 @@ export declare const MEDIA_UPDATE_TYPE: {
  * @property {boolean} receiveShare
  * @property {boolean} isSharing
  */
-/**
- * AudioVideo
- * @typedef {Object} AudioVideo
- * @property {Object} audio
- * @property {String} audio.deviceId
- * @property {Object} video
- * @property {String} video.deviceId
- * @property {String} video.localVideoQuality // [240p, 360p, 480p, 720p, 1080p]
- */
 /**
  * SharePreferences
  * @typedef {Object} SharePreferences
@@ -51,16 +77,9 @@ export declare const MEDIA_UPDATE_TYPE: {
  * @property {String} [pin]
  * @property {Boolean} [moderator]
  * @property {String|Object} [meetingQuality]
- * @property {String} [meetingQuality.local]
  * @property {String} [meetingQuality.remote]
  * @property {Boolean} [rejoin]
- */
-/**
- * SendOptions
- * @typedef {Object} SendOptions
- * @property {Boolean} sendAudio
- * @property {Boolean} sendVideo
- * @property {Boolean} sendShare
+ * @property {Boolean} [enableMultistream]
  */
 /**
  * Recording
@@ -143,7 +162,11 @@ export declare const MEDIA_UPDATE_TYPE: {
  * @instance
  * @type {Object}
  * @property {Boolean} memberId id of the meeting member that started screen share
+ * @property {String}  url of this content share
+ * @property {String}  shareInstanceId of this content share
+ * @property {Object}  annotation Info of this content share
  * @memberof Meeting
+ *
  */
 /**
  * Meeting Stopped Sharing Remote Event
@@ -279,18 +302,23 @@ export declare const MEDIA_UPDATE_TYPE: {
 export default class Meeting extends StatelessWebexPlugin {
     attrs: any;
     audio: any;
+    breakouts: any;
+    simultaneousInterpretation: any;
+    annotation: any;
+    webinar: any;
     conversationUrl: string;
-    correlationId: string;
+    callStateForMetrics: CallStateForMetrics;
     destination: string;
     destinationType: string;
     deviceUrl: string;
-    effects: any;
     hostId: string;
     id: string;
+    isMultistream: boolean;
     locusUrl: string;
     mediaConnections: any[];
+    mediaId?: string;
     meetingFiniteStateMachine: any;
-    meetingInfo: object;
+    meetingInfo: any;
     meetingRequest: MeetingRequest;
     members: Members;
     options: object;
@@ -302,11 +330,13 @@ export default class Meeting extends StatelessWebexPlugin {
     resource: string;
     roap: Roap;
     roapSeq: number;
+    selfUrl?: string;
     sipUri: string;
     type: string;
     userId: string;
     video: any;
     callEvents: any[];
+    datachannelUrl: string;
     deferJoin: Promise<any>;
     dialInDeviceStatus: string;
     dialInUrl: string;
@@ -318,31 +348,46 @@ export default class Meeting extends StatelessWebexPlugin {
     hasWebsocketConnected: boolean;
     inMeetingActions: InMeetingActions;
     isLocalShareLive: boolean;
-    isSharing: boolean;
+    isRoapInProgress: boolean;
     keepAliveTimerId: NodeJS.Timeout;
     lastVideoLayoutInfo: any;
     locusInfo: any;
+    locusMediaRequest?: LocusMediaRequest;
     mediaProperties: MediaProperties;
+    mediaRequestManagers: {
+        audio: MediaRequestManager;
+        video: MediaRequestManager;
+        screenShareAudio: MediaRequestManager;
+        screenShareVideo: MediaRequestManager;
+    };
     meetingInfoFailureReason: string;
+    meetingInfoFailureCode?: number;
+    meetingInfoExtraParams?: Record<string, any>;
     networkQualityMonitor: NetworkQualityMonitor;
-    networkStatus: string;
+    networkStatus?: NETWORK_STATUS;
     passwordStatus: string;
     queuedMediaUpdates: any[];
     recording: any;
+    remoteMediaManager: RemoteMediaManager | null;
     recordingController: RecordingController;
     controlsOptionsManager: ControlsOptionsManager;
     requiredCaptcha: any;
+    receiveSlotManager: ReceiveSlotManager;
+    selfUserPolicies: any;
+    enforceVBGImagesURL: string;
     shareStatus: string;
+    screenShareFloorState: ScreenShareFloorStatus;
     statsAnalyzer: StatsAnalyzer;
     transcription: Transcription;
     receiveTranscription: boolean;
     updateMediaConnections: (mediaConnections: any[]) => void;
-    endCallInitiateJoinReq: any;
+    userDisplayHints: any;
+    endCallInitJoinReq: any;
     endJoinReqResp: any;
     endLocalSDPGenRemoteSDPRecvDelay: any;
     joinedWith: any;
     locusId: any;
-    startCallInitiateJoinReq: any;
+    startCallInitJoinReq: any;
     startJoinReqResp: any;
     startLocalSDPGenRemoteSDPRecvDelay: any;
     wirelessShare: any;
@@ -350,12 +395,27 @@ export default class Meeting extends StatelessWebexPlugin {
     meetingJoinUrl: any;
     meetingNumber: any;
     meetingState: any;
-    permissionToken: any;
+    permissionToken: string;
+    permissionTokenPayload: any;
+    permissionTokenReceivedLocalTime: number;
     resourceId: any;
     resourceUrl: string;
     selfId: string;
     state: any;
+    localAudioStreamMuteStateHandler: (muted: boolean) => void;
+    localVideoStreamMuteStateHandler: (muted: boolean) => void;
+    localOutputTrackChangeHandler: () => void;
+    roles: any[];
+    environment: string;
     namespace: string;
+    allowMediaInLobby: boolean;
+    turnDiscoverySkippedReason: string;
+    turnServerUsed: boolean;
+    private retriedWithTurnServer;
+    private sendSlotManager;
+    private deferSDPAnswer?;
+    private sdpResponseTimer?;
+    private hasMediaConnectionConnectedAtLeastOnce;
     /**
      * @param {Object} attrs
      * @param {Object} options
@@ -363,29 +423,68 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     constructor(attrs: any, options: object);
+    /**
+     * returns meeting is joined
+     * @private
+     * @memberof Meeting
+     * @returns {Boolean}
+     */
+    private isJoined;
+    /**
+     * Returns whether this meeting is a Locus CALL
+     * @returns {Boolean}
+     */
+    isLocusCall(): boolean;
+    /**
+     * Getter - Returns callStateForMetrics.correlationId
+     * @returns {string}
+     */
+    get correlationId(): string;
+    /**
+     * Setter - sets callStateForMetrics.correlationId
+     * @param {string} correlationId
+     */
+    set correlationId(correlationId: string);
+    /**
+     * Internal method for fetching meeting info
+     *
+     * @returns {Promise}
+     */
+    private fetchMeetingInfoInternal;
+    /**
+     * Refreshes the meeting info permission token (it's required for joining meetings)
+     *
+     * @param {string} [reason] used for metrics and logging purposes (optional)
+     * @returns {Promise}
+     */
+    refreshPermissionToken(reason?: string): Promise<void>;
     /**
      * Fetches meeting information.
      * @param {Object} options
      * @param {String} [options.password] optional
      * @param {String} [options.captchaCode] optional
+     * @param {Boolean} [options.sendCAevents] optional - Whether to submit Call Analyzer events or not. Default: false.
      * @public
      * @memberof Meeting
      * @returns {Promise}
      */
-    fetchMeetingInfo({ password, captchaCode, }: {
+    fetchMeetingInfo({ password, captchaCode, extraParams, sendCAevents, }: {
         password?: string;
         captchaCode?: string;
+        extraParams?: Record<string, any>;
+        sendCAevents?: boolean;
     }): Promise<void>;
     /**
      * Checks if the supplied password/host key is correct. It returns a promise with information whether the
      * password and captcha code were correct or not.
      * @param {String} password - this can be either a password or a host key, can be undefined if only captcha was required
      * @param {String} captchaCode - can be undefined if captcha was not required by the server
+     * @param {Boolean} sendCAevents - whether Call Analyzer events should be sent when fetching meeting information
      * @public
      * @memberof Meeting
      * @returns {Promise<{isPasswordValid: boolean, requiredCaptcha: boolean, failureReason: MEETING_INFO_FAILURE_REASON}>}
      */
-    verifyPassword(password: string, captchaCode: string): Promise<{
+    verifyPassword(password: string, captchaCode: string, sendCAevents?: boolean): Promise<{
         isPasswordValid: boolean;
         requiredCaptcha: any;
         failureReason: string;
@@ -402,6 +501,14 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {Promise}
      */
     refreshCaptcha(): any;
+    /**
+     * Posts metrics event for this meeting. Allows the app to send Call Analyzer events.
+     * @param {String} eventName - Call Analyzer event
+     * @public
+     * @memberof Meeting
+     * @returns {Promise}
+     */
+    postMetrics(eventName: ClientEvent['name']): void;
     /**
      * Proxy function for all the listener set ups
      * @returns {undefined}
@@ -410,70 +517,43 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     private setUpLocusInfoListeners;
     /**
-     * Set up the locus info listener for meetings disconnected due to inactivity
+     * Set up the listeners for breakouts
      * @returns {undefined}
      * @private
      * @memberof Meeting
      */
-    private setUpLocusInfoMediaInactiveListener;
+    setUpBreakoutsListener(): void;
     /**
-     * Set up the locus info listener for assign host permissions on a meeting
+     * Set up the listeners for interpretation
      * @returns {undefined}
      * @private
      * @memberof Meeting
      */
-    private setUpLocusInfoAssignHostListener;
+    private setUpInterpretationListener;
     /**
-     * Set up the internal locus info full state object listener
+     * Set up the locus info listener for meetings disconnected due to inactivity
      * @returns {undefined}
      * @private
      * @memberof Meeting
      */
-    private setUpLocusFullStateListener;
-    /**
-     * get the metrics payload pre
-     * @param {Object} options
-     * @param {String} options.event
-     * @param {String} options.trackingId
-     * @param {Object} options.locus
-     * @param {Array} options.mediaConnections
-     * @param {Object} options.errors
-     * @returns {Object}
-     * @memberof Meeting
-     */
-    getAnalyzerMetricsPrePayload(options: {
-        event: string;
-        trackingId: string;
-        locus: object;
-        mediaConnections: Array<any>;
-        errors: object;
-    } | any): {};
+    private setUpLocusInfoMediaInactiveListener;
     /**
-     * Send the metrics to call-analyzer dashboard
-     * @param {Object} options
-     * @param {String} options.event
-     * @param {String} options.trackingId
-     * @param {Object} options.locus
-     * @param {Object} options.errors
-     * @returns {Promise}
+     * Set up the locus info listener for assign host permissions on a meeting
+     * @returns {undefined}
      * @private
      * @memberof Meeting
      */
-    private sendCallAnalyzerMetrics;
+    private setUpLocusInfoAssignHostListener;
     /**
-     * Send the metrics to Media Quality Analyzer dashboard
-     * @param {Object} options
-     * @param {String} options.event
-     * @param {String} options.trackingId
-     * @param {Object} options.locus
-     * @returns {Promise}
+     * Set up the internal locus info full state object listener
+     * @returns {undefined}
      * @private
      * @memberof Meeting
      */
-    private sendMediaQualityAnalyzerMetrics;
+    private setUpLocusFullStateListener;
     /**
      * sets the network status on meeting object
-     * @param {String} networkStatus
+     * @param {NETWORK_STATUS} networkStatus
      * @private
      * @returns {undefined}
      * @memberof Meeting
@@ -533,6 +613,13 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     private setupLocusControlsListener;
+    /**
+     * Trigger annotation info update event
+     @returns {undefined}
+     @param {object} contentShare
+     @param {object} previousContentShare
+     */
+    private triggerAnnotationInfoEvent;
     /**
      * Set up the locus info media shares listener
      * update content and whiteboard sharing id value for members, and updates the member
@@ -567,6 +654,12 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof meeting
      */
     private setUpLocusInfoMeetingInfoListener;
+    /**
+     * Handles a data channel URL change
+     * @param {String} datachannelUrl
+     * @returns {void}
+     */
+    handleDataChannelUrlChange(datachannelUrl: any): void;
     /**
      * Set up the locus info embedded apps listener
      * @returns {undefined}
@@ -625,13 +718,23 @@ export default class Meeting extends StatelessWebexPlugin {
         phoneNumber: string;
     }): any;
     /**
-     * Admit the guest(s) to the call once they are waiting
+     * Admit the guest(s) to the call once they are waiting.
+     * If the host/cohost is in a breakout session, the locus url
+     * of the session must be provided as the authorizingLocusUrl.
+     * Regardless of host/cohost location, the locus Id (lid) in
+     * the path should be the locus Id of the main, which means the
+     * locus url of the api call must be from the main session.
+     * If these loucs urls are not provided, the function will do the check.
      * @param {Array} memberIds
+     * @param {Object} sessionLocusUrls: {authorizingLocusUrl, mainLocusUrl}
      * @returns {Promise} see #members.admitMembers
      * @public
      * @memberof Meeting
      */
-    admit(memberIds: Array<any>): any;
+    admit(memberIds: Array<any>, sessionLocusUrls?: {
+        authorizingLocusUrl: string;
+        mainLocusUrl: string;
+    }): any;
     /**
      * Remove the member from the meeting, boot them
      * @param {String} memberId
@@ -665,48 +768,6 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     getMembers(): Members;
-    /**
-     * Truthy when a meeting has an audio connection established
-     * @returns {Boolean}  true if meeting audio is connected otherwise false
-     * @public
-     * @memberof Meeting
-     */
-    isAudioConnected(): boolean;
-    /**
-     * Convenience function to tell whether a meeting is muted
-     * @returns {Boolean} if meeting audio muted or not
-     * @public
-     * @memberof Meeting
-     */
-    isAudioMuted(): any;
-    /**
-     * Convenience function to tell if the end user last changed the audio state
-     * @returns {Boolean} if audio was manipulated by the end user
-     * @public
-     * @memberof Meeting
-     */
-    isAudioSelf(): any;
-    /**
-     * Truthy when a meeting has a video connection established
-     * @returns {Boolean} true if meeting video connected otherwise false
-     * @public
-     * @memberof Meeting
-     */
-    isVideoConnected(): boolean;
-    /**
-     * Convenience function to tell whether video is muted
-     * @returns {Boolean} if meeting video is muted or not
-     * @public
-     * @memberof Meeting
-     */
-    isVideoMuted(): any;
-    /**
-     * Convenience function to tell whether the end user changed the video state
-     * @returns {Boolean} if meeting video is muted or not
-     * @public
-     * @memberof Meeting
-     */
-    isVideoSelf(): any;
     /**
      * Sets the meeting info on the class instance
      * @param {Object} meetingInfo
@@ -729,16 +790,29 @@ export default class Meeting extends StatelessWebexPlugin {
         };
     } | any, destination?: object | string | null): void;
     /**
-     * Sets the first locus info on the class instance
-     * @param {Object} locus
-     * @param {String} locus.url
-     * @param {Array} locus.participants
-     * @param {Object} locus.self
+     * Indicates whether policy can be applied
+     * @returns {boolean}
+     */
+    private arePolicyRestrictionsSupported;
+    /**
+     * Updates the meeting actions (display hints), depends on locus display hints, user policy and app api info
      * @returns {undefined}
      * @private
      * @memberof Meeting
      */
-    private parseLocus;
+    private updateMeetingActions;
+    /**
+     * Sets the self user policies based on the contents of the permission token
+     * @returns {void}
+     */
+    setSelfUserPolicies(): void;
+    /**
+     * Sets the permission token payload on the class instance
+     *
+     * @param {String} permissionToken
+     * @returns {void}
+     */
+    setPermissionTokenPayload(permissionToken: string): void;
     /**
      * Sets the sip uri on the class instance
      * uses meeting info as precedence
@@ -748,14 +822,6 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     setSipUri(sipUri: string): void;
-    /**
-     * Set the roap seq on the class instance
-     * @param {Number} seq
-     * @returns {undefined}
-     * @private
-     * @memberof Meeting
-     */
-    setRoapSeq(seq: number): void;
     /**
      * Set the locus info the class instance
      * @param {Object} locus
@@ -769,16 +835,13 @@ export default class Meeting extends StatelessWebexPlugin {
      * @private
      * @memberof Meeting
      */
-    private setLocus;
-    /**
-     * Sets the remote stream on the class instance and emits and
-     * event to developers
-     * @param {Object} pc The remote stream peer connection
-     * @returns {undefined}
-     * @public
-     * @memberof Meeting
-     */
-    setRemoteStream(pc: any): void;
+    setLocus(locus: {
+        mediaConnections: Array<any>;
+        locusUrl: string;
+        locusId: string;
+        mediaId: string;
+        host: object;
+    } | any): void;
     /**
      * Upload logs for the current meeting
      * @param {object} options file name and function name
@@ -788,19 +851,10 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     uploadLogs(options?: object): void;
     /**
-     * Removes remote audio and video stream on the class instance and triggers an event
-     * to developers
+     * Removes remote audio, video and share streams from class instance's mediaProperties
      * @returns {undefined}
-     * @public
-     * @memberof Meeting
-     * @deprecated after v1.89.3
      */
-    unsetRemoteStream(): void;
-    /**
-     * Removes remote audio, video and share tracks from class instance's mediaProperties
-     * @returns {undefined}
-     */
-    unsetRemoteTracks(): void;
+    unsetRemoteStreams(): void;
     /**
      * Removes the remote stream on the class instance and triggers an event
      * to developers
@@ -811,115 +865,92 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     closeRemoteStream(): void;
     /**
-     * Removes the remote tracks on the class instance and triggers an event
+     * Removes the remote streams on the class instance and triggers an event
      * to developers
      * @returns {undefined}
      * @memberof Meeting
      */
-    closeRemoteTracks(): Promise<[any, any, any]>;
-    /**
-     * Emits the 'media:ready' event with a local stream that consists of 1 local audio and 1 local video track
-     * @returns {undefined}
-     * @private
-     * @memberof Meeting
-     */
-    private sendLocalMediaReadyEvent;
+    closeRemoteStreams(): Promise<[any, any, any]>;
     /**
-     * Sets the local audio track on the class and emits an event to the developer
-     * @param {MediaStreamTrack} audioTrack
-     * @param {Boolean} emitEvent if true, a media ready event is emitted to the developer
-     * @returns {undefined}
-     * @private
-     * @memberof Meeting
+     * Stores the reference to a new microphone stream, sets up the required event listeners
+     * on it, cleans up previous stream, etc.
+     *
+     * @param {LocalMicrophoneStream | null} localStream local microphone stream
+     * @returns {Promise<void>}
      */
-    private setLocalAudioTrack;
+    private setLocalAudioStream;
     /**
-     * Sets the local video track on the class and emits an event to the developer
-     * @param {MediaStreamTrack} videoTrack
-     * @param {Boolean} emitEvent if true, a media ready event is emitted to the developer
-     * @returns {undefined}
-     * @private
-     * @memberof Meeting
+     * Stores the reference to a new camera stream, sets up the required event listeners
+     * on it, cleans up previous stream, etc.
+     *
+     * @param {LocalCameraStream | null} localStream local camera stream
+     * @returns {Promise<void>}
      */
-    private setLocalVideoTrack;
+    private setLocalVideoStream;
     /**
-     * Sets the local media stream on the class and emits an event to the developer
-     * @param {Stream} localStream the local media stream
-     * @returns {undefined}
-     * @public
-     * @memberof Meeting
+     * Stores the reference to a new screen share stream, sets up the required event listeners
+     * on it, cleans up previous stream, etc.
+     * It also sends the floor grant/release request.
+     *
+     * @param {LocalDisplayStream | undefined} localDisplayStream local display stream
+     * @returns {Promise<void>}
      */
-    setLocalTracks(localStream: any): void;
+    private setLocalShareVideoStream;
     /**
-     * Sets the local media stream on the class and emits an event to the developer
-     * @param {MediaStream} localShare the local media stream
-     * @returns {undefined}
-     * @public
-     * @memberof Meeting
+     * Stores the reference to a new screen share audio stream, sets up the required event listeners
+     * on it, cleans up previous stream, etc.
+     *
+     * @param {LocalSystemAudioStream | undefined} localSystemAudioStream local system audio stream
+     * @returns {Promise<void>}
      */
-    setLocalShareTrack(localShare: MediaStream): void;
+    private setLocalShareAudioStream;
     /**
-     * Closes the local stream from the class and emits an event to the developer
+     * sets up listner for mercury event
      * @returns {undefined}
-     * @event media:stopped
      * @public
      * @memberof Meeting
      */
-    closeLocalStream(): any;
+    setMercuryListener(): void;
     /**
-     * Closes the local stream from the class and emits an event to the developer
-     * @returns {undefined}
-     * @event media:stopped
+     * Close the peer connections and remove them from the class.
+     * Cleanup any media connection related things.
+     *
+     * @returns {Promise}
      * @public
      * @memberof Meeting
      */
-    closeLocalShare(): any;
+    closePeerConnections(): Promise<void>;
     /**
-     * Removes the local stream from the class and emits an event to the developer
+     * Unsets the peer connections on the class
+     * warning DO NOT CALL WITHOUT CLOSING PEER CONNECTIONS FIRST
      * @returns {undefined}
      * @public
      * @memberof Meeting
      */
-    unsetLocalVideoTrack(): void;
+    unsetPeerConnections(): void;
     /**
-     * Removes the local share from the class and emits an event to the developer
+     * Convenience method to set the correlation id for the callStateForMetrics
+     * @param {String} id correlation id to set on the callStateForMetrics
      * @returns {undefined}
      * @public
      * @memberof Meeting
      */
-    unsetLocalShareTrack(): void;
+    setCorrelationId(id: string): void;
     /**
-     * sets up listner for mercury event
+     * Update the callStateForMetrics
+     * @param {CallStateForMetrics} callStateForMetrics updated values for callStateForMetrics
      * @returns {undefined}
      * @public
      * @memberof Meeting
      */
-    setMercuryListener(): void;
+    updateCallStateForMetrics(callStateForMetrics: CallStateForMetrics): void;
     /**
-     * Close the peer connections and remove them from the class. Triggers an event
-     * when each is closed.
-     * @returns {Promise} returns a resolved promise with an array of closed peer connections
-     * @public
-     * @memberof Meeting
-     */
-    closePeerConnections(): any;
-    /**
-     * Unsets the peer connections on the class
-     * warning DO NOT CALL WITHOUT CLOSING PEER CONNECTIONS FIRST
-     * @param {PeerConnection} peerConnection
-     * @returns {undefined}
-     * @public
-     * @memberof Meeting
-     */
-    unsetPeerConnections(): void;
-    /**
-     * Convenience method to set the correlation id for the Meeting
-     * @param {String} id correlation id to set on the class
-     * @returns {undefined}
+     * Enqueue request for screenshare floor and set the status to pending
+     * @returns {Promise}
      * @private
      * @memberof Meeting
      */
-    private setCorrelationId;
+    private enqueueScreenShareFloorRequest;
     /**
      * Mute the audio for a meeting
      * @returns {Promise} resolves the data from muting audio {mute, self} or rejects if there is no audio set
@@ -952,32 +983,25 @@ export default class Meeting extends StatelessWebexPlugin {
      * Shorthand function to join AND set up media
      * @param {Object} options - options to join with media
      * @param {JoinOptions} [options.joinOptions] - see #join()
-     * @param {MediaDirection} options.mediaSettings - see #addMedia()
-     * @param {AudioVideo} [options.audioVideoOptions] - see #getMediaStreams()
-     * @returns {Promise} -- {join: see join(), media: see addMedia(), local: see getMediaStreams()}
+     * @param {AddMediaOptions} [options.mediaOptions] - see #addMedia()
+     * @returns {Promise} -- {join: see join(), media: see addMedia()}
      * @public
      * @memberof Meeting
      * @example
      * joinWithMedia({
      *  joinOptions: {resourceId: 'resourceId' },
-     *  mediaSettings: {
-     *   sendAudio: true,
-     *   sendVideo: true,
-     *   sendShare: false,
-     *   receiveVideo:true,
-     *   receiveAudio: true,
-     *   receiveShare: true
-     * }
-     * audioVideoOptions: {
-     *   audio: 'audioDeviceId',
-     *   video: 'videoDeviceId'
-     * }})
+     *  mediaOptions: {
+     *    localStreams: { microphone: microphoneStream, camera: cameraStream }
+     *   }
+     * })
      */
     joinWithMedia(options?: {
         joinOptions?: any;
-        mediaSettings: any;
-        audioVideoOptions?: any;
-    }): any;
+        mediaOptions?: AddMediaOptions;
+    }): Promise<{
+        join: any;
+        media: void;
+    }>;
     /**
      * Initiates the reconnection of the media in the meeting
      *
@@ -993,6 +1017,11 @@ export default class Meeting extends StatelessWebexPlugin {
      * @throws TranscriptionNotSupportedError
      */
     isTranscriptionSupported(): boolean;
+    /**
+     * Check if the meeting supports the Reactions
+     * @returns {boolean}
+     */
+    isReactionsSupported(): boolean;
     /**
      * Monitor the Low-Latency Mercury (LLM) web socket connection on `onError` and `onClose` states
      * @private
@@ -1005,6 +1034,13 @@ export default class Meeting extends StatelessWebexPlugin {
      * @returns {Promise<void>} a promise to open the WebSocket connection
      */
     private startTranscription;
+    /**
+     * Callback called when a relay event is received from meeting LLM Connection
+     * @param {RelayEvent} e Event object coming from LLM Connection
+     * @private
+     * @returns {void}
+     */
+    private processRelayEvent;
     /**
      * stop recieving Transcription by closing
      * the web socket connection properly
@@ -1030,7 +1066,14 @@ export default class Meeting extends StatelessWebexPlugin {
      *             if joining as host on second loop, pass pin and pass moderator if joining as guest on second loop
      * Scenario D: Joining any other way (sip, pstn, conversationUrl, link just need to specify resourceId)
      */
-    join(options?: any): any;
+    join(options?: any): Promise<any>;
+    /**
+     * Connects to low latency mercury and reconnects if the address has changed
+     * It will also disconnect if called when the meeting has ended
+     * @param {String} datachannelUrl
+     * @returns {Promise}
+     */
+    updateLLMConnection(): Promise<any>;
     /**
      * Use phone for meeting audio
      * @param {String} phoneNumber If provided, it will dial-out using this number. If not provided, dial-in will be used
@@ -1038,7 +1081,7 @@ export default class Meeting extends StatelessWebexPlugin {
      * @public
      * @memberof Meeting
      */
-    usePhoneAudio(phoneNumber: string): any;
+    usePhoneAudio(phoneNumber: string): Promise<any>;
     /**
      * Determines if the given pstnStatus is in a state which implies the phone is provisioned
      * @param {String} pstnStatus
@@ -1087,34 +1130,19 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     moveFrom(resourceId: string): any;
     /**
-     * Get local media streams based on options passed
-     * @param {MediaDirection} mediaDirection A configurable options object for joining a meeting
-     * @param {AudioVideo} [audioVideo] audio/video object to set audioinput and videoinput devices, see #Media.getUserMedia
-     * @param {SharePreferences} [sharePreferences] audio/video object to set audioinput and videoinput devices, see #Media.getUserMedia
-     * @returns {Promise} see #Media.getUserMedia
-     * @public
-     * @todo should be static, or moved so can be called outside of a meeting
-     * @memberof Meeting
-     */
-    getMediaStreams: (mediaDirection: any, audioVideo?: any, sharePreferences?: any) => any;
-    /**
-     * Checks if the machine has at least one audio or video device
-     * @param {Object} options
-     * @param {Boolean} options.sendAudio
-     * @param {Boolean} options.sendVideo
-     * @returns {Object}
-     * @memberof Meetings
+     * Handles ROAP_FAILURE event from the webrtc media connection
+     *
+     * @param {Error} error
+     * @returns {void}
      */
-    getSupportedDevices: ({ sendAudio, sendVideo, }: {
-        sendAudio: boolean;
-        sendVideo: boolean;
-    }) => any;
+    handleRoapFailure: (error: any) => void;
     /**
-     * Get the devices from the Media module
-     * @returns {Promise} resolves to an array of DeviceInfo
-     * @memberof Meetings
+     * This function makes sure we send the right metrics when local and remote SDPs are processed/generated
+     *
+     * @returns {undefined}
      */
-    getDevices: () => any;
+    setupSdpListeners: () => void;
+    setupMediaConnectionListeners: () => void;
     /**
      * Registers for all required StatsAnalyzer events
      * @private
@@ -1122,23 +1150,142 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meetings
      */
     setupStatsAnalyzerEventHandlers: () => void;
+    getMediaConnectionDebugId(): string;
     /**
-     * Specify joining via audio (option: pstn), video, screenshare
-     * @param {Object} options A configurable options object for joining a meeting
-     * @param {Object} options.resourceId pass the deviceId
-     * @param {MediaDirection} options.mediaSettings pass media options
-     * @param {MediaStream} options.localStream
-     * @param {MediaStream} options.localShare
-     * @returns {Promise}
+     * Creates a webrtc media connection and publishes streams to it
+     *
+     * @param {Object} turnServerInfo TURN server information
+     * @param {BundlePolicy} [bundlePolicy] Bundle policy settings
+     * @param {AddMediaOptions} [options] Options for enabling/disabling audio/video
+     * @returns {RoapMediaConnection | MultistreamRoapMediaConnection}
+     */
+    private createMediaConnection;
+    /**
+     * Listens for an event emitted by eventEmitter and emits it from the meeting object
+     *
+     * @private
+     * @param {*} eventEmitter object from which to forward the event
+     * @param {*} eventTypeToForward which event type to listen on and to forward
+     * @param {string} meetingEventType event type to be used in the event emitted from the meeting object
+     * @returns {void}
+     */
+    forwardEvent(eventEmitter: any, eventTypeToForward: any, meetingEventType: any): void;
+    /**
+     * Sets up all the references to local streams in this.mediaProperties before creating media connection
+     * and before TURN discovery, so that the correct mute state is sent with TURN discovery roap messages.
+     *
+     * @private
+     * @param {LocalStreams} localStreams
+     * @returns {Promise<void>}
+     */
+    private setUpLocalStreamReferences;
+    /**
+     * Calls mediaProperties.waitForMediaConnectionConnected() and sends CA client.ice.end metric on failure
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private waitForMediaConnectionConnected;
+    /**
+     * Enables statsAnalyser if config allows it
+     *
+     * @private
+     * @returns {void}
+     */
+    private createStatsAnalyzer;
+    /**
+     * Handles device logging
+     *
+     * @private
+     * @static
+     * @returns {Promise<void>}
+     */
+    private static handleDeviceLogging;
+    /**
+     * Returns a promise. This promise is created once the local sdp offer has been successfully created and is resolved
+     * once the remote sdp answer has been received.
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private waitForRemoteSDPAnswer;
+    /**
+     * Calls establishMediaConnection with isForced = true to force turn discovery to happen
+     *
+     * @private
+     * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+     * @param {BundlePolicy} [bundlePolicy]
+     * @returns {Promise<void>}
+     */
+    private retryEstablishMediaConnectionWithForcedTurnDiscovery;
+    /**
+     * Does relevant clean up before retrying to establish media connection
+     * and performs the retry with forced turn discovery
+     *
+     * @private
+     * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+     * @param {BundlePolicy} [bundlePolicy]
+     * @returns {Promise<void>}
+     */
+    private retryWithForcedTurnDiscovery;
+    /**
+     * If waitForMediaConnectionConnected() fails when we haven't done turn discovery then we
+     * attempt to establish a media connection again, but this time using turn discovery. If we
+     * used turn discovery on the first pass we do not attempt connection again.
+     *
+     * @private
+     * @param {Error} error
+     * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+     * @param {BundlePolicy} [bundlePolicy]
+     * @returns {Promise<void>}
+     */
+    private handleWaitForMediaConnectionConnectedError;
+    /**
+     * Does TURN discovery, SDP offer/answer exhange, establishes ICE connection and DTLS handshake.
+     *
+     * @private
+     * @param {RemoteMediaManagerConfiguration} [remoteMediaManagerConfig]
+     * @param {BundlePolicy} [bundlePolicy]
+     * @param {boolean} [isForced] - let isForced be true to do turn discovery regardless of reachability results
+     * @returns {Promise<void>}
+     */
+    private establishMediaConnection;
+    /**
+     * Cleans up stats analyzer, peer connection, and turns off listeners
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private cleanUpOnAddMediaFailure;
+    /**
+     * Sends stats report, closes peer connection and cleans up any media connection
+     * related things before trying to establish media connection again with turn server
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private cleanUpBeforeRetryWithTurnServer;
+    /**
+     * Creates a media connection to the server. Media connection is required for sending or receiving any audio/video.
+     *
+     * @param {AddMediaOptions} options
+     * @returns {Promise<void>}
      * @public
      * @memberof Meeting
      */
-    addMedia(options?: any): any;
+    addMedia(options?: AddMediaOptions): Promise<void>;
     /**
      * Informs if the peer connection is in a state that can be updated with updateMedia (audio/video/share)
      * @returns {Boolean}
      */
     canUpdateMedia(): boolean;
+    /**
+     *  media failed, so collect a stats report from webrtc using the wcme connection to grab the rtc stats report
+     * send a webrtc telemetry dump to the configured server using the internal media core check metrics configured callback
+     * @param {String} callFrom - the function calling this function, optional.
+     * @returns {Promise<void>}
+     */
+    private forceSendStatsReport;
     /**
      * Enqueues a media update operation.
      * @param {String} mediaUpdateType one of MEDIA_UPDATE_TYPE values
@@ -1164,86 +1311,26 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     processNextQueuedMediaUpdate: () => void;
     /**
-     * A confluence of updateAudio, updateVideo, and updateShare
-     * this function re-establishes all of the media streams with new options
-     * @param {Object} options
-     * @param {MediaStream} options.localStream
-     * @param {MediaStream} options.localShare
-     * @param {MediaDirection} options.mediaSettings
-     * @returns {Promise}
-     * @todo fix setRemoteStream for updateMedia
-     * @public
-     * @memberof Meeting
-     */
-    updateMedia(options?: {
-        localStream?: MediaStream;
-        localShare?: MediaStream;
-        mediaSettings?: any;
-    }): any;
-    /**
-     * Update the main audio track with new parameters
-     * @param {Object} options
-     * @param {boolean} options.sendAudio
-     * @param {boolean} options.receiveAudio
-     * @param {MediaStream} options.stream Stream that contains the audio track to update
-     * @returns {Promise}
-     * @public
-     * @memberof Meeting
-     */
-    updateAudio(options: {
-        sendAudio: boolean;
-        receiveAudio: boolean;
-        stream: MediaStream;
-    }): Promise<any>;
-    /**
-     * Update the main video track with new parameters
-     * @param {Object} options
-     * @param {boolean} options.sendVideo
-     * @param {boolean} options.receiveVideo
-     * @param {MediaStream} options.stream Stream that contains the video track to update
-     * @returns {Promise}
-     * @public
-     * @memberof Meeting
-     */
-    updateVideo(options: {
-        sendVideo: boolean;
-        receiveVideo: boolean;
-        stream: MediaStream;
-    }): any;
-    /**
-     * Internal function when stopping a share stream, cleanup
-     * @param {boolean} sendShare
-     * @param {boolean} previousShareStatus
-     * @returns {Promise}
-     * @private
-     * @memberof Meeting
-     */
-    private checkForStopShare;
-    /**
-     * Update the share streams, can be used to start sharing
+     * Updates the media connection - it allows to enable/disable all audio/video/share in the meeting.
+     * This does not affect the published tracks, so for example if a microphone track is published and
+     * updateMedia({audioEnabled: false}) is called, the audio will not be sent or received anymore,
+     * but the track's "published" state is not changed and when updateMedia({audioEnabled: true}) is called,
+     * the sending of the audio from the same track will resume.
+     *
      * @param {Object} options
-     * @param {boolean} options.sendShare
-     * @param {boolean} options.receiveShare
+     * @param {boolean} options.audioEnabled [optional] enables/disables receiving and sending of main audio in the meeting
+     * @param {boolean} options.videoEnabled [optional] enables/disables receiving and sending of main video in the meeting
+     * @param {boolean} options.shareEnabled [optional] enables/disables receiving and sending of screen share in the meeting
      * @returns {Promise}
      * @public
      * @memberof Meeting
      */
-    updateShare(options: {
-        sendShare?: boolean;
-        receiveShare?: boolean;
-        stream?: any;
-        skipSignalingCheck?: boolean;
-    }): any;
-    /**
-     * Do all the attach media pre set up before executing the actual attach
-     * @param {MediaStream} localStream
-     * @param {MediaStream} localShare
-     * @param {MediaDirection} mediaSettings
-     * @returns {undefined}
-     * @private
-     * @memberof Meeting
-     */
-    private preMedia;
+    updateMedia(options: {
+        audioEnabled?: boolean;
+        videoEnabled?: boolean;
+        shareAudioEnabled?: boolean;
+        shareVideoEnabled?: boolean;
+    }): Promise<void>;
     /**
      * Acknowledge the meeting, outgoing or incoming
      * @param {String} type
@@ -1251,7 +1338,11 @@ export default class Meeting extends StatelessWebexPlugin {
      * @public
      * @memberof Meeting
      */
-    acknowledge(type: string): any;
+    acknowledge(type: string): Promise<{
+        response: any;
+    }> | Promise<{
+        message: string;
+    }>;
     /**
      * Decline this meeting
      * @param {String} reason
@@ -1261,15 +1352,45 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     decline(reason: string): any;
     /**
-     * Leave the current meeting
+     * Returns a promise that will resolve to fetch options for leaving a meeting.
+     *
+     * This is to support quickly submitting a leave request when the browser/tab is closing.
+     * Calling meeting.leave will not work because there are some async steps that will
+     * not complete before the browser is closed.  Instead, we pre-gather all the
+     * information/options needed for the request(s), and then simply and quickly
+     * fire the fetch(es) when pagehide is triggered.
+     *
+     * We must use fetch instead of request because fetch has a keepalive option that
+     * allows the request it to outlive the page.
+     *
+     * Note: the $timings values will be wrong, but setRequestTimingsAndFetch() will
+     * properly adjust them before submitting.
+     *
+     * @public
      * @param {Object} options leave options
      * @param {String} options.resourceId the device with which to leave from, empty if just the computer
+     * @param {any} options.reason the reason for leaving
+     * @returns {Promise} resolves to options to be used with fetch
+     */
+    buildLeaveFetchRequestOptions(options?: {
+        resourceId?: string;
+        reason?: any;
+    }): any;
+    /**
+     * Leave the current meeting
+     * @param {Object} options - leave options
+     * @param {String} [options.resourceId] - the device with which to leave from, empty if just the computer
+     * @param {String} [options.clientEventLeaveReason] - the leaveReason to include in the Call Analyzer event.
+     *                 Must be one of: 'paired-leave' | 'one-to-one' | 'ended-by-locus' (defaults to no reason)
+     *                 https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/main/diagnostic-events.raml#L796
+     * @param {String} [options.reason] - only used for logging
      * @returns {Promise}
      * @public
      * @memberof Meeting
      */
     leave(options?: {
         resourceId?: string;
+        clientEventLeaveReason?: ClientEventLeaveReason;
         reason?: any;
     }): any;
     /**
@@ -1297,12 +1418,12 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     private requestScreenShareFloor;
     /**
-     * Stops the screen share
-     * @returns {Promise} see #updateShare
-     * @public
-     * @memberof Meeting
+     * Requests screen share floor if such request is pending.
+     * It should be called whenever meeting state changes to JOINED
+     *
+     * @returns {void}
      */
-    stopShare(options?: {}): any;
+    private requestScreenShareFloorIfPending;
     /**
      * Sends a request to Locus to release the screen share floor.
      * @returns {Promise} see #meetingRequest.changeMeetingFloor
@@ -1333,6 +1454,16 @@ export default class Meeting extends StatelessWebexPlugin {
      * @memberof Meeting
      */
     setDisallowUnmute(enabled: boolean): Promise<any>;
+    /**
+     * set the mute all flag for participants if you're the host
+     * @returns {Promise}
+     * @param {boolean} mutedEnabled
+     * @param {boolean} disallowUnmuteEnabled
+     * @param {boolean} muteOnEntryEnabled
+     * @public
+     * @memberof Meeting
+     */
+    setMuteAll(mutedEnabled: boolean, disallowUnmuteEnabled: boolean, muteOnEntryEnabled: boolean): Promise<any>;
     /**
      * End the recording of this meeting
      * @returns {Promise}
@@ -1383,7 +1514,7 @@ export default class Meeting extends StatelessWebexPlugin {
      * @public
      * @memberof Meeting
      */
-    sendDTMF(tones: string): any;
+    sendDTMF(tones: string): Promise<any>;
     /**
      * Sends request to change layout type for the current meeting for the specific participant/device only
      * @param {String} [layoutType] a layout type that should be available in meeting constants {@link #layout_types}
@@ -1408,50 +1539,41 @@ export default class Meeting extends StatelessWebexPlugin {
             height: number;
         };
     }): any;
-    /**
-     * Sets the quality of the local video stream
-     * @param {String} level {LOW|MEDIUM|HIGH}
-     * @returns {Promise<MediaStream>} localStream
-     */
-    setLocalVideoQuality(level: string): any;
     /**
      * Sets the quality level of the remote incoming media
      * @param {String} level {LOW|MEDIUM|HIGH}
      * @returns {Promise}
      */
-    setRemoteQualityLevel(level: string): any;
+    setRemoteQualityLevel(level: string): Promise<void>;
     /**
-     * This is deprecated, please use setLocalVideoQuality for setting local and setRemoteQualityLevel for remote
-     * @param {String} level {LOW|MEDIUM|HIGH}
-     * @returns {Promise}
-     * @deprecated After FHD support
+     * Functionality for when a share audio is ended.
+     * @private
+     * @memberof Meeting
+     * @returns {undefined}
      */
-    setMeetingQuality(level: string): any;
+    private handleShareAudioStreamEnded;
     /**
-     * @param {Object} options parameter
-     * @param {Boolean} options.sendAudio send audio from the display share
-     * @param {Boolean} options.sendShare send video from the display share
-     * @param {Object} options.sharePreferences
-     * @param {MediaTrackConstraints} options.sharePreferences.shareConstraints constraints to apply to video
-     *   @see {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackConstraints}
-     * @param {Boolean} options.sharePreferences.highFrameRate if shareConstraints isn't provided, set default values based off of this boolean
-     * @returns {Promise}
+     * Functionality for when a share video is muted or unmuted.
+     * @private
+     * @memberof Meeting
+     * @param {boolean} muted
+     * @returns {undefined}
      */
-    shareScreen(options?: {
-        sendAudio: boolean;
-        sendShare: boolean;
-        sharePreferences: {
-            shareConstraints: MediaTrackConstraints;
-        };
-    }): any;
+    private handleShareVideoStreamMuteStateChange;
     /**
-     * Functionality for when a share is ended.
+     * Functionality for when a share video is ended.
      * @private
      * @memberof Meeting
-     * @param {MediaStream} localShare
      * @returns {undefined}
      */
-    private handleShareTrackEnded;
+    private handleShareVideoStreamEnded;
+    /**
+     * Emits meeting:stoppedSharingLocal
+     * @private
+     * @returns {undefined}
+     * @memberof Meeting
+     */
+    private triggerStoppedSharing;
     /**
      * Emits the 'network:quality' event
      * 1 indicates an acceptable uplink network.
@@ -1466,92 +1588,16 @@ export default class Meeting extends StatelessWebexPlugin {
     private sendNetworkQualityEvent;
     /**
      * Handle logging the media
-     * @param {Object} audioTrack The audio track
-     * @param {Object} videoTrack The video track
+     * @param {Object} mediaProperties
      * @private
      * @returns {undefined}
      */
     private handleMediaLogging;
-    /**
-     * @param {string} typeMedia 'audio' or 'video'
-     * @returns {undefined}
-     */
-    setStartSetupDelay(typeMedia: string): void;
-    /**
-     * @param {string} typeMedia 'audio' or 'video'
-     * @returns {undefined}
-     */
-    setEndSetupDelay(typeMedia: string): void;
-    /**
-     * @param {string} typeMedia 'audio' or 'video'
-     * @returns {string} duration between start and end of setup
-     */
-    getSetupDelayDuration(typeMedia: string): number;
-    /**
-     * @param {string} typeMedia 'audio' or 'video'
-     * @returns {undefined}
-     */
-    setStartSendingMediaDelay(typeMedia: string): void;
-    /**
-     * @param {string} typeMedia 'audio' or 'video'
-     * @returns {undefined}
-     */
-    setEndSendingMediaDelay(typeMedia: string): void;
-    /**
-     * @param {string} typeMedia 'audio' or 'video'
-     * @returns {string} duration between join response and first media tx
-     */
-    getSendingMediaDelayDuration(typeMedia: string): number;
-    /**
-     *
-     * @returns {undefined}
-     */
-    setStartLocalSDPGenRemoteSDPRecvDelay(): void;
-    /**
-     *
-     * @returns {undefined}
-     */
-    setEndLocalSDPGenRemoteSDPRecvDelay(): void;
-    /**
-     *
-     * @returns {string} duration between local SDP generation and remote SDP reception
-     */
-    getLocalSDPGenRemoteSDPRecvDelay(): number;
-    /**
-     *
-     * @returns {undefined}
-     */
-    setStartCallInitiateJoinReq(): void;
-    /**
-     *
-     * @returns {undefined}
-     */
-    setEndCallInitiateJoinReq(): void;
-    /**
-     *
-     * @returns {string} duration between call initiate and sending join request to locus
-     */
-    getCallInitiateJoinReq(): number;
-    /**
-     *
-     * @returns {undefined}
-     */
-    setStartJoinReqResp(): void;
-    /**
-     *
-     * @returns {undefined}
-     */
-    setEndJoinReqResp(): void;
-    /**
-     *
-     * @returns {string} duration between sending locus join request and receiving join response
-     */
-    getJoinReqResp(): number;
     /**
      *
-     * @returns {string} duration between call initiate and successful locus join (even if it is in lobby)
+     * @returns {string} one of 'attendee','host','cohost', returns the user type of the current user
      */
-    getTotalJmt(): number;
+    getCurUserType(): "host" | "cohost" | "attendee";
     /**
      * End the current meeting for all
      * @returns {Promise}
@@ -1567,56 +1613,107 @@ export default class Meeting extends StatelessWebexPlugin {
      */
     clearMeetingData: () => void;
     /**
-     * Internal API to return status of BNR
-     * @returns {Boolean}
-     * @public
+     * starts keepAlives being sent
+     * @returns {void}
+     * @private
      * @memberof Meeting
      */
-    isBnrEnabled(): any;
+    startKeepAlive: () => void;
     /**
-     * Internal API to obtain BNR enabled MediaStream
-     * @returns {Promise<MediaStreamTrack>}
+     * stops keepAlives being sent
+     * @returns {void}
      * @private
-     * @param {MedaiStreamTrack} audioTrack from updateAudio
      * @memberof Meeting
      */
-    private internal_enableBNR;
+    stopKeepAlive: () => void;
     /**
-     * Enable the audio track with BNR for a meeting
-     * @returns {Promise} resolves the data from enable bnr or rejects if there is no audio or audio is muted
+     * Send a reaction inside the meeting.
+     *
+     * @param {ReactionServerType} reactionType - type of reaction to be sent. Example: "thumbs_up"
+     * @param {SkinToneType} skinToneType - skin tone for the reaction. Example: "medium_dark"
+     * @returns {Promise}
      * @public
      * @memberof Meeting
      */
-    enableBNR(): any;
+    sendReaction(reactionType: ReactionServerType, skinToneType?: SkinToneType): any;
     /**
-     * Disable the BNR for an audio track
-     * @returns {Promise} resolves the data from disable bnr or rejects if there is no audio set
+     * Method to enable or disable reactions inside the meeting.
+     *
+     * @param  {boolean} enable - enable or disable reactions
+     * @returns {Promise}
      * @public
      * @memberof Meeting
      */
-    disableBNR(): any;
+    toggleReactions(enable: boolean): Promise<any>;
     /**
-     * starts keepAlives being sent
+     * Throws if we don't have a media connection created
+     *
      * @returns {void}
-     * @private
-     * @memberof Meeting
      */
-    startKeepAlive: () => void;
+    private checkMediaConnection;
     /**
-     * stops keepAlives being sent
-     * @returns {void}
-     * @private
-     * @memberof Meeting
+     * Method to enable or disable the 'Music mode' effect on audio stream
+     *
+     * @param {boolean} shouldEnableMusicMode
+     * @returns {Promise}
      */
-    stopKeepAlive: () => void;
+    enableMusicMode(shouldEnableMusicMode: boolean): Promise<void>;
+    /** Updates the tracks being sent on the transcoded media connection
+     *
+     * @returns {Promise<void>}
+     */
+    private updateTranscodedMediaConnection;
     /**
-     * Send a reaction inside the meeting.
+     * Publishes a stream.
      *
-     * @param {ReactionType} reactionType - type of reaction to be sent. Example: "thumbs_up"
-     * @param {SkinToneType} skinToneType - skin tone for the reaction. Example: "medium_dark"
+     * @param {MediaType} mediaType of the stream
+     * @param {LocalStream} stream to publish
      * @returns {Promise}
-     * @public
-     * @memberof Meeting
      */
-    sendReaction(reactionType: ReactionType, skinToneType?: SkinToneType): any;
+    private publishStream;
+    /**
+     * Un-publishes a stream.
+     *
+     * @param {MediaType} mediaType of the stream
+     * @param {LocalStream} stream to unpublish
+     * @returns {Promise}
+     */
+    private unpublishStream;
+    /**
+     * Publishes specified local streams in the meeting
+     *
+     * @param {Object} streams
+     * @returns {Promise}
+     */
+    publishStreams(streams: LocalStreams): Promise<void>;
+    /**
+     * Un-publishes specified local streams in the meeting
+     *
+     * @param {Array<LocalStream>} streams
+     * @returns {Promise}
+     */
+    unpublishStreams(streams: LocalStream[]): Promise<void>;
+    /**
+     * Gets permission token expiry information including timeLeft, expiryTime, currentTime
+     * (from the time the function has been fired)
+     *
+     * @returns {object} permissionTokenExpiryInfo
+     * @returns {number} permissionTokenExpiryInfo.timeLeft The time left for token to expire
+     * @returns {number} permissionTokenExpiryInfo.expiryTime The expiry time of permission token from the server
+     * @returns {number} permissionTokenExpiryInfo.currentTime The current time of the local machine
+     */
+    getPermissionTokenExpiryInfo(): {
+        timeLeft: number;
+        expiryTime: number;
+        currentTime: number;
+    };
+    /**
+     * Check if there is enough time left till the permission token expires
+     * If not - refresh the permission token
+     *
+     * @param {number} threshold - time in seconds
+     * @param {string} reason - reason for refreshing the permission token
+     * @returns {Promise<void>}
+     */
+    checkAndRefreshPermissionToken(threshold: number, reason: string): Promise<void>;
 }