@webex/plugin-meetings 2.60.0-next.4 → 2.60.0-next.6

package/dist/roap/index.d.ts

@@ -0,0 +1,78 @@
+import { StatelessWebexPlugin } from '@webex/webex-core';
+import Meeting from '../meeting';
+/**
+ * Roap options
+ * @typedef {Object} RoapOptions
+ * @property {String} sdp
+ * @property {Meeting} meeting
+ * @property {Number} seq
+ * @property {Number} tieBreaker
+ *  @property {Boolean} reconnect
+ */
+/**
+ * @typedef {Object} SeqOptions
+ * @property {String} correlationId
+ * @property {String} mediaId
+ * @property {Number} seq
+ */
+/**
+ * @class Roap
+ * @export
+ * @private
+ */
+export default class Roap extends StatelessWebexPlugin {
+    attrs: any;
+    lastRoapOffer: any;
+    options: any;
+    roapHandler: any;
+    roapRequest: any;
+    turnDiscovery: any;
+    /**
+     *
+     * @param {Object} attrs
+     * @param {Object} options
+     */
+    constructor(attrs: any, options: any);
+    /**
+     *
+     * @param {SeqOptions} options
+     * @returns {null}
+     * @memberof Roap
+     */
+    sendRoapOK(options: any): Promise<any>;
+    /**
+     * Sends a ROAP answer...
+     * @param {SeqOptions} options
+     * @param {Boolean} options.audioMuted
+     * @param {Boolean} options.videoMuted
+     * @returns {Promise}
+     * @memberof Roap
+     */
+    sendRoapAnswer(options: any): any;
+    /**
+     * Sends a ROAP error...
+     * @param {Object} options
+     * @returns {Promise}
+     * @memberof Roap
+     */
+    sendRoapError(options: any): any;
+    /**
+     * sends a roap media request
+     * @param {RoapOptions} options
+     * @returns {Promise}
+     * @memberof Roap
+     */
+    sendRoapMediaRequest(options: any): any;
+    /**
+     * Performs a TURN server discovery procedure, which involves exchanging
+     * some roap messages with the server. This exchange has to be done before
+     * any other roap messages are sent
+     *
+     * @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, isForced?: boolean): any;
+}

package/dist/roap/request.d.ts

@@ -0,0 +1,41 @@
+import { StatelessWebexPlugin } from '@webex/webex-core';
+import { IP_VERSION } from '../constants';
+import { LocusMediaRequest } from '../meeting/locusMediaRequest';
+/**
+ * @class RoapRequest
+ */
+export default class RoapRequest extends StatelessWebexPlugin {
+    /**
+     * Returns reachability data.
+     * @param {Object} localSdp
+     * @returns {Object}
+     */
+    attachReachabilityData(localSdp: any): Promise<{
+        localSdp: any;
+        joinCookie: any;
+    }>;
+    /**
+     * Sends a ROAP message
+     * @param {Object} options
+     * @param {Object} options.roapMessage
+     * @param {String} options.locusSelfUrl
+     * @param {String} options.mediaId
+     * @param {String} options.correlationId
+     * @param {String} options.meetingId
+     * @param {IP_VERSION} options.ipVersion only required for offers
+     * @returns {Promise} returns the response/failure of the request
+     */
+    sendRoap(options: {
+        roapMessage: any;
+        locusSelfUrl: string;
+        mediaId: string;
+        meetingId: string;
+        ipVersion?: IP_VERSION;
+        locusMediaRequest?: LocusMediaRequest;
+        audioMuted?: boolean;
+        videoMuted?: boolean;
+    }): Promise<{
+        mediaConnections: any;
+        locus: any;
+    }>;
+}

package/dist/roap/turnDiscovery.d.ts

@@ -0,0 +1,92 @@
+import RoapRequest from './request';
+import Meeting from '../meeting';
+/**
+ * Handles the process of finding out TURN server information from Linus.
+ * This is achieved by sending a TURN_DISCOVERY_REQUEST.
+ */
+export default class TurnDiscovery {
+    private roapRequest;
+    private defer?;
+    private turnInfo;
+    private responseTimer?;
+    /**
+     * Constructor
+     *
+     * @param {RoapRequest} roapRequest
+     */
+    constructor(roapRequest: RoapRequest);
+    /**
+     * waits for TURN_DISCOVERY_RESPONSE message to arrive
+     *
+     * @returns {Promise}
+     * @private
+     * @memberof Roap
+     */
+    private waitForTurnDiscoveryResponse;
+    /**
+     * handles TURN_DISCOVERY_RESPONSE roap message
+     *
+     * @param {Object} roapMessage
+     * @returns {void}
+     * @public
+     * @memberof Roap
+     */
+    handleTurnDiscoveryResponse(roapMessage: object): void;
+    /**
+     * sends the TURN_DISCOVERY_REQUEST roap request
+     *
+     * @param {Meeting} meeting
+     * @param {Boolean} isReconnecting
+     * @returns {Promise}
+     * @private
+     * @memberof Roap
+     */
+    sendRoapTurnDiscoveryRequest(meeting: Meeting, isReconnecting: boolean): Promise<void>;
+    /**
+     * Sends the OK message that server expects to receive
+     * after it sends us TURN_DISCOVERY_RESPONSE
+     *
+     * @param {Meeting} meeting
+     * @returns {Promise}
+     */
+    sendRoapOK(meeting: Meeting): Promise<{
+        mediaConnections: any;
+        locus: any;
+    }>;
+    /**
+     * Gets the reason why reachability is skipped.
+     *
+     * @param {Meeting} meeting
+     * @returns {Promise<string>} Promise with empty string if reachability is not skipped or a reason if it is skipped
+     */
+    private getSkipReason;
+    /**
+     * Checks if TURN discovery is skipped.
+     *
+     * @param {Meeting} meeting
+     * @returns {Boolean} true if TURN discovery is being skipped, false if it is being done
+     */
+    isSkipped(meeting: any): Promise<boolean>;
+    /**
+     * Retrieves TURN server information from the backend by doing
+     * a roap message exchange:
+     * client                             server
+     *  | -----TURN_DISCOVERY_REQUEST-----> |
+     *  | <----TURN_DISCOVERY_RESPONSE----- |
+     *  | --------------OK----------------> |
+     *
+     * This TURN discovery roap exchange is always done with seq=0.
+     * The RoapMediaConnection SDP exchange always starts with seq=1,
+     * so it works fine no matter if TURN discovery is done or not.
+     *
+     * @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, isForced?: boolean): Promise<{
+        turnServerInfo: any;
+        turnDiscoverySkippedReason: any;
+    }>;
+}

package/dist/rtcMetrics/constants.d.ts

@@ -0,0 +1,4 @@
+declare const RTC_METRICS: {
+    APP_ID: string;
+};
+export { RTC_METRICS as default };

package/dist/rtcMetrics/index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Rtc Metrics
+ */
+export default class RtcMetrics {
+    /**
+     * Array of MetricData items to be sent to the metrics service.
+     */
+    metricsQueue: any[];
+    intervalId: number;
+    webex: any;
+    meetingId: string;
+    correlationId: string;
+    /**
+     * Initialize the interval.
+     *
+     * @param {object} webex - The main `webex` object.
+     * @param {string} meetingId - The meeting id.
+     * @param {string} correlationId - The correlation id.
+     */
+    constructor(webex: any, meetingId: any, correlationId: any);
+    /**
+     * Check to see if the metrics queue has any items.
+     *
+     * @returns {void}
+     */
+    sendMetricsInQueue(): void;
+    /**
+     * Add metrics items to the metrics queue.
+     *
+     * @param {object} data - An object with a payload array of metrics items.
+     *
+     * @returns {void}
+     */
+    addMetrics(data: any): void;
+    /**
+     * Clear the metrics interval.
+     *
+     * @returns {void}
+     */
+    closeMetrics(): void;
+    /**
+     * Anonymize IP addresses.
+     *
+     * @param {array} stats - An RTCStatsReport organized into an array of strings.
+     * @returns {string}
+     */
+    anonymizeIp(stats: string): string;
+    /**
+     * Send metrics to the metrics service.
+     *
+     * @returns {void}
+     */
+    private sendMetrics;
+}

package/dist/statsAnalyzer/global.d.ts

@@ -0,0 +1,36 @@
+declare const STATS_DEFAULT: {
+    encryption: string;
+    bandwidth: {
+        systemBandwidth: number;
+        sentPerSecond: number;
+        encodedPerSecond: number;
+        helper: {
+            audioBytesSent: number;
+            videoBytestSent: number;
+        };
+        speed: number;
+    };
+    results: {};
+    connectionType: {
+        systemNetworkType: string;
+        systemIpAddress: string;
+        local: {
+            candidateType: any[];
+            transport: any[];
+            ipAddress: any[];
+            networkType: any[];
+        };
+        remote: {
+            candidateType: any[];
+            transport: any[];
+            ipAddress: any[];
+            networkType: any[];
+        };
+    };
+    resolutions: {};
+    internal: {
+        remote: {};
+        candidates: {};
+    };
+};
+export default STATS_DEFAULT;

package/dist/statsAnalyzer/index.d.ts

@@ -0,0 +1,201 @@
+/// <reference types="node" />
+import EventsScope from '../common/events/events-scope';
+import { ReceiveSlot } from '../multistream/receiveSlot';
+export declare const EVENTS: {
+    MEDIA_QUALITY: string;
+    LOCAL_MEDIA_STARTED: string;
+    LOCAL_MEDIA_STOPPED: string;
+    REMOTE_MEDIA_STARTED: string;
+    REMOTE_MEDIA_STOPPED: string;
+};
+type ReceiveSlotCallback = (csi: number) => ReceiveSlot | undefined;
+/**
+ * Stats Analyzer class that will emit events based on detected quality
+ *
+ * @export
+ * @class StatsAnalyzer
+ * @extends {EventsScope}
+ */
+export declare class StatsAnalyzer extends EventsScope {
+    config: any;
+    correlationId: any;
+    lastEmittedStartStopEvent: any;
+    lastMqaDataSent: any;
+    lastStatsResults: any;
+    meetingMediaStatus: any;
+    mqaInterval: NodeJS.Timeout;
+    mqaSentCount: any;
+    networkQualityMonitor: any;
+    mediaConnection: any;
+    statsInterval: NodeJS.Timeout;
+    statsResults: any;
+    statsStarted: any;
+    successfulCandidatePair: any;
+    receiveSlotCallback: ReceiveSlotCallback;
+    /**
+     * Creates a new instance of StatsAnalyzer
+     * @constructor
+     * @public
+     * @param {Object} config SDK Configuration Object
+     * @param {Function} receiveSlotCallback Callback used to access receive slots.
+     * @param {Object} networkQualityMonitor class for assessing network characteristics (jitter, packetLoss, latency)
+     * @param {Object} statsResults Default properties for stats
+     */
+    constructor(config: any, receiveSlotCallback?: ReceiveSlotCallback, networkQualityMonitor?: object, statsResults?: object);
+    /**
+     * Resets cumulative stats arrays.
+     *
+     * @public
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    resetStatsResults(): void;
+    /**
+     * sets mediaStatus status for analyzing metrics
+     *
+     * @public
+     * @param {Object} status for the audio and video
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    updateMediaStatus(status: object): void;
+    /**
+     * captures MQA data from media connection
+     *
+     * @public
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    sendMqaData(): void;
+    /**
+     * updated the media connection when changed
+     *
+     * @private
+     * @memberof StatsAnalyzer
+     * @param {RoapMediaConnection} mediaConnection
+     * @returns {void}
+     */
+    updateMediaConnection(mediaConnection: any): void;
+    /**
+     * Starts the stats analyzer on interval
+     *
+     * @public
+     * @memberof StatsAnalyzer
+     * @param {RoapMediaConnection} mediaConnection
+     * @returns {Promise}
+     */
+    startAnalyzer(mediaConnection: any): any;
+    /**
+     * Cleans up the analyzer when done
+     *
+     * @public
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    stopAnalyzer(): any;
+    /**
+     * Parse a single result of get stats
+     *
+     * @private
+     * @param {*} getStatsResult
+     * @param {String} type
+     * @param {boolean} isSender
+     * @returns {void}
+     * @memberof StatsAnalyzer
+     */
+    private parseGetStatsResult;
+    /**
+     * Filters the get stats results for types
+     * @private
+     * @param {Array} statsItem
+     * @param {String} type
+     * @param {boolean} isSender
+     * @returns {void}
+     */
+    filterAndParseGetStatsResults(statsItem: any, type: string, isSender: boolean): void;
+    /**
+     * parse the audio
+     * @param {String} result
+     * @param {boolean} type
+     * @returns {void}
+     */
+    parseAudioSource(result: any, type: any): void;
+    /**
+     * emits started/stopped events for local/remote media by checking
+     * if given values are increasing or not. The previousValue, currentValue
+     * params can be any numerical value like number of receive packets or
+     * decoded frames, etc.
+     *
+     * @private
+     * @param {string} mediaType
+     * @param {number} previousValue - value to compare
+     * @param {number} currentValue - value to compare (must be same type of value as previousValue)
+     * @param {boolean} isLocal - true if stats are for local media being sent out, false for remote media being received
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    emitStartStopEvents: (mediaType: string, previousValue: number, currentValue: number, isLocal: boolean) => void;
+    /**
+     * compares current and previous stats to check if packets are not sent
+     *
+     * @private
+     * @memberof StatsAnalyzer
+     * @returns {void}
+     */
+    private compareLastStatsResult;
+    /**
+     * Does a `getStats` on all the transceivers and parses the results
+     *
+     * @private
+     * @memberof StatsAnalyzer
+     * @returns {Promise}
+     */
+    private getStatsAndParse;
+    /**
+     * Processes OutboundRTP stats result and stores
+     * @private
+     * @param {*} result
+     * @param {*} mediaType
+     * @returns {void}
+     */
+    private processOutboundRTPResult;
+    /**
+     * Processes InboundRTP stats result and stores
+     * @private
+     * @param {*} result
+     * @param {*} mediaType
+     * @returns {void}
+     */
+    private processInboundRTPResult;
+    /**
+     * Processes remote and local candidate result and stores
+     * @private
+     * @param {*} result
+     * @param {*} type
+     * @param {boolean} isSender
+     * @param {boolean} isRemote
+     *
+     * @returns {void}
+     */
+    parseCandidate: (result: any, type: any, isSender: boolean, isRemote: boolean) => void;
+    /**
+     * Process Track results
+     *
+     * @private
+     * @param {*} result
+     * @param {*} mediaType
+     * @returns {void}
+     * @memberof StatsAnalyzer
+     */
+    private processTrackResult;
+    /**
+     *
+     * @private
+     * @param {*} result
+     * @param {*} type
+     * @returns {void}
+     * @memberof StatsAnalyzer
+     */
+    compareSentAndReceived(result: any, type: any): void;
+}
+export {};

package/dist/statsAnalyzer/mqaUtil.d.ts

@@ -0,0 +1,24 @@
+export declare const getAudioReceiverMqa: ({ audioReceiver, statsResults, lastMqaDataSent, mediaType }: {
+    audioReceiver: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getAudioSenderMqa: ({ audioSender, statsResults, lastMqaDataSent, mediaType }: {
+    audioSender: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getVideoReceiverMqa: ({ videoReceiver, statsResults, lastMqaDataSent, mediaType }: {
+    videoReceiver: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;
+export declare const getVideoSenderMqa: ({ videoSender, statsResults, lastMqaDataSent, mediaType }: {
+    videoSender: any;
+    statsResults: any;
+    lastMqaDataSent: any;
+    mediaType: any;
+}) => void;

package/dist/transcription/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @description Meeting Webex assistance transcription feature.
+ * @exports
+ * @class Transcription
+ */
+export default class Transcription {
+    webSocketUrl: any;
+    sessionID: any;
+    members: any;
+    memberCSIs: any;
+    webSocket: any;
+    /**
+     * @param {string} webSocketUrl
+     * @param {sessionID} sessionId
+     * @param {object} members
+     * @constructor
+     * @memberof Transcription
+     */
+    constructor(webSocketUrl: string, sessionId: any, members: object);
+    /**
+     * open the Low Latency Mercury connection
+     * An event parameter will be send to the callback.
+     *
+     * @param {string} token
+     * @param {string} sessionID
+     * @returns {void}
+     */
+    connect(token: string): void;
+    /**
+     * Sets callback to invoke when the web socket connection is closed.
+     *
+     * @param {Function} callback
+     * @returns {void}
+     */
+    onCloseSocket(callback: any): void;
+    /**
+     * Sets callback to invoke when a web socket connection error occurs.
+     * An event parameter will be send to the callback.
+     *
+     * @param {Function} callback
+     * @returns {void}
+     */
+    onErrorSocket(callback: any): void;
+    /**
+     * Get current speaker from the given csis payload and update the global csis map
+     *
+     * @private
+     * @param {object} csis
+     * @returns {object}
+     */
+    private getSpeaker;
+    /**
+     * Sends transcription data to given callback as it arrives.
+     *
+     * @param {Function} callback
+     * @returns {void}
+     */
+    subscribe(callback: any): void;
+    /**
+     * Close the LLM web socket connection
+     * @returns {void}
+     */
+    closeSocket(): void;
+}

package/dist/webinar/collection.d.ts

@@ -0,0 +1,16 @@
+/*!
+ * Copyright (c) 2015-2023 Cisco Systems, Inc. See LICENSE file.
+ */
+declare class WebinarCollection {
+    webinarInfo: any;
+    namespace: string;
+    mainIndex: string;
+    constructor();
+    set(id: any, info: any): void;
+    /**
+     * @param {String} id
+     * @returns {Member}
+     */
+    get(id: string): any;
+}
+export default WebinarCollection;

package/dist/webinar/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @class Webinar
+ */
+declare const Webinar: any;
+export default Webinar;

package/dist/webinar/index.js

@@ -62,7 +62,7 @@ var Webinar = _webexCore.WebexPlugin.extend({
   updateCanManageWebcast: function updateCanManageWebcast(canManageWebcast) {
     this.set('canManageWebcast', canManageWebcast);
   },
-  version: "2.60.0-next.4"
+  version: "2.60.0-next.6"
 });
 var _default = exports.default = Webinar;
 //# sourceMappingURL=index.js.map