@webex/plugin-meetings 3.0.0-bnr.5 → 3.0.0-stream-classes.2

package/dist/types/meeting/locusMediaRequest.d.ts

@@ -0,0 +1,75 @@
+import { WebexPlugin } from '@webex/webex-core';
+import { IP_VERSION } from '../constants';
+export type MediaRequestType = 'RoapMessage' | 'LocalMute';
+export type RequestResult = any;
+export type RoapRequest = {
+    type: 'RoapMessage';
+    selfUrl: string;
+    mediaId: string;
+    roapMessage: any;
+    reachability: any;
+    sequence?: any;
+    joinCookie: any;
+    ipVersion: IP_VERSION;
+};
+export type LocalMuteRequest = {
+    type: 'LocalMute';
+    selfUrl: string;
+    mediaId: string;
+    sequence?: any;
+    muteOptions: {
+        audioMuted?: boolean;
+        videoMuted?: boolean;
+    };
+    ipVersion: IP_VERSION;
+};
+export type Request = RoapRequest | LocalMuteRequest;
+export type Config = {
+    device: {
+        url: string;
+        deviceType: string;
+        countryCode?: string;
+        regionCode?: string;
+    };
+    correlationId: string;
+    preferTranscoding: boolean;
+};
+/**
+ * This class manages all /media API requests to Locus. Every call to that
+ * Locus API has to go through this class.
+ */
+export declare class LocusMediaRequest extends WebexPlugin {
+    private config;
+    private latestAudioMuted?;
+    private latestVideoMuted?;
+    private isRequestInProgress;
+    private queuedRequests;
+    private confluenceState;
+    /**
+     * Constructor
+     */
+    constructor(config: Config, options: any);
+    /**
+     * Add a request to the internal queue.
+     */
+    private addToQueue;
+    /**
+     * Takes the next request from the queue and executes it. Once that
+     * request is completed, the next one will be taken from the queue
+     * and executed and this is repeated until the queue is empty.
+     */
+    private executeNextQueuedRequest;
+    /**
+     * Returns latest requested audio and video mute values. If they have never been
+     * requested, we assume audio/video to be muted.
+     */
+    private getLatestMuteState;
+    /**
+     * Prepares the uri and body for the media request to be sent to Locus
+     */
+    private sendHttpRequest;
+    /**
+     * Sends a media request to Locus
+     */
+    send(request: Request): Promise<RequestResult>;
+}

package/dist/types/meeting/muteState.d.ts

@@ -1,25 +1,35 @@
 import { ServerMuteReason } from '@webex/media-helpers';
-export declare const createMuteState: (type: any, meeting: any, mediaDirection: any, sdkOwnsLocalTrack: boolean) => MuteState;
+export declare const createMuteState: (type: any, meeting: any, enabled: boolean) => MuteState;
 /** The purpose of this class is to manage the local and remote mute state and make sure that the server state always matches
    the last requested state by the client.
 
    More info about Locus muting API: https://sqbu-github.cisco.com/pages/WebExSquared/locus/guides/mute.html#
+
+   This class is exported only for unit tests. It should never be instantiated directly with new MuteState(), instead createMuteState() should be called
 */
