@webex/plugin-meetings 3.0.0-stream-classes.5 → 3.0.0-test.1

package/dist/types/meetings/index.d.ts

@@ -3,6 +3,7 @@ import '@webex/internal-plugin-conversation';
 import '@webex/internal-plugin-metrics';
 import { WebexPlugin } from '@webex/webex-core';
 import 'webrtc-adapter';
+import { CallStateForMetrics } from '../meeting';
 import Reachability from '../reachability';
 import { INoiseReductionEffect, IVirtualBackgroundEffect } from './meetings.types';
 /**
@@ -159,21 +160,21 @@ export default class Meetings extends WebexPlugin {
      */
     private _toggleUnifiedMeetings;
     /**
-     * API to enable or disable TURN discovery
-     * @param {Boolean} enable
+     * API to toggle starting adhoc meeting
+     * @param {Boolean} changeState
      * @private
      * @memberof Meetings
      * @returns {undefined}
      */
-    private _toggleTurnDiscovery;
+    private _toggleAdhocMeetings;
     /**
-     * API to toggle starting adhoc meeting
-     * @param {Boolean} changeState
+     * API to toggle TCP reachability, needs to be called before webex.meetings.register()
+     * @param {Boolean} newValue
      * @private
      * @memberof Meetings
      * @returns {undefined}
      */
