@webex/plugin-meetings 3.0.0-beta.26 → 3.0.0-beta.261

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

@@ -7,6 +7,7 @@ declare const BEHAVIORAL_METRICS: {
     JOIN_FAILURE: string;
     ADD_MEDIA_SUCCESS: string;
     ADD_MEDIA_FAILURE: string;
+    ROAP_MERCURY_EVENT_RECEIVED: string;
     CONNECTION_SUCCESS: string;
     CONNECTION_FAILURE: string;
     MEETING_LEAVE_FAILURE: string;
@@ -15,6 +16,8 @@ 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;
@@ -36,11 +39,8 @@ declare const BEHAVIORAL_METRICS: {
     PEERCONNECTION_FAILURE: string;
     INVALID_ICE_CANDIDATE: string;
     UPLOAD_LOGS_FAILURE: string;
+    UPLOAD_LOGS_SUCCESS: string;
     RECEIVE_TRANSCRIPTION_FAILURE: string;
-    ENABLE_BNR_SUCCESS: string;
-    ENABLE_BNR_FAILURE: string;
-    DISABLE_BNR_SUCCESS: string;
-    DISABLE_BNR_FAILURE: string;
     FETCH_MEETING_INFO_V1_SUCCESS: string;
     FETCH_MEETING_INFO_V1_FAILURE: string;
     ADHOC_MEETING_SUCCESS: string;
@@ -53,5 +53,10 @@ declare const BEHAVIORAL_METRICS: {
     MOVE_FROM_SUCCESS: string;
     MOVE_FROM_FAILURE: string;
     TURN_DISCOVERY_FAILURE: string;
+    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;
 };
 export { BEHAVIORAL_METRICS as default };

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

@@ -1,3 +1,6 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
 /**
  * @description Metrics handles all the call metrics events
  * @export
@@ -5,9 +8,6 @@
  */
 declare class Metrics {
     static instance: Metrics;
-    _events: any;
-    keys: any;
-    meetingCollection: any;
     webex: any;
     /**
      * Create Metrics Object
@@ -19,126 +19,11 @@ declare class Metrics {
     /**
      * Initializes the Metrics singleton with a meeting Collection.
      *
-     * @param {Object} meetingCollection meetings object
      * @param {Object} webex  webex SDK object
      *
      * @returns {void}
      */
-    initialSetup(meetingCollection: object, webex: object): void;
-    /**
-     * poste Meeting event metrics
-     * @param {object} options {meetingId/meeting} as a json object
-     * @param {Meeting} options.meeting Meeting object
-     * @param {String} options.meetingId
-     * @param {object} options.data
-     * @param {object} options.event
-     * @returns {object} null
-     */
-    postEvent(options: {
-        meeting?: any;
-        meetingId?: string;
-        data?: object;
-        event?: any;
-    } | any): void;
-    /**
-     *  Docs for Call analyzer metrics
-     *   https://sqbu-github.cisco.com/WebExSquared/call-analyzer/wiki
-     *   https://sqbu-github.cisco.com/WebExSquared/event-dictionary/blob/master/diagnostic-events.raml
-     */
-    initPayload(eventType: any, identifiers: any, options: any): any;
-    /**
-     * returns metrics friendly OS versions
-     * @param {String} osName Os name
-     * @returns {String}
-     * @private
-     * @memberof Metrics
-     */
-    private getOsName;
-    /**
-     * get the payload specific for a media quality event through call analyzer
-     * @param {String} eventType the event name
-     * @param {Object} identifiers contains the identifiers needed for CA
-     * @param {String} identifiers.correlationId
-     * @param {String} identifiers.locusUrl
-     * @param {String} identifiers.locusId
-     * @param {Object} options
-     * @param {Object} options.intervalData
-     * @param {String} options.clientType
-     * @returns {Object}
-     * @public
-     * @memberof Metrics
-     */
-    initMediaPayload(eventType: string, identifiers: {
-        correlationId: string;
-        locusUrl: string;
-        locusId: string;
-    }, options?: {
-        intervalData: object;
-        clientType: string;
-    } | any): {
-        eventId: any;
-        version: number;
-        origin: {
-            audioSetupDelay: any;
-            videoSetupDelay: any;
-            name: string;
-            networkType: any;
-            userAgent: string;
-            clientInfo: {
-                clientType: any;
-                clientVersion: string;
-                localNetworkPrefix: string;
-                os: any;
-                osVersion: any;
-                subClientType: any;
-                browser: any;
-                browserVersion: any;
-            };
-        };
-        originTime: {
-            triggered: string;
-        };
-        senderCountryCode: any;
-        event: {
-            name: string;
-            canProceed: boolean;
-            identifiers: {
-                correlationId: string;
-                locusUrl: string;
-                locusId: string;
-            };
-            intervals: any[];
-            joinTimes: any;
-            eventData: {
-                webClientDomain: any;
-            };
-            sourceMetadata: {
-                applicationSoftwareType: string;
-                applicationSoftwareVersion: any;
-                mediaEngineSoftwareType: any;
-                mediaEngineSoftwareVersion: any;
-                startTime: string;
-            };
-        };
-    };
-    /**
-     * This function Parses a Locus error and returns a diagnostic event payload.
-     * It should keep updating from:
-     * https://sqbu-github.cisco.com/WebExSquared/spark-client-framework/blob/master/spark-client-framework/Adapters/TelephonyAdapter/TelephonyAdapter.cpp#L920
-     *
-     * @param {Object} err the error Object from Locus response
-     * @param {boolean} showToUser true if a toast is shown to user
-     * @returns {{showToUser: boolean, category: string, errorDescription: string,
-     *  errorCode: number, errorData: *, fatal: boolean, name: string}}
-     */
-    parseLocusError(err: any, showToUser: boolean): any;
-    generateErrorPayload(errorCode: any, shownToUser: any, name: any, err: any): any;
-    /**
-     * Returns a formated string of the user agent.
-     *
-     * @returns {string} formatted user agent information
-     */
-    userAgentToString(): string;
+    initialSetup(webex: object): void;
     /**
      * Uploads given metric to the Metrics service as an Behavioral metric.
      * Metadata about the environment such as browser, OS, SDK and their versions

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

@@ -1,4 +1,4 @@
-import { MediaRequest as WcmeMediaRequest } from '@webex/internal-media-core';
+import { StreamRequest } from '@webex/internal-media-core';
 import { ReceiveSlot } from './receiveSlot';
 export interface ActiveSpeakerPolicyInfo {
     policy: 'active-speaker';
@@ -25,26 +25,94 @@ export interface MediaRequest {
     policyInfo: PolicyInfo;
     receiveSlots: Array<ReceiveSlot>;
     codecInfo?: CodecInfo;
+    preferredMaxFs?: number;
+    handleMaxFs?: ({ maxFs }: {
+        maxFs: number;
+    }) => void;
 }
 export type MediaRequestId = string;
 type DegradationPreferences = {
     maxMacroblocksLimit: number;
 };
-type SendMediaRequestsCallback = (mediaRequests: WcmeMediaRequest[]) => void;
+type SendMediaRequestsCallback = (streamRequests: StreamRequest[]) => void;
+type Kind = 'audio' | 'video';
+type Options = {
+    degradationPreferences: DegradationPreferences;
+    kind: Kind;
+    trimRequestsToNumOfSources: boolean;
+};
 export declare class MediaRequestManager {
     private sendMediaRequestsCallback;
+    private kind;
     private counter;
     private clientRequests;
-    private slotsActiveInLastMediaRequest;
     private degradationPreferences;
-    constructor(degradationPreferences: DegradationPreferences, sendMediaRequestsCallback: SendMediaRequestsCallback);
-    private resetInactiveReceiveSlots;
+    private sourceUpdateListener;
+    private debouncedSourceUpdateListener;
+    private previousStreamRequests;
+    private trimRequestsToNumOfSources;
+    private numTotalSources;
+    private numLiveSources;
+    constructor(sendMediaRequestsCallback: SendMediaRequestsCallback, options: Options);
     setDegradationPreferences(degradationPreferences: DegradationPreferences): void;
     private getDegradedClientRequests;
+    /**
+     * Returns true if two stream requests are the same, false otherwise.
+     *
+     * @param {StreamRequest} streamRequestA - Stream request A for comparison.
+     * @param {StreamRequest} streamRequestB - Stream request B for comparison.
+     * @returns {boolean} - Whether they are equal.
+     */
+    isEqual(streamRequestA: StreamRequest, streamRequestB: StreamRequest): boolean;
+    /**
+     * Compares new stream requests to previous ones and determines
+     * if they are the same.
+     *
+     * @param {StreamRequest[]} newRequests - Array with new requests.
+     * @returns {boolean} - True if they are equal, false otherwise.
+     */
+    private checkIsNewRequestsEqualToPrev;
+    /**
+     * Returns the maxPayloadBitsPerSecond per Stream
+     *
+     * If MediaRequestManager kind is "audio", a constant bitrate will be returned.
+     * If MediaRequestManager kind is "video", the bitrate will be calculated based
+     * on maxFs (default h264 maxFs as fallback if maxFs is not defined)
+     *
+     * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+     * @returns {number} maxPayloadBitsPerSecond
+     */
+    private getMaxPayloadBitsPerSecond;
+    /**
+     * Returns the max Macro Blocks per second (maxMbps) per H264 Stream
+     *
+     * The maxMbps will be calculated based on maxFs and maxFps
+     * (default h264 maxFps as fallback if maxFps is not defined)
+     *
+     * @param {MediaRequest} mediaRequest  - mediaRequest to take data from
+     * @returns {number} maxMbps
+     */
+    private getH264MaxMbps;
+    /**
+     * Clears the previous stream requests.
+     *
+     * @returns {void}
+     */
+    clearPreviousRequests(): void;
+    /** Modifies the passed in clientRequests and makes sure that in total they don't ask
+     *  for more streams than there are available.
+     *
+     * @param {Object} clientRequests
+     * @returns {void}
+     */
+    private trimRequests;
+    private getPreferLiveVideo;
+    private cloneClientRequests;
     private sendRequests;
     addRequest(mediaRequest: MediaRequest, commit?: boolean): MediaRequestId;
     cancelRequest(requestId: MediaRequestId, commit?: boolean): void;
     commit(): void;
     reset(): void;
+    setNumCurrentSources(numTotalSources: number, numLiveSources: number): void;
 }
 export {};

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

@@ -1,9 +1,10 @@
-import { MediaType, ReceiveSlot as WcmeReceiveSlot, SourceState } from '@webex/internal-media-core';
+import { MediaType, ReceiveSlot as WcmeReceiveSlot, StreamState } from '@webex/internal-media-core';
 import EventsScope from '../common/events/events-scope';
 export declare const ReceiveSlotEvents: {
     SourceUpdate: string;
+    MaxFsUpdate: string;
 };
-export type { SourceState } from '@webex/internal-media-core';
+export type { StreamState } from '@webex/internal-media-core';
 export type CSI = number;
 export type MemberId = string;
 export type ReceiveSlotId = string;
@@ -35,14 +36,25 @@ export declare class ReceiveSlot extends EventsScope {
      * Getter for csi
      */
     get csi(): number;
+    /**
+     * Set the max frame size for this slot
+     * @param newFs frame size
+     */
+    setMaxFs(newFs: any): void;
     /**
      * Getter for sourceState
      */
-    get sourceState(): SourceState;
+    get sourceState(): StreamState;
     /**
      * registers event handlers with the underlying ReceiveSlot
      */
-    setupEventListeners(): void;
+    private setupEventListeners;
+    /** Tries to find the member id for this receive slot if it hasn't got one */
+    findMemberId(): void;
+    /**
+     * @returns {string} a log message used to identify the receive slot
+     */
+    get logString(): string;
     /**
      * The MediaStream object associated with this slot.
      *
@@ -53,12 +65,4 @@ export declare class ReceiveSlot extends EventsScope {
      * The underlying WCME receive slot
      */
     get wcmeReceiveSlot(): WcmeReceiveSlot;
-    /**
-     * Resets the source state to the default 'no source' value.
-     * This function should be called on receive slots that are
-     * no longer part of a media request. It's needed because WCME
-     * does not send any more events on such slots, so the sourceState
-     * value would not represent the truth anymore.
-     */
-    resetSourceState(): void;
 }

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

@@ -1,5 +1,7 @@
-import { MediaType } from '@webex/internal-media-core';
-import { ReceiveSlot } from './receiveSlot';
+import { MediaType, ReceiveSlot as WcmeReceiveSlot } from '@webex/internal-media-core';
+import { FindMemberIdCallback, ReceiveSlot } from './receiveSlot';
+export type CreateSlotCallback = (mediaType: MediaType) => Promise<WcmeReceiveSlot>;
+export type { CSI, FindMemberIdCallback } from './receiveSlot';
 /**
  * Manages all receive slots used by a meeting. WMCE receive slots cannot be ever deleted,
  * so this manager has a pool in order to re-use the slots that were released earlier.
@@ -7,12 +9,13 @@ import { ReceiveSlot } from './receiveSlot';
 export declare class ReceiveSlotManager {
     private allocatedSlots;
     private freeSlots;
-    private meeting;
+    private createSlotCallback;
+    private findMemberIdByCsiCallback;
     /**
      * Constructor
      * @param {Meeting} meeting
      */
-    constructor(meeting: any);
+    constructor(createSlotCallback: CreateSlotCallback, findMemberIdByCsiCallback: FindMemberIdCallback);
     /**
      * Creates a new receive slot or returns one from the existing pool of free slots
      *
@@ -38,4 +41,16 @@ export declare class ReceiveSlotManager {
         numAllocatedSlots: {};
         numFreeSlots: {};
     };
+    /**
+     * Tries to find the member id on all allocated receive slots
+     * This function should be called when new members are added to the meeting.
+     */
+    updateMemberIds(): void;
+    /**
+     * Find a receive slot by a ssrc.
+     *
+     * @param ssrc - The ssrc of the receive slot to find.
+     * @returns - The receive slot with this ssrc, undefined if not found.
+     */
+    findReceiveSlotBySsrc(ssrc: number): ReceiveSlot | undefined;
 }

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

@@ -1,7 +1,7 @@
-import { MediaType, SourceState } from '@webex/internal-media-core';
+import { MediaType, StreamState } from '@webex/internal-media-core';
 import EventsScope from '../common/events/events-scope';
 import { MediaRequestManager } from './mediaRequestManager';
-import { CSI, ReceiveSlot } from './receiveSlot';
+import { ReceiveSlot } from './receiveSlot';
 export declare const RemoteMediaEvents: {
     SourceUpdate: string;
     Stopped: string;
@@ -38,28 +38,12 @@ export declare class RemoteMedia extends EventsScope {
      */
     constructor(receiveSlot: ReceiveSlot, mediaRequestManager: MediaRequestManager, options?: Options);
     /**
-     * Invalidates the remote media by clearing the reference to a receive slot and
-     * cancelling the media request.
-     * After this call the remote media is unusable.
-     *
-     * @param {boolean} commit - whether to commit the cancellation of the media request
-     * @internal
-     */
-    stop(commit?: boolean): void;
-    /**
-     * Sends a new media request. This method can only be used for receiver-selected policy,
-     * because only in that policy we have a 1-1 relationship between RemoteMedia and MediaRequest
-     * and the request id is then stored in this RemoteMedia instance.
-     * For active-speaker policy, the same request is shared among many RemoteMedia instances,
-     * so it's managed through RemoteMediaGroup
-     *
-     * @internal
+     * Supply the width and height of the video element
+     * to restrict the requested resolution to this size
+     * @param width width of the video element
+     * @param height height of the video element
      */
-    sendMediaRequest(csi: CSI, commit: boolean): void;
-    /**
-     * @internal
-     */
-    cancelMediaRequest(commit: boolean): void;
+    setSizeHint(width: any, height: any): void;
     /**
      * registers event listeners on the receive slot and forwards all the events
      */
@@ -79,15 +63,10 @@ export declare class RemoteMedia extends EventsScope {
     /**
      * Getter for source state
      */
-    get sourceState(): SourceState;
+    get sourceState(): StreamState;
     /**
      * Getter for remote media stream
      */
     get stream(): MediaStream;
-    /**
-     * @internal
-     * @returns {ReceiveSlot}
-     */
-    getUnderlyingReceiveSlot(): ReceiveSlot;
 }
 export {};

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

@@ -35,15 +35,6 @@ export declare class RemoteMediaGroup {
     isPinned(remoteMedia: RemoteMedia): boolean;
     private sendActiveSpeakerMediaRequest;
     private cancelActiveSpeakerMediaRequest;
-    /**
-     * Invalidates the remote media group by clearing the references to the receive slots
-     * used by all remote media from that group and cancelling all media requests.
-     * After this call the remote media group is unusable.
-     *
-     * @param{boolean} commit whether to commit the cancellation of media requests
-     * @internal
-     */
-    stop(commit?: boolean): void;
     /**
      * Checks if a given RemoteMedia instance belongs to this group.
      *

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

@@ -139,6 +139,20 @@ export declare class RemoteMediaManager extends EventsScope {
      * @returns {LayoutId}
      */
     getLayoutId(): LayoutId | undefined;
+    /**
+     * sets the preferLiveVideo
+     */
+    setPreferLiveVideo(preferLiveVideo: boolean): void;
+    /**
+     * Sets CSIs for multiple RemoteMedia instances belonging to RemoteMediaGroup.
+     * For each entry in the remoteMediaCsis array:
+     * - if csi is specified, the RemoteMedia instance is pinned to that CSI
+     * - if csi is undefined, the RemoteMedia instance is unpinned
+     */
+    setActiveSpeakerCsis(remoteMediaCsis: {
+        remoteMedia: RemoteMedia;
+        csi?: number;
+    }[]): void;
     /**
      * Creates the audio slots
      */
@@ -161,9 +175,39 @@ export declare class RemoteMediaManager extends EventsScope {
      */
     private releaseUnusedVideoSlots;
     /**
-     * Allocates receive slots to all video panes in the current selected layout
+     * Allocates receive slots to all active speaker video panes
+     * in the current selected layout.
+     *
+     * Allocation tries to keep the same order of the slots between the previous
+     * layout and the new one. Sorting helps making sure that highest priority slots
+     * go in the same order in the new layout.
+     */
+    private allocateSlotsToActiveSpeakerPaneGroups;
+    /**
+     * Allocates receive slots to all receiver selected video panes
+     * in the current selected layout
+     */
+    private allocateSlotsToReceiverSelectedVideoPaneGroups;
+    /**
+     * Ensures that we have enough slots for the current layout.
+     */
+    private refillRequiredSlotsIfNeeded;
+    /**
+     * Move all active speaker slots to "unused"
+     */
+    private trimActiveSpeakerSlots;
+    /**
+     * Logs the state of the receive slots
      */
-    private allocateSlotsToVideoPaneGroups;
+    private logMainVideoReceiveSlots;
+    /** logs main audio slots */
+    private logMainAudioReceiveSlots;
+    /** logs slides video slots */
+    private logSlidesVideoReceiveSlots;
+    /** logs slides audio slots */
+    private logSlidesAudioReceiveSlots;
+    /** Logs all current receive slots */
+    logAllReceiveSlots(): void;
     /**
      * Makes sure we have the right number of receive slots created for the current layout
      * and allocates them to the right video panes / pane groups

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

@@ -0,0 +1,61 @@
+import { SendSlot, MediaType, LocalStream, MultistreamRoapMediaConnection } from '@webex/internal-media-core';
+export default class SendSlotManager {
+    private readonly slots;
+    private readonly LoggerProxy;
+    constructor(LoggerProxy: any);
+    /**
+     * This method is used to create a sendSlot for the given mediaType and returns the created sendSlot
+     * @param {MultistreamRoapMediaConnection} mediaConnection MultistreamRoapMediaConnection for which a sendSlot needs to be created
+     * @param {MediaType} mediaType MediaType for which a sendSlot needs to be created (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @param {boolean} active This is optional boolean to set the active state of the sendSlot. Default is true
+     * @returns {SendSlot} slot The created sendSlot
+     */
+    createSlot(mediaConnection: MultistreamRoapMediaConnection, mediaType: MediaType, active?: boolean): SendSlot;
+    /**
+     * This method is used to retrieve the sendSlot for the given mediaType
+     * @param {MediaType} mediaType of which the slot needs to be retrieved
+     * @returns {SendSlot}
+     */
+    getSlot(mediaType: MediaType): SendSlot;
+    /**
+     * 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)
+     * @param {LocalStream} stream LocalStream to be published
+     * @returns {Promise<void>}
+     */
+    publishStream(mediaType: MediaType, stream: LocalStream): Promise<void>;
+    /**
+     * This method unpublishes the stream from the sendSlot of the given mediaType
+     * @param {MediaType} mediaType MediaType of the sendSlot from which a stream needs to be unpublished (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @returns {Promise<void>}
+     */
+    unpublishStream(mediaType: MediaType): Promise<void>;
+    /**
+     * This method is used to set the active state of the sendSlot for the given mediaType
+     * @param {MediaType} mediaType The MediaType of the sendSlot for which the active state needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @param {boolean} active The boolean to set the active state of the sendSlot. Default is true
+     * @returns {void}
+     */
+    setActive(mediaType: MediaType, active?: boolean): void;
+    /**
+     * This method is used to set the codec parameters for the sendSlot of the given mediaType
+     * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be set (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @param {Object} codecParameters
+     * @returns {Promise<void>}
+     */
+    setCodecParameters(mediaType: MediaType, codecParameters: {
+        [key: string]: string | undefined;
+    }): Promise<void>;
+    /**
+     * This method is used to delete the codec parameters for the sendSlot of the given mediaType
+     * @param {MediaType} mediaType MediaType of the sendSlot for which the codec parameters needs to be deleted (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)
+     * @param {Array<String>} parameters Array of keys of the codec parameters to be deleted
+     * @returns {Promise<void>}
+     */
+    deleteCodecParameters(mediaType: MediaType, parameters: string[]): Promise<void>;
+    /**
+     * This method is used to reset the SendSlotsManager by deleting all the sendSlots
+     * @returns {undefined}
+     */
+    reset(): void;
+}

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

@@ -1,6 +1,29 @@
 /*!
  * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
  */
+export type TransportResult = {
+    reachable: 'true' | 'false';
+    latencyInMilliseconds?: string;
+    clientMediaIPs?: string[];
+    untested?: 'true';
+};
+type ReachabilityResult = {
+    udp: TransportResult;
+    tcp: TransportResult;
+    xtls: {
+        untested: 'true';
+    };
+};
+export type ReachabilityResults = Record<string, ReachabilityResult>;
+type InternalReachabilityResults = Record<string, ReachabilityResult & {
+    isVideoMesh?: boolean;
+}>;
+export type ICECandidateResult = {
+    clusterId: string;
+    isVideoMesh: boolean;
+    elapsed?: string | null;
+    publicIPs?: string[];
+};
 /**
  * @class Reachability
  * @export
@@ -23,14 +46,20 @@ export default class Reachability {
      * @async
      * @memberof Reachability
      */
-    gatherReachability(): Promise<unknown>;
+    gatherReachability(): Promise<InternalReachabilityResults>;
+    /**
+     * Reachability results as an object in the format that backend expects
+     *
+     * @returns {any} reachability results that need to be sent to the backend
+     */
+    getReachabilityResults(): Promise<ReachabilityResults | undefined>;
     /**
      * fetches reachability data and checks for cluster reachability
      * @returns {boolean}
      * @public
      * @memberof Reachability
      */
-    isAnyClusterReachable(): Promise<boolean>;
+    isAnyPublicClusterReachable(): Promise<boolean>;
     /**
      * Generate peerConnection config settings
      * @param {object} cluster
@@ -94,7 +123,7 @@ export default class Reachability {
      * speed.
      * @private
      * @param {RTCPeerConnection} peerConnection
-     * @param {number} timeout
+     * @param {boolean} isVideoMesh
      * @returns {Promise}
      */
     private iceGatheringState;
@@ -107,20 +136,27 @@ export default class Reachability {
     private logUnreachableClusters;
     /**
      * Calculates time to establish connection
-     * @param {array} iceResults iceResults
+     * @param {Array<ICECandidateResult>} iceResults iceResults
      * @returns {object} reachabilityMap
-     * @private
+     * @protected
      * @memberof Reachability
      */
-    private parseIceResultsToReachabilityResults;
+    protected parseIceResultsToInternalReachabilityResults(iceResults: Array<ICECandidateResult>): InternalReachabilityResults;
     /**
      * fetches reachability data
      * @param {object} clusterList
-     * @returns {Promise<localSDPData>} reachability check results
+     * @returns {Promise<InternalReachabilityResults>} 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
@@ -138,3 +174,4 @@ export default class Reachability {
      */
     private setup;
 }
+export {};