-declare class MuteState {
-    pendingPromiseReject: any;
-    pendingPromiseResolve: any;
-    state: any;
+export declare class MuteState {
+    state: {
+        client: {
+            enabled: boolean;
+            localMute: boolean;
+        };
+        server: {
+            localMute: boolean;
+            remoteMute: boolean;
+            unmuteAllowed: boolean;
+        };
+        syncToServerInProgress: boolean;
+    };
     type: any;
-    sdkOwnsLocalTrack: boolean;
     ignoreMuteStateChange: boolean;
     /**
      * Constructor
      *
      * @param {String} type - audio or video
      * @param {Object} meeting - the meeting object (used for reading current remote mute status)
-     * @param {boolean} sdkOwnsLocalTrack - if false, then client app owns the local track (for now that's the case only for multistream meetings)
+     * @param {boolean} enabled - whether the client audio/video is enabled at all
      */
-    constructor(type: string, meeting: any, sdkOwnsLocalTrack: boolean);
+    constructor(type: string, meeting: any, enabled: boolean);
     /**
      * Starts the mute state machine. Needs to be called after a new MuteState instance is created.
      *
@@ -28,58 +38,57 @@ declare class MuteState {
      */
     init(meeting: any): void;
     /**
-     * This method needs to be called whenever the local audio/video track has changed.
-     * It reapplies the remote mute state onto the new track and also reads the current
-     * local mute state from the track and updates the internal state machine and sends
+     * This method needs to be called whenever the local audio/video stream has changed.
+     * It reapplies the remote mute state onto the new stream and also reads the current
+     * local mute state from the stream and updates the internal state machine and sends
      * any required requests to the server.
      *
      * @param {Object} meeting - the meeting object
      * @returns {void}
      */
-    handleLocalTrackChange(meeting: any): void;
+    handleLocalStreamChange(meeting: any): void;
     /**
-     * Mutes/unmutes local track
+     * Enables/disables audio/video
      *
      * @param {Object} meeting - the meeting object
-     * @param {Boolean} mute - true to mute the track, false to unmute it
-     * @param {ServerMuteReason} reason - reason for muting/unmuting
+     * @param {boolean} enable
      * @returns {void}
      */
-    private muteLocalTrack;
+    enable(meeting: any, enable: boolean): void;
     /**
-     * Handles mute/unmute request from the client/user. Returns a promise that's resolved once the server update is completed or
-     * at the point that this request becomese superseded by another client request.
-     *
-     * The client doesn't have to wait for the returned promise to resolve before calling handleClientRequest() again. If
-     * handleClientRequest() is called again before the previous one resolved, the MuteState class will make sure that eventually
-     * the server state will match the last requested state from the client.
+     * Mutes/unmutes local stream
      *
-     * @public
-     * @memberof MuteState
-     * @param {Object} [meeting] the meeting object
-     * @param {Boolean} [mute] true for muting, false for unmuting request
-     * @returns {Promise}
+     * @param {Object} meeting - the meeting object
+     * @param {Boolean} mute - true to mute the stream, false to unmute it
+     * @param {ServerMuteReason} reason - reason for muting/unmuting
+     * @returns {void}
      */
-    handleClientRequest(meeting: object, mute?: boolean): Promise<unknown>;
+    private muteLocalStream;
     /**
-     * This method should be called when the local track mute state is changed
+     * This method should be called when the local stream mute state is changed
      * @public
      * @memberof MuteState
      * @param {Object} [meeting] the meeting object
      * @param {Boolean} [mute] true for muting, false for unmuting request
      * @returns {void}
      */
-    handleLocalTrackMuteStateChange(meeting?: object, mute?: boolean): void;
+    handleLocalStreamMuteStateChange(meeting?: object, mute?: boolean): void;
     /**
-     * Applies the current mute state to the local track (by enabling or disabling it accordingly)
+     * Applies the current mute state to the local stream (by enabling or disabling it accordingly)
      *
      * @public
      * @param {Object} [meeting] the meeting object
-     * @param {ServerMuteReason} reason - reason why we're applying our client state to the local track
+     * @param {ServerMuteReason} reason - reason why we're applying our client state to the local stream
      * @memberof MuteState
      * @returns {void}
      */
     applyClientStateLocally(meeting?: any, reason?: ServerMuteReason): void;
+    /** Returns true if client is locally muted - it takes into account not just the client local mute state,
+     *  but also whether audio/video is enabled at all
+     *
+     * @returns {boolean}
+     */
+    private getClientLocalMuteState;
     /**
      * Updates the server local and remote mute values so that they match the current client desired state.
      *
@@ -107,18 +116,18 @@ declare class MuteState {
      * @returns {Promise}
      */
     private sendRemoteMuteRequestToServer;
-    /** Sets the mute state of the local track according to what server thinks is our state
+    /** Sets the mute state of the local stream according to what server thinks is our state
      * @param {Object} meeting - the meeting object
-     * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local track
+     * @param {ServerMuteReason} serverMuteReason - reason why we're applying server mute to the local stream
      * @returns {void}
      */
-    private applyServerMuteToLocalTrack;
-    /** Applies the current value for unmute allowed to the underlying track
+    private applyServerMuteToLocalStream;
+    /** Applies the current value for unmute allowed to the underlying stream
      *
      * @param {Meeting} meeting
      * @returns {void}
      */
-    private applyUnmuteAllowedToTrack;
+    private applyUnmuteAllowedToStream;
     /**
      * This method should be called whenever the server remote mute state is changed
      *
@@ -140,13 +149,14 @@ declare class MuteState {
      */
     handleServerLocalUnmuteRequired(meeting?: object): void;
     /**
-     * Returns true if the user is locally or remotely muted
+     * Returns true if the user is locally or remotely muted.
+     * It only checks the mute status, ignoring the fact whether audio/video is enabled.
      *
      * @public
      * @memberof MuteState
      * @returns {Boolean}
      */
-    isMuted(): any;
+    isMuted(): boolean;
     /**
      * Returns true if the user is remotely muted
      *
@@ -154,7 +164,7 @@ declare class MuteState {
      * @memberof MuteState
      * @returns {Boolean}
      */
-    isRemotelyMuted(): any;
+    isRemotelyMuted(): boolean;
     /**
      * Returns true if unmute is allowed
      *
@@ -162,24 +172,13 @@ declare class MuteState {
      * @memberof MuteState
      * @returns {Boolean}
      */
-    isUnmuteAllowed(): any;
-    /**
-     * Returns true if the user is locally muted
-     *
-     * @public
-     * @memberof MuteState
-     * @returns {Boolean}
-     */
-    isLocallyMuted(): any;
+    isUnmuteAllowed(): boolean;
     /**
-     * Returns true if the user is muted as a result of the client request (and not remotely muted)
+     * Returns true if the user is locally muted or audio/video is disabled
      *
      * @public
      * @memberof MuteState
      * @returns {Boolean}
      */
-    isSelf(): boolean;
-    get muted(): any;
-    get self(): boolean;
+    isLocallyMuted(): boolean;
 }
-export {};

package/dist/types/meeting/request.d.ts

@@ -1,10 +1,15 @@
 import { StatelessWebexPlugin } from '@webex/webex-core';
+import { IP_VERSION } from '../constants';
 import { SendReactionOptions, ToggleReactionsOptions } from './request.type';
+import { AnnotationInfo } from '../annotation/annotation.types';
 /**
  * @class MeetingRequest
  */
 export default class MeetingRequest extends StatelessWebexPlugin {
     changeVideoLayoutDebounced: any;
+    meetingRef: WeakRef<any>;
+    locusDeltaRequest: (options: object) => Promise<any>;
+    buildLocusDeltaRequestOptions: (options: object) => Promise<any>;
     /**
      * Constructor
      * @param {Object} attrs
@@ -30,6 +35,9 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      * @param {boolean} options.moveToResource
      * @param {Object} options.roapMessage
      * @param {boolean} options.breakoutsSupported
+     * @param {String} options.locale,
+     * @param {Array} options.deviceCapabilities
+     * @param {boolean} options.liveAnnotationSupported
      * @returns {Promise}
      */
     joinMeeting(options: {
@@ -49,6 +57,10 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         permissionToken: any;
         preferTranscoding: any;
         breakoutsSupported: boolean;
+        locale?: string;
+        deviceCapabilities?: Array<string>;
+        liveAnnotationSupported: boolean;
+        ipVersion: IP_VERSION;
     }): Promise<any>;
     /**
      * Send a request to refresh the captcha
@@ -83,26 +95,13 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      */
     private dialOut;
     /**
-     * Syns the missed delta event
+     * Sends a requests to get the latest locus DTO, it might be a full Locus or a delta, depending on the url provided
      * @param {Object} options
-     * @param {boolean} options.desync flag to get partial or whole locus object
-     * @param {String} options.syncUrl sync url to get ht elatest locus delta
-     * @returns {Promise}
-     */
-    syncMeeting(options: {
-        desync: boolean;
-        syncUrl: string;
-    }): any;
-    /**
-     * Request to get the complete locus object
-     * @param {Object} options
-     * @param {boolean} options.desync flag to get partial or whole locus object
      * @param {String} options.locusUrl sync url to get ht elatest locus delta
      * @returns {Promise}
      */
-    getFullLocus(options: {
-        desync: boolean;
-        locusUrl: string;
+    getLocusDTO(options: {
+        url: string;
     }): any;
     /**
      * Make a network request to make a provisioned phone leave the meeting
@@ -116,13 +115,36 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      */
     private disconnectPhoneAudio;
     /**
-     * Make a network request to leave a meeting
+     * Prepares request options to to leave a meeting
      * @param {Object} options
      * @param {Url} options.locusUrl
      * @param {String} options.selfId
      * @param {Url} options.deviceUrl
      * @param {String} options.resourceId,
      * @param {String} options.correlationId
+     * @returns {Object} request options
+     */
+    prepareLeaveMeetingRequestOptions({ locusUrl, selfId, deviceUrl: url, resourceId, correlationId, }: {
+        locusUrl: string;
+        selfId: string;
+        deviceUrl: string;
+        resourceId: string;
+        correlationId: string;
+    }): {
+        method: string;
+        uri: string;
+        body: {
+            device: {
+                deviceType: any;
+                url: string;
+            };
+            usingResource: string;
+            correlationId: string;
+        };
+    };
+    /**
+     * Make a network request to leave a meeting
+     * @param {Object} options
      * @returns {Promise}
      */
     leaveMeeting({ locusUrl, selfId, deviceUrl: url, resourceId, correlationId, }: {
@@ -131,7 +153,13 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         deviceUrl: string;
         resourceId: string;
         correlationId: string;
-    }): any;
+    }): Promise<any>;
+    /**
+     * Builds request options to leave a meeting
+     * @param {Object} options
+     * @returns {Object} request options
+     */
+    buildLeaveMeetingRequestOptions(options: any): Promise<any>;
     /**
      * Make a network request to acknowledge a meeting
      * @param {Object} options
@@ -144,8 +172,14 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         locusUrl: string;
         deviceUrl: string;
         correlationId: string;
-    }): any;
-    lockMeeting(options: any): any;
+    }): Promise<any>;
+    /**
+     * Makes a network request to lock the meeting
+     * @param {Object} options
+     * @param {Boolean} options.lock Whether it is locked or not
+     * @returns {Promise}
+     */
+    lockMeeting(options: any): Promise<any>;
     /**
      * Make a network request to decline a meeting
      * @param {Object} options
@@ -158,25 +192,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         locusUrl: string;
         deviceUrl: string;
         reason: string;
-    }): any;
-    /**
-     * Toggle remote audio and/or video
-     * @param {Object} options options for toggling
-     * @param {String} options.selfId Locus self id??
-     * @param {String} options.locusUrl Locus url
-     * @param {String} options.deviceUrl Url of a device
-     * @param {String} options.resourceId Populated if you are paired to a device
-     * @param {String} options.localMedias local sdps
-     * @param {Boolean} options.preferTranscoding false for multistream (Homer), true for transcoded media (Edonus)
-     * @returns {Promise}
-     */
-    remoteAudioVideoToggle(options: {
-        selfId: string;
-        locusUrl: string;
-        deviceUrl: string;
-        resourceId: string;
-        localMedias: string;
-    } | any): any;
+    }): Promise<any>;
     /**
      * change the content floor grant
      * @param {Object} options options for floor grant
@@ -193,6 +209,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         deviceUrl: string;
         resourceId: string;
         uri: string;
+        annotationInfo: AnnotationInfo;
     } | any): any;
     /**
      * Sends a request to the DTMF endpoint to send tones
@@ -206,7 +223,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         locusUrl: string;
         deviceUrl: string;
         tones: string;
-    }): any;
+    }): Promise<any>;
     /**
      * Sends a request to the controls endpoint to set the video layout
      * @param {Object} options
@@ -233,7 +250,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
             width: number;
             height: number;
         };
-    }): any;
+    }): Promise<any>;
     /**
      * Make a network request to end meeting for all
      * @param {Object} options
@@ -242,7 +259,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      */
     endMeetingForAll({ locusUrl }: {
         locusUrl: string;
-    }): any;
+    }): Promise<any>;
     /**
      * Send a locus keepAlive (used in lobby)
      * @param {Object} options
@@ -267,5 +284,6 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      * @param {locusUrl} options.locusUrl
      * @returns {Promise}
      */
