@webex/plugin-meetings 3.0.0-beta.40 → 3.0.0-beta.401

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

@@ -0,0 +1,74 @@
+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;
+    };
+};
+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,45 +1,94 @@
-export declare const createMuteState: (type: any, meeting: any, mediaDirection: any) => MuteState;
+import { ServerMuteReason } from '@webex/media-helpers';
+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;
+    ignoreMuteStateChange: boolean;
     /**
      * Constructor
      *
      * @param {String} type - audio or video
      * @param {Object} meeting - the meeting object (used for reading current remote mute status)
+     * @param {boolean} enabled - whether the client audio/video is enabled at all
+     */
+    constructor(type: string, meeting: any, enabled: boolean);
+    /**
+     * Starts the mute state machine. Needs to be called after a new MuteState instance is created.
+     *
+     * @param {Object} meeting - the meeting object
+     * @returns {void}
+     */
+    init(meeting: any): void;
+    /**
+     * 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}
      */
-    constructor(type: string, meeting: any);
+    handleLocalStreamChange(meeting: any): 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.
+     * Enables/disables audio/video
      *
-     * 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.
+     * @param {Object} meeting - the meeting object
+     * @param {boolean} enable
+     * @returns {void}
+     */
+    enable(meeting: any, enable: boolean): void;
+    /**
+     * Mutes/unmutes local stream
      *
+     * @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}
+     */
+    private muteLocalStream;
+    /**
+     * 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 {Promise}
+     * @returns {void}
      */
-    handleClientRequest(meeting?: object, mute?: boolean): Promise<unknown>;
+    handleLocalStreamMuteStateChange(meeting?: any): 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 stream
      * @memberof MuteState
      * @returns {void}
      */
-    applyClientStateLocally(meeting?: any): 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.
      *
@@ -67,16 +116,23 @@ declare class MuteState {
      * @returns {Promise}
      */
     private sendRemoteMuteRequestToServer;
+    /** Applies the current value for unmute allowed to the underlying stream
+     *
+     * @param {Meeting} meeting
+     * @returns {void}
+     */
+    private applyUnmuteAllowedToStream;
     /**
      * This method should be called whenever the server remote mute state is changed
      *
      * @public
      * @memberof MuteState
+     * @param {Meeting} meeting
      * @param {Boolean} [muted] true if user is remotely muted, false otherwise
      * @param {Boolean} [unmuteAllowed] indicates if user is allowed to unmute self (false when "hard mute" feature is used)
      * @returns {undefined}
      */
-    handleServerRemoteMuteUpdate(muted?: boolean, unmuteAllowed?: boolean): void;
+    handleServerRemoteMuteUpdate(meeting: any, muted?: boolean, unmuteAllowed?: boolean): void;
     /**
      * This method should be called whenever we receive from the server a requirement to locally unmute
      *
@@ -85,32 +141,38 @@ declare class MuteState {
      * @param {Object} [meeting] the meeting object
      * @returns {undefined}
      */
-    handleServerLocalUnmuteRequired(meeting?: object): void;
+    handleServerLocalUnmuteRequired(meeting?: any): void;
+    /**
+     * 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(): boolean;
     /**
-     * Returns true if the user is locally or remotely muted
+     * Returns true if the user is remotely muted
      *
      * @public
      * @memberof MuteState
      * @returns {Boolean}
      */
-    isMuted(): any;
+    isRemotelyMuted(): boolean;
     /**
-     * Returns true if the user is locally muted
+     * Returns true if unmute is allowed
      *
      * @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,12 +35,16 @@ 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: {
         sipUri: string;
         deviceUrl: string;
         locusUrl: string;
+        locusClusterUrl: string;
         resourceId: string;
         correlationId: string;
         ensureConversation: boolean;
@@ -48,7 +57,12 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         meetingNumber: any;
         permissionToken: any;
         preferTranscoding: any;
+        reachability: any;
         breakoutsSupported: boolean;
+        locale?: string;
+        deviceCapabilities?: Array<string>;
+        liveAnnotationSupported: boolean;
+        ipVersion?: IP_VERSION;
     }): Promise<any>;
     /**
      * Send a request to refresh the captcha
@@ -83,26 +97,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 +117,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 +155,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 +174,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 +194,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
@@ -185,6 +203,7 @@ export default class MeetingRequest extends StatelessWebexPlugin {
      * @param {String} options.deviceUrl Url of a device
      * @param {String} options.resourceId Populated if you are paired to a device
      * @param {String} options.uri floor grant uri
+     * @param {String} options.shareInstanceId id for current share
      * @returns {Promise}
      */
     changeMeetingFloor(options: {
@@ -193,6 +212,8 @@ export default class MeetingRequest extends StatelessWebexPlugin {
         deviceUrl: string;
         resourceId: string;
         uri: string;
+        annotationInfo: AnnotationInfo;
+        shareInstanceId: string;
     } | any): any;
     /**
      * Sends a request to the DTMF endpoint to send tones
@@ -206,7 +227,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 +254,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 +263,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 +288,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,118 @@
-declare const MeetingUtil: any;
+import { SELF_POLICY, IP_VERSION } 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;
+    /**
+     * Returns the current state of knowledge about whether we are on an ipv4-only or ipv6-only or mixed (ipv4 and ipv6) network.
+     * The return value matches the possible values of "ipver" parameter used by the backend APIs.
+     *
+     * @param {Object} webex webex instance
+     * @returns {IP_VERSION|undefined} ipver value to be passed to the backend APIs or undefined if we should not pass any value to the backend
+     */
+    getIpVersion(webex: any): IP_VERSION | undefined;
+    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;
+    /**
+     * Returns a CA-recognized error payload for the specified raw error message/reason.
+     *
+     * New errors can be added to this function for handling in the future
+     *
+     * @param {String} reason the raw error message
+     * @returns {Array<object>} an array of payload objects
+     */
+    getChangeMeetingFloorErrorPayload: (reason: string) => {
+        fatal: boolean;
+        category: string;
+        errorCode: number;
+        errorDescription: string;
+        name: string;
+        shownToUser: boolean;
+    }[];
+};
 export default MeetingUtil;

package/dist/types/meeting/voicea-meeting.d.ts

@@ -0,0 +1,16 @@
+export declare const getSpeaker: (members: any, csis?: any[]) => unknown;
+export declare const getSpeakerFromProxyOrStore: ({ csisKey, meetingMembers, transcriptData }: {
+    csisKey: any;
+    meetingMembers: any;
+    transcriptData: any;
+}) => {
+    speaker: {
+        speakerId: string;
+        name: string;
+    };
+    needsCaching: boolean;
+};
+export declare const processNewCaptions: ({ data, meeting }: {
+    data: any;
+    meeting: any;
+}) => void;

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

@@ -49,9 +49,21 @@ export default class MeetingInfo {
      * Fetches meeting info from the server
      * @param {String} destination one of many different types of destinations to look up info for
      * @param {String} [type] to match up with the destination value
+     * @param {String} [password] meeting password
+     * @param {Object} [captchaInfo] captcha code and id
+     * @param {String} [installedOrgID]
+     * @param {String} [locusId]
+     * @param {Object} [extraParams]
+     * @param {Boolean} [options] meeting Id and whether Call Analyzer events should be sent
      * @returns {Promise} returns a meeting info object
      * @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;
+        sendCAevents?: boolean;
+    }): any;
 }