-    private _toggleAdhocMeetings;
+    private _toggleTcpReachability;
     /**
      * Explicitly sets up the meetings plugin by registering
      * the device, connecting to mercury, and listening for locus events.
@@ -223,8 +224,10 @@ export default class Meetings extends WebexPlugin {
      * @returns {String} feedback ID logs were submitted under
      */
     uploadLogs(options?: {
+        autoupload?: boolean;
         callStart?: string;
         feedbackId?: string;
+        locussessionid?: string;
         locusId?: string;
         correlationId?: string;
         meetingId?: string;
@@ -244,7 +247,7 @@ export default class Meetings extends WebexPlugin {
      * @public
      * @memberof Meetings
      */
-    startReachability(): Promise<unknown>;
+    startReachability(): Promise<import("../reachability").ReachabilityResults>;
     /**
      * Get geoHint for info for meetings
      * @returns {Promise}
@@ -277,23 +280,37 @@ export default class Meetings extends WebexPlugin {
      */
     private destroy;
     /**
-     * Create a meeting.
+     * Create a meeting or return an existing meeting.
+     *
+     * When meeting info passed it should be complete, e.g.: fetched after password or captcha provided
+     *
      * @param {string} destination - sipURL, phonenumber, or locus object}
      * @param {string} [type] - the optional specified type, such as locusId
      * @param {Boolean} useRandomDelayForInfo - whether a random delay should be added to fetching meeting info
      * @param {Object} infoExtraParams extra parameters to be provided when fetching meeting info
-     * @param {string} correlationId - the optional specified correlationId
+     * @param {string} correlationId - the optional specified correlationId (callStateForMetrics.correlationId can be provided instead)
+     * @param {Boolean} failOnMissingMeetingInfo - whether to throw an error if meeting info fails to fetch (for calls that are not 1:1 or content share)
+     * @param {CallStateForMetrics} callStateForMetrics - information about call state for metrics
+     * @param {Object} [meetingInfo] - Pre-fetched complete meeting info
+     * @param {String} [meetingLookupUrl] - meeting info prefetch url
      * @returns {Promise<Meeting>} A new Meeting.
      * @public
      * @memberof Meetings
      */
-    create(destination: string, type?: string, useRandomDelayForInfo?: boolean, infoExtraParams?: {}, correlationId?: string): any;
+    create(destination: string, type?: string, useRandomDelayForInfo?: boolean, infoExtraParams?: {}, correlationId?: string, failOnMissingMeetingInfo?: boolean, callStateForMetrics?: CallStateForMetrics, meetingInfo?: any, meetingLookupUrl?: any): any;
     /**
+     * Create meeting
+     *
+     * When meeting info passed it should be complete, e.g.: fetched after password or captcha provided
+     *
      * @param {String} destination see create()
      * @param {String} type see create()
      * @param {Boolean} useRandomDelayForInfo whether a random delay should be added to fetching meeting info
      * @param {Object} infoExtraParams extra parameters to be provided when fetching meeting info
-     * @param {String} correlationId the optional specified correlationId
+     * @param {CallStateForMetrics} callStateForMetrics - information about call state for metrics
+     * @param {Boolean} failOnMissingMeetingInfo - whether to throw an error if meeting info fails to fetch (for calls that are not 1:1 or content share)
+     * @param {Object} [meetingInfo] - Pre-fetched complete meeting info
+     * @param {String} [meetingLookupUrl] - meeting info prefetch url
      * @returns {Promise} a new meeting instance complete with meeting info and destination
      * @private
      * @memberof Meetings
@@ -322,12 +339,15 @@ export default class Meetings extends WebexPlugin {
         endDate: object;
     }): any;
     /**
-     * syncs all the meeting from server
-     * @returns {undefined}
+     * Syncs all the meetings from server. Does nothing and returns immediately if unverified guest.
+     * @param {boolean} keepOnlyLocusMeetings - whether the sync should keep only locus meetings or any other meeting in meetingCollection
+     * @returns {Promise<void>}
      * @public
      * @memberof Meetings
      */
-    syncMeetings(): any;
+    syncMeetings({ keepOnlyLocusMeetings }?: {
+        keepOnlyLocusMeetings?: boolean;
+    }): Promise<void>;
     /**
      * sort out locus array for initial creating
      * @param {Array} loci original locus array
@@ -358,4 +378,12 @@ export default class Meetings extends WebexPlugin {
      * @returns {Logger}
      */
     getLogger(): any;
+    /**
+     * Returns the first meeting it finds that has the webrtc media connection created.
+     * Useful for debugging in the console.
+     *
+     * @private
+     * @returns {Meeting} Meeting object that has a webrtc media connection, else undefined
+     */
+    getActiveWebrtcMeeting(): any;
 }

package/dist/types/member/index.d.ts

@@ -4,6 +4,7 @@ import { IExternalRoles, IMediaStatus } from './types';
  */
 export default class Member {
     associatedUser: any;
+    canReclaimHost: boolean;
     id: any;
     isAudioMuted: any;
     isContentSharing: any;

package/dist/types/members/types.d.ts

@@ -6,6 +6,7 @@ export declare enum ServerRoles {
 export type ServerRoleShape = {
     type: ServerRoles;
     hasRole: boolean;
+    hostKey?: string;
 };
 export type RoleAssignmentOptions = {
     roles: Array<ServerRoleShape>;

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

@@ -121,6 +121,11 @@ declare const MembersUtil: {
             };
         };
     };
+    /**
+     * @param {ServerRoleShape} role
+     * @returns {ServerRoleShape} the role shape to be added to the body
+     */
+    getAddedRoleShape: (role: ServerRoleShape) => ServerRoleShape;
     /**
      * @param {RoleAssignmentOptions} options
      * @returns {RoleAssignmentRequest} the request parameters (method, uri, body) needed to make a addMember request

package/dist/types/metrics/constants.d.ts

@@ -1,12 +1,14 @@
 declare const BEHAVIORAL_METRICS: {
     MEETINGS_REGISTRATION_FAILED: string;
     MEETINGS_REGISTRATION_SUCCESS: string;
+    MEETINGS_REGISTRATION_STEP: string;
     MERCURY_CONNECTION_FAILURE: string;
     MERCURY_CONNECTION_RESTORED: string;
     JOIN_SUCCESS: string;
     JOIN_FAILURE: string;
     ADD_MEDIA_SUCCESS: string;
     ADD_MEDIA_FAILURE: string;
+    ADD_MEDIA_RETRY: string;
     ROAP_MERCURY_EVENT_RECEIVED: string;
     CONNECTION_SUCCESS: string;
     CONNECTION_FAILURE: string;
@@ -16,13 +18,17 @@ declare const BEHAVIORAL_METRICS: {
     GET_USER_MEDIA_FAILURE: string;
     GET_DISPLAY_MEDIA_FAILURE: string;
     JOIN_WITH_MEDIA_FAILURE: string;
+    LLM_CONNECTION_AFTER_JOIN_FAILURE: string;
+    RECEIVE_TRANSCRIPTION_AFTER_JOIN_FAILURE: string;
     DISCONNECT_DUE_TO_INACTIVITY: string;
     MEETING_MEDIA_INACTIVE: string;
     MEETING_RECONNECT_FAILURE: string;
     MEETING_MAX_REJOIN_FAILURE: string;
+    MEETING_SHARE_SUCCESS: string;
     MEETING_SHARE_FAILURE: string;
     MEETING_START_WHITEBOARD_SHARE_FAILURE: string;
     MEETING_STOP_WHITEBOARD_SHARE_FAILURE: string;
+    MEETING_SHARE_VIDEO_MUTE_STATE_CHANGE: string;
     MUTE_AUDIO_FAILURE: string;
     MUTE_VIDEO_FAILURE: string;
     SET_MEETING_QUALITY_FAILURE: string;
@@ -54,5 +60,11 @@ declare const BEHAVIORAL_METRICS: {
     MEETING_INFO_POLICY_ERROR: string;
     LOCUS_DELTA_SYNC_FAILED: string;
     LOCUS_DELTA_OUT_OF_ORDER: string;
+    PERMISSION_TOKEN_REFRESH: string;
+    PERMISSION_TOKEN_REFRESH_ERROR: string;
+    TURN_DISCOVERY_LATENCY: string;
+    ROAP_OFFER_TO_ANSWER_LATENCY: string;
+    ROAP_HTTP_RESPONSE_MISSING: string;
+    TURN_DISCOVERY_REQUIRES_OK: string;
 };
 export { BEHAVIORAL_METRICS as default };

package/dist/types/multistream/mediaRequestManager.d.ts

@@ -1,4 +1,5 @@
 import { StreamRequest } from '@webex/internal-media-core';
+import { NamedMediaGroup } from '@webex/json-multistream';
 import { ReceiveSlot } from './receiveSlot';
 export interface ActiveSpeakerPolicyInfo {
     policy: 'active-speaker';
@@ -6,6 +7,7 @@ export interface ActiveSpeakerPolicyInfo {
     crossPriorityDuplication: boolean;
     crossPolicyDuplication: boolean;
     preferLiveVideo: boolean;
+    namedMediaGroups?: NamedMediaGroup[];
 }
 export interface ReceiverSelectedPolicyInfo {
     policy: 'receiver-selected';

package/dist/types/multistream/remoteMediaGroup.d.ts

@@ -1,9 +1,11 @@
+import { NamedMediaGroup } from '@webex/json-multistream';
 import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
 import { MediaRequestManager } from './mediaRequestManager';
 import { CSI, ReceiveSlot } from './receiveSlot';
 type Options = {
     resolution?: RemoteVideoResolution;
     preferLiveVideo?: boolean;
+    namedMediaGroup?: NamedMediaGroup;
 };
 export declare class RemoteMediaGroup {
     private mediaRequestManager;

package/dist/types/multistream/remoteMediaManager.d.ts

@@ -1,4 +1,6 @@
 import { EventMap } from 'typed-emitter';
+import { MediaType } from '@webex/internal-media-core';
+import { NamedMediaGroup } from '@webex/json-multistream';
 import EventsScope from '../common/events/events-scope';
 import { RemoteMedia, RemoteVideoResolution } from './remoteMedia';
 import { CSI } from './receiveSlot';
@@ -39,6 +41,7 @@ export interface Configuration {
             [key: LayoutId]: VideoLayout;
         };
     };
+    namedMediaGroup?: NamedMediaGroup;
 }
 /**
  * Default configuration:
@@ -49,6 +52,7 @@ export interface Configuration {
 export declare const DefaultConfiguration: Configuration;
 export declare enum Event {
     AudioCreated = "AudioCreated",
+    InterpretationAudioCreated = "InterpretationAudioCreated",
     ScreenShareAudioCreated = "ScreenShareAudioCreated",
     VideoLayoutChanged = "VideoLayoutChanged"
 }
@@ -153,10 +157,22 @@ export declare class RemoteMediaManager extends EventsScope {
         remoteMedia: RemoteMedia;
         csi?: number;
     }[]): void;
+    /**
+     * Sets which named media group need receiving
+     * @param {MediaType} mediaType of the stream
+     * @param {number} languageCode of the stream. If the languageId is 0, the named media group request will be canceled,
+     * and only receive the main audio stream.
+     * @returns {void}
+     */
+    setReceiveNamedMediaGroup(mediaType: MediaType, languageId: number): Promise<void>;
     /**
      * Creates the audio slots
      */
     private createAudioMedia;
+    /**
+     * Creates the audio slots for named media
+     */
+    private createInterpretationAudioMedia;
     /**
      * Creates receive slots required for receiving screen share audio and video
      */

package/dist/types/multistream/sendSlotManager.d.ts

@@ -1,4 +1,5 @@
 import { SendSlot, MediaType, LocalStream, MultistreamRoapMediaConnection } from '@webex/internal-media-core';
+import { NamedMediaGroup } from '@webex/json-multistream';
 export default class SendSlotManager {
     private readonly slots;
     private readonly LoggerProxy;
@@ -17,6 +18,14 @@ export default class SendSlotManager {
      * @returns {SendSlot}
      */
     getSlot(mediaType: MediaType): SendSlot;
+    /**
+     * Allow users to specify 'namedMediaGroups' to indicate which named media group its audio should be sent to.
+     * @param {MediaType} mediaType MediaType of the sendSlot to which the audio stream needs to be send to the media group
+     * @param {[]}namedMediaGroups - Allow users to specify 'namedMediaGroups'.If the value of 'namedMediaGroups' is zero,
+     * named media group will be canceled and the audio stream will be sent to the floor.
+     * @returns {void}
+     */
+    setNamedMediaGroups(mediaType: MediaType, namedMediaGroups: NamedMediaGroup[]): void;
     /**
      * This method publishes the given stream to the sendSlot for the given mediaType
      * @param {MediaType} mediaType MediaType of the sendSlot to which a stream needs to be published (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

package/dist/types/reachability/clusterReachability.d.ts

@@ -0,0 +1,109 @@
+import { ClusterNode } from './request';
+export type TransportResult = {
+    result: 'reachable' | 'unreachable' | 'untested';
+    latencyInMilliseconds?: number;
+    clientMediaIPs?: string[];
+};
+export type ClusterReachabilityResult = {
+    udp: TransportResult;
+    tcp: TransportResult;
+    xtls: TransportResult;
+};
+/**
+ * A class that handles reachability checks for a single cluster.
+ */
+export declare class ClusterReachability {
+    private numUdpUrls;
+    private numTcpUrls;
+    private result;
+    private pc?;
+    private defer;
+    private startTimestamp;
+    readonly isVideoMesh: boolean;
+    readonly name: any;
+    /**
+     * Constructor for ClusterReachability
+     * @param {string} name cluster name
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     */
+    constructor(name: string, clusterInfo: ClusterNode);
+    /**
+     * Gets total elapsed time, can be called only after start() is called
+     * @returns {Number} Milliseconds
+     */
+    private getElapsedTime;
+    /**
+     * Generate peerConnection config settings
+     * @param {ClusterNode} cluster
+     * @returns {RTCConfiguration} peerConnectionConfig
+     */
+    private buildPeerConnectionConfig;
+    /**
+     * Creates an RTCPeerConnection
+     * @param {ClusterNode} clusterInfo information about the media cluster
+     * @returns {RTCPeerConnection} peerConnection
+     */
+    private createPeerConnection;
+    /**
+     * @returns {ClusterReachabilityResult} reachability result for this cluster
+     */
+    getResult(): ClusterReachabilityResult;
+    /**
+     * Closes the peerConnection
+     *
+     * @returns {void}
+     */
+    private closePeerConnection;
+    /**
+     * Resolves the defer, indicating that reachability checks for this cluster are completed
+     *
+     * @returns {void}
+     */
+    private finishReachabilityCheck;
+    /**
+     * Adds public IP (client media IPs)
+     * @param {string} protocol
+     * @param {string} publicIP
+     * @returns {void}
+     */
+    private addPublicIP;
+    /**
+     * Registers a listener for the iceGatheringStateChange event
+     *
+     * @returns {void}
+     */
+    private registerIceGatheringStateChangeListener;
+    /**
+     * Checks if we have the results for all the protocols (UDP and TCP)
+     *
+     * @returns {boolean} true if we have all results, false otherwise
+     */
+    private haveWeGotAllResults;
+    /**
+     * Stores the latency in the result for the given protocol and marks it as reachable
+     *
+     * @param {string} protocol
+     * @param {number} latency
+     * @returns {void}
+     */
+    private storeLatencyResult;
+    /**
+     * Registers a listener for the icecandidate event
+     *
+     * @returns {void}
+     */
+    private registerIceCandidateListener;
+    /**
+     * Starts the process of doing UDP and TCP reachability checks on the media cluster.
+     * XTLS reachability checking is not supported.
+     *
+     * @returns {Promise}
+     */
+    start(): Promise<ClusterReachabilityResult>;
+    /**
+     * Starts the process of gathering ICE candidates
+     *
+     * @returns {Promise} promise that's resolved once reachability checks for this cluster are completed or timeout is reached
+     */
+    private gatherIceCandidates;
+}

package/dist/types/reachability/index.d.ts

@@ -1,11 +1,37 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
-export type ICECandidateResult = {
-    clusterId: string;
-    elapsed?: string | null;
-    publicIPs?: string[];
+import ReachabilityRequest from './request';
+import { ClusterReachability, ClusterReachabilityResult } from './clusterReachability';
+export type ReachabilityMetrics = {
+    reachability_public_udp_success: number;
+    reachability_public_udp_failed: number;
+    reachability_public_tcp_success: number;
+    reachability_public_tcp_failed: number;
+    reachability_vmn_udp_success: number;
+    reachability_vmn_udp_failed: number;
+    reachability_vmn_tcp_success: number;
+    reachability_vmn_tcp_failed: number;
 };
+/**
+ * This is the type that matches what backend expects us to send to them. It is a bit weird, because
+ * it uses strings instead of booleans and numbers, but that's what they require.
+ */
+export type TransportResultForBackend = {
+    reachable?: 'true' | 'false';
+    latencyInMilliseconds?: string;
+    clientMediaIPs?: string[];
+    untested?: 'true';
+};
+export type ReachabilityResultForBackend = {
+    udp: TransportResultForBackend;
+    tcp: TransportResultForBackend;
+    xtls: TransportResultForBackend;
+};
+export type ReachabilityResultsForBackend = Record<string, ReachabilityResultForBackend>;
+export type ReachabilityResults = Record<string, ClusterReachabilityResult & {
+    isVideoMesh?: boolean;
+}>;
 /**
  * @class Reachability
  * @export
@@ -13,8 +39,10 @@ export type ICECandidateResult = {
 export default class Reachability {
     namespace: string;
     webex: object;
-    reachabilityRequest: any;
-    clusterLatencyResults: any;
+    reachabilityRequest: ReachabilityRequest;
+    clusterReachability: {
+        [key: string]: ClusterReachability;
+    };
     /**
      * Creates an instance of Reachability.
      * @param {object} webex
@@ -22,87 +50,45 @@ export default class Reachability {
      */
     constructor(webex: object);
     /**
-     * fetches reachability data
-     * @returns {Object} reachability data
+     * Gets a list of media clusters from the backend and performs reachability checks on all the clusters
+     * @returns {Promise<ReachabilityResults>} reachability results
      * @public
-     * @async
      * @memberof Reachability
      */
-    gatherReachability(): Promise<unknown>;
+    gatherReachability(): Promise<ReachabilityResults>;
     /**
-     * fetches reachability data and checks for cluster reachability
-     * @returns {boolean}
-     * @public
-     * @memberof Reachability
+     * Returns statistics about last reachability results. The returned value is an object
+     * with a flat list of properties so that it can be easily sent with metrics
+     *
+     * @returns {Promise} Promise with metrics values, it never rejects/throws.
      */
-    isAnyClusterReachable(): Promise<boolean>;
+    getReachabilityMetrics(): Promise<ReachabilityMetrics>;
     /**
-     * Generate peerConnection config settings
-     * @param {object} cluster
-     * @returns {object} peerConnectionConfig
-     * @private
-     * @memberof Reachability
+     * Maps our internal transport result to the format that backend expects
+     * @param {TransportResult} transportResult
+     * @returns {TransportResultForBackend}
      */
-    private buildPeerConnectionConfig;
+    private mapTransportResultToBackendDataFormat;
     /**
-     * Creates an RTCPeerConnection
-     * @param {object} cluster
-     * @returns {RTCPeerConnection} peerConnection
-     * @private
-     * @memberof Reachability
+     * Reachability results as an object in the format that backend expects
+     *
+     * @returns {any} reachability results that need to be sent to the backend
      */
-    private createPeerConnection;
+    getReachabilityResults(): Promise<ReachabilityResultsForBackend | undefined>;
     /**
-     * Gets total elapsed time
-     * @param {RTCPeerConnection} peerConnection
-     * @returns {Number} Milliseconds
-     * @private
-     * @memberof Reachability
-     */
-    private getElapsedTime;
-    /**
-     * creates offer and generates localSDP
-     * @param {object} clusterList cluster List
-     * @returns {Promise} Reachability latency results
-     * @private
+     * fetches reachability data and checks for cluster reachability
+     * @returns {boolean}
+     * @public
      * @memberof Reachability
      */
-    private getLocalSDPForClusters;
+    isAnyPublicClusterReachable(): Promise<boolean>;
     /**
      * Get list of all unreachable clusters
      * @returns {array} Unreachable clusters
      * @private
      * @memberof Reachability
      */
-    private getUnreachablClusters;
-    /**
-     * Attach an event handler for the icegatheringstatechange
-     * event and measure latency.
-     * @param {RTCPeerConnection} peerConnection
-     * @returns {undefined}
-     * @private
-     * @memberof Reachability
-     */
-    private handleIceGatheringStateChange;
-    /**
-     * Attach an event handler for the icecandidate
-     * event and measure latency.
-     * @param {RTCPeerConnection} peerConnection
-     * @returns {undefined}
-     * @private
-     * @memberof Reachability
-     */
-    private handleOnIceCandidate;
-    /**
-     * An event handler on an RTCPeerConnection when the state of the ICE
-     * candidate gathering process changes. Used to measure connection
-     * speed.
-     * @private
-     * @param {RTCPeerConnection} peerConnection
-     * @param {number} timeout
-     * @returns {Promise}
-     */
-    private iceGatheringState;
+    private getUnreachableClusters;
     /**
      * Make a log of unreachable clusters.
      * @returns {undefined}
@@ -111,42 +97,9 @@ export default class Reachability {
      */
     private logUnreachableClusters;
     /**
-     * Calculates time to establish connection
-     * @param {Array<ICECandidateResult>} iceResults iceResults
-     * @returns {object} reachabilityMap
-     * @protected
-     * @memberof Reachability
-     */
-    protected parseIceResultsToReachabilityResults(iceResults: Array<ICECandidateResult>): {};
-    /**
-     * fetches reachability data
-     * @param {object} clusterList
-     * @returns {Promise<localSDPData>} reachability check results
-     * @private
-     * @memberof Reachability
-     */
-    private performReachabilityCheck;
-    /**
-     * Adds public IP (client media IPs)
-     * @param {RTCPeerConnection} peerConnection
-     * @param {string} publicIP
-     * @returns {void}
-     */
-    protected addPublicIP(peerConnection: RTCPeerConnection, publicIP?: string | null): void;
-    /**
-     * Records latency and closes the peerConnection
-     * @param {RTCPeerConnection} peerConnection
-     * @param {number} elapsed Latency in milliseconds
-     * @returns {undefined}
-     * @private
-     * @memberof Reachability
-     */
-    private setLatencyAndClose;
-    /**
-     * utility function
-     * @returns {undefined}
-     * @private
-     * @memberof Reachability
+     * Performs reachability checks for all clusters
+     * @param {ClusterList} clusterList
+     * @returns {Promise<ReachabilityResults>} reachability check results
      */
-    private setup;
+    private performReachabilityChecks;
 }

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

@@ -0,0 +1,8 @@
+/**
+ * Converts a stun url to a turn url
+ *
+ * @param {string} stunUrl url of a stun server
+ * @param {'tcp'|'udp'} protocol what protocol to use for the turn server
+ * @returns {string} url of a turn server
+ */
+export declare function convertStunUrlToTurn(stunUrl: string, protocol: 'udp' | 'tcp'): string;

package/dist/types/reconnection-manager/index.d.ts

@@ -1,6 +1,7 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
+import { RECONNECTION_STATE } from '../constants';
 import Meeting from '../meeting';
 /**
  * @export
@@ -73,6 +74,15 @@ export default class ReconnectionManager {
      * @returns {Boolean} true if reconnection operation is in progress
      */
     isReconnectInProgress(): boolean;
+    /**
+     * Sets the reconnection status
+     *
+     * @public
+     * @param {RECONNECTION_STATE} status
+     * @memberof ReconnectionManager
+     * @returns {undefined}
+     */
+    setStatus(status: RECONNECTION_STATE): void;
     /**
      * @returns {Boolean}
      * @throws {ReconnectionError}

package/dist/types/roap/index.d.ts

@@ -71,7 +71,8 @@ export default class Roap extends StatelessWebexPlugin {
      * @param {Meeting} meeting
      * @param {Boolean} isReconnecting should be set to true if this is a new
      *                                 media connection just after a reconnection
+     * @param {Boolean} [isForced]
      * @returns {Promise}
      */
-    doTurnDiscovery(meeting: Meeting, isReconnecting: boolean): any;
+    doTurnDiscovery(meeting: Meeting, isReconnecting: boolean, isForced?: boolean): any;
 }