-    toggleReactions({ enable, locusUrl, requestingParticipantId }: ToggleReactionsOptions): any;
+    toggleReactions({ enable, locusUrl, requestingParticipantId }: ToggleReactionsOptions): Promise<any>;
+    getLocusStatusByUrl(locusUrl: string): any;
 }

package/dist/types/meeting/util.d.ts

@@ -1,2 +1,94 @@
-declare const MeetingUtil: any;
+import { SELF_POLICY } from '../constants';
+declare const MeetingUtil: {
+    parseLocusJoin: (response: any) => any;
+    remoteUpdateAudioVideo: (meeting: any, audioMuted?: boolean, videoMuted?: boolean) => any;
+    hasOwner: (info: any) => any;
+    isOwnerSelf: (owner: any, selfId: any) => boolean;
+    isPinOrGuest: (err: any) => boolean;
+    joinMeeting: (meeting: any, options: any) => any;
+    cleanUp: (meeting: any) => any;
+    disconnectPhoneAudio: (meeting: any, phoneUrl: any) => any;
+    /**
+     * Returns options for leaving a meeting.
+     * @param {any} meeting
+     * @param {any} options
+     * @returns {any} leave options
+     */
+    prepareLeaveMeetingOptions: (meeting: any, options?: any) => any;
+    leaveMeeting: (meeting: any, options?: any) => any;
+    declineMeeting: (meeting: any, reason: any) => any;
+    isUserInLeftState: (locusInfo: any) => boolean;
+    isUserInIdleState: (locusInfo: any) => boolean;
+    isUserInJoinedState: (locusInfo: any) => boolean;
+    isMediaEstablished: (currentMediaStatus: any) => any;
+    joinMeetingOptions: (meeting: any, options?: any) => any;
+    /**
+     * Returns request options for leaving a meeting.
+     * @param {any} meeting
+     * @param {any} options
+     * @returns {any} request options
+     */
+    buildLeaveFetchRequestOptions: (meeting: any, options?: any) => any;
+    getTrack: (stream: any) => {
+        audioTrack: any;
+        videoTrack: any;
+    };
+    getModeratorFromLocusInfo: (locusInfo: any) => any;
+    getPolicyFromLocusInfo: (locusInfo: any) => any;
+    getUserDisplayHintsFromLocusInfo: (locusInfo: any) => any;
+    canInviteNewParticipants: (displayHints: any) => any;
+    canAdmitParticipant: (displayHints: any) => any;
+    canUserLock: (displayHints: any) => any;
+    canUserUnlock: (displayHints: any) => any;
+    canUserRaiseHand: (displayHints: any) => any;
+    canUserLowerAllHands: (displayHints: any) => any;
+    canUserLowerSomeoneElsesHand: (displayHints: any) => any;
+    bothLeaveAndEndMeetingAvailable: (displayHints: any) => any;
+    canManageBreakout: (displayHints: any) => any;
+    canBroadcastMessageToBreakout: (displayHints: any, policies?: {}) => boolean;
+    isSuppressBreakoutSupport: (displayHints: any) => any;
+    canAdmitLobbyToBreakout: (displayHints: any) => boolean;
+    isBreakoutPreassignmentsEnabled: (displayHints: any) => boolean;
+    canUserAskForHelp: (displayHints: any) => boolean;
+    lockMeeting: (actions: any, request: any, locusUrl: any) => any;
+    unlockMeeting: (actions: any, request: any, locusUrl: any) => any;
+    handleAudioLogging: (audioStream?: LocalMicrophoneStream) => void;
+    handleVideoLogging: (videoStream?: LocalCameraStream) => void;
+    handleDeviceLogging: (devices?: any[]) => void;
+    endMeetingForAll: (meeting: any) => any;
+    canEnableClosedCaption: (displayHints: any) => any;
+    isSaveTranscriptsEnabled: (displayHints: any) => any;
+    canStartTranscribing: (displayHints: any) => any;
+    canStopTranscribing: (displayHints: any) => any;
+    isClosedCaptionActive: (displayHints: any) => any;
+    isWebexAssistantActive: (displayHints: any) => any;
+    canViewCaptionPanel: (displayHints: any) => any;
+    isRealTimeTranslationEnabled: (displayHints: any) => any;
+    canSelectSpokenLanguages: (displayHints: any) => any;
+    waitingForOthersToJoin: (displayHints: any) => any;
+    canSendReactions: (originalValue: any, displayHints: any) => any;
+    canUserRenameSelfAndObserved: (displayHints: any) => any;
+    canUserRenameOthers: (displayHints: any) => any;
+    canShareWhiteBoard: (displayHints: any) => any;
+    /**
+     * Adds the current locus sequence information to a request body
+     * @param {Object} meeting The meeting object
+     * @param {Object} requestBody The body of a request to locus
+     * @returns {void}
+     */
+    addSequence: (meeting: any, requestBody: any) => void;
+    /**
+     * Updates the locus info for the meeting with the delta locus
+     * returned from requests that include the sequence information
+     * Returns the original response object
+     * @param {Object} meeting The meeting object
+     * @param {Object} response The response of the http request
+     * @returns {Object}
+     */
+    updateLocusWithDelta: (meeting: any, response: any) => any;
+    generateBuildLocusDeltaRequestOptions: (originalMeeting: any) => (originalOptions: any) => any;
+    generateLocusDeltaRequest: (originalMeeting: any) => (originalOptions: any) => any;
+    selfSupportsFeature: (feature: SELF_POLICY, userPolicies: Record<SELF_POLICY, boolean>) => boolean;
+    parseInterpretationInfo: (meeting: any, meetingInfo: any) => void;
+};
 export default MeetingUtil;

package/dist/types/meeting-info/index.d.ts

@@ -53,5 +53,10 @@ export default class MeetingInfo {
      * @public
      * @memberof MeetingInfo
      */
-    fetchMeetingInfo(destination: string, type?: string): any;
+    fetchMeetingInfo(destination: string, type?: string, password?: string, captchaInfo?: {
+        code: string;
+        id: string;
+    }, installedOrgID?: any, locusId?: any, extraParams?: object, options?: {
+        meetingId?: string;
+    }): any;
 }

package/dist/types/meeting-info/meeting-info-v2.d.ts

@@ -82,14 +82,21 @@ export default class MeetingInfoV2 {
      * @memberof MeetingInfo
      */
     fetchInfoOptions(destination: string, type?: string): any;
+    /**
+     * Raises a MeetingInfoV2PolicyError for policy error codes
+     * @param {any} err the error from the request
+     * @returns {void}
+     */
+    handlePolicyError: (err: any) => void;
     /**
      * Creates adhoc space meetings for a space by fetching the conversation infomation
      * @param {String} conversationUrl conversationUrl to start adhoc meeting on
+     * @param {String} installedOrgID org ID of user's machine
      * @returns {Promise} returns a meeting info object
      * @public
      * @memberof MeetingInfo
      */
-    createAdhocSpaceMeeting(conversationUrl: string): Promise<any>;
+    createAdhocSpaceMeeting(conversationUrl: string, installedOrgID?: string): Promise<any>;
     /**
      * Fetches meeting info from the server
      * @param {String} destination one of many different types of destinations to look up info for
@@ -98,8 +105,10 @@ export default class MeetingInfoV2 {
      * @param {Object} captchaInfo
      * @param {String} captchaInfo.code
      * @param {String} captchaInfo.id
-     * @param {String} installedOrgID
+     * @param {String} installedOrgID org ID of user's machine
      * @param {String} locusId
+     * @param {Object} extraParams
+     * @param {Object} options
      * @returns {Promise} returns a meeting info object
      * @public
      * @memberof MeetingInfo
@@ -107,5 +116,7 @@ export default class MeetingInfoV2 {
     fetchMeetingInfo(destination: string, type?: string, password?: string, captchaInfo?: {
         code: string;
         id: string;
-    }, installedOrgID?: any, locusId?: any): Promise<any>;
+    }, installedOrgID?: any, locusId?: any, extraParams?: object, options?: {
+        meetingId?: string;
+    }): Promise<any>;
 }