@ohos-ports/genesys-cloud-streaming-client 20.1.0-beta.1

package/dist/es/types/genesys-cloud-media-session.js

@@ -0,0 +1,379 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import StatsGatherer from 'webrtc-stats-gatherer';
+import { EventEmitter } from 'events';
+import { timeoutPromise } from '../utils';
+import { SessionTypes } from './interfaces';
+const loggingOverrides = {
+    'Discovered new ICE candidate': { skipMessage: true }
+};
+export class GenesysCloudMediaSession {
+    constructor(webrtcExtension, params) {
+        this.webrtcExtension = webrtcExtension;
+        this.iceCandidatesDiscovered = 0;
+        this.iceCandidatesReceivedFromPeer = 0;
+        this.state = 'pending';
+        this.connectionState = 'starting';
+        this.id = params.id;
+        this.fromJid = params.fromJid;
+        this.peerID = params.peerID;
+        this.logger = params.logger;
+        this.conversationId = params.conversationId;
+        this.fromUserId = params.fromUserId;
+        this.pc = this.peerConnection = new RTCPeerConnection({
+            iceServers: params.iceServers,
+            iceTransportPolicy: params.iceTransportPolicy
+        });
+        this.originalRoomJid = params.originalRoomJid;
+        this.sessionType = SessionTypes[params.sessionType];
+        this.ignoreHostCandidatesFromRemote = !!params.ignoreHostCandidatesFromRemote;
+        this.allowIPv6 = !!params.allowIPv6;
+        this.allowTCP = !!params.allowTCP;
+        this.reinvite = !!params.reinvite;
+        this.privAnswerMode = params.privAnswerMode;
+        this.meetingId = params.meetingId;
+        // babel does not like the typescript recipe for multiple extends so we are hacking this one
+        // referencing https://github.com/babel/babel/issues/798
+        const eventEmitter = new EventEmitter();
+        Object.keys(eventEmitter.__proto__).forEach((name) => {
+            this[name] = eventEmitter[name];
+        });
+        if (!params.optOutOfWebrtcStatsTelemetry) {
+            this.setupStatsGatherer();
+        }
+        this.peerConnection.addEventListener('icecandidate', this.onIceCandidate.bind(this));
+        this.peerConnection.addEventListener('iceconnectionstatechange', this.onIceStateChange.bind(this));
+        this.peerConnection.addEventListener('connectionstatechange', this.onConnectionStateChange.bind(this));
+        this.peerConnection.addEventListener('icecandidateerror', this.onIceCandidateError.bind(this));
+        // sync the session state after a silent disconnect, like putting the system to sleep.
+    }
+    keepStateInSyncWithPeerConnection() {
+        if (this.stateSyncTimeout) {
+            clearTimeout(this.stateSyncTimeout);
+            this.stateSyncTimeout = undefined;
+        }
+        const lastTime = Date.now();
+        const checkInterval = 2000;
+        const threshold = 2000;
+        this.stateSyncTimeout = setTimeout(() => {
+            const currentTime = Date.now();
+            const timeDiff = currentTime - lastTime;
+            if (timeDiff > checkInterval + threshold) {
+                this.log('warn', 'MediaSession detected timer anomally. Reasons include taxed resources or system sleep.');
+                // if we have a state mismatch
+                if (this.state !== 'ended' && ['failed', 'closed'].includes(this.peerConnection.connectionState)) {
+                    this.log('warn', 'state mismatch between session.state and peerConnection.connectionState, manually terminating the session', { sessionId: this.id, conversationId: this.conversationId, sessionType: this.sessionType });
+                    this.onSessionTerminate();
+                }
+            }
+            if (this.state !== 'ended') {
+                this.keepStateInSyncWithPeerConnection();
+            }
+        }, checkInterval);
+    }
+    setRemoteDescription(sdp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.peerConnection.setRemoteDescription({ sdp, type: 'offer' });
+        });
+    }
+    getLogDetails() {
+        return {
+            conversationId: this.conversationId,
+            sessionId: this.id,
+            sessionType: this.sessionType
+        };
+    }
+    log(level, message, details, options) {
+        if (!details) {
+            details = {};
+        }
+        const logDetails = Object.assign(Object.assign({}, details), this.getLogDetails());
+        this.logger[level](message, logDetails, options);
+    }
+    sendGenesysWebrtc(info) {
+        return __awaiter(this, void 0, void 0, function* () {
+            info.id = info.id || globalThis.crypto.randomUUID();
+            info.jsonrpc = info.jsonrpc || '2.0';
+            const iq = {
+                type: 'set',
+                genesysWebrtc: info,
+                from: this.webrtcExtension.jid,
+                to: this.peerID
+            };
+            return this.webrtcExtension.sendIq(iq);
+        });
+    }
+    end(reason = 'success', silent = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state = 'ended';
+            const params = {
+                sessionId: this.id,
+                reason: reason.condition || reason
+            };
+            if (!silent) {
+                yield timeoutPromise((resolve, reject) => {
+                    this.log('info', 'sending sdp terminate');
+                    this.sendGenesysWebrtc({ jsonrpc: '2.0', method: 'terminate', params }).then(resolve, reject);
+                }, 2000, 'Timeout waiting for response to termination request', { sessionId: this.id, conversationId: this.conversationId, sessionType: this.sessionType }).catch((e) => this.logger.error(e));
+            }
+            this.onSessionTerminate(params.reason);
+        });
+    }
+    setupStatsGatherer() {
+        this.statsGatherer = new StatsGatherer(this.peerConnection);
+        this.statsGatherer.on('stats', this.emit.bind(this, 'stats'));
+    }
+    onIceStateChange() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const iceState = this.peerConnection.iceConnectionState;
+            const sessionId = this.id;
+            const conversationId = this.conversationId;
+            const sessionType = this.sessionType;
+            this.log('info', 'ICE state changed: ', { iceState, sessionId, conversationId });
+            if (iceState === 'disconnected') {
+                // this means we actually connected at one point
+                if (this.peerConnection.signalingState === 'stable') {
+                    this.interruptionStart = new Date();
+                    this.log('info', 'Connection state is interrupted', { sessionId, conversationId, sessionType });
+                }
+            }
+            else if (iceState === 'connected') {
+                this.log('info', 'sending session-info: active');
+                const params = {
+                    sessionId: this.id,
+                    status: 'active'
+                };
+                yield this.sendGenesysWebrtc({
+                    jsonrpc: '2.0',
+                    params,
+                    method: 'info'
+                });
+                this._setupDataChannel();
+            }
+            else if (iceState === 'failed') {
+                this.log('info', 'ICE connection failed', {
+                    candidatesDiscovered: this.iceCandidatesDiscovered,
+                    candidatesReceivedFromPeer: this.iceCandidatesReceivedFromPeer
+                });
+            }
+        });
+    }
+    onConnectionStateChange() {
+        const connectionState = this.connectionState = this.peerConnection.connectionState;
+        const sessionId = this.id;
+        const conversationId = this.conversationId;
+        const sessionType = this.sessionType;
+        if (connectionState === 'connected') {
+            this.keepStateInSyncWithPeerConnection();
+        }
+        this.log('info', 'Connection state changed: ', { connectionState, sessionId, conversationId, sessionType });
+        if (this.interruptionStart) {
+            if (connectionState === 'connected') {
+                const diff = new Date().getTime() - this.interruptionStart.getTime();
+                this.log('info', 'Connection was interrupted but was successfully recovered/connected', { sessionId, conversationId, sessionType, timeToRecover: diff });
+                this.interruptionStart = undefined;
+            }
+            else if (connectionState === 'failed') {
+                this.log('info', 'Connection was interrupted and failed to recover, cleaning up', { sessionId, conversationId, sessionType });
+                this.onSessionTerminate();
+            }
+        }
+        this.emit('connectionState', connectionState);
+    }
+    onIceCandidateError(ev) {
+        const event = ev;
+        this.log('error', 'IceCandidateError', {
+            errorCode: event.errorCode,
+            errorText: event.errorText,
+            url: event.url
+        });
+    }
+    /* istanbul ignore next */
+    createIceCandidate(sdpMid, candidateStr) {
+        return new RTCIceCandidate({
+            sdpMid,
+            candidate: candidateStr
+        });
+    }
+    addRemoteIceCandidate(sdpFragment) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // matches the mline type. example: "m=video 9 RTP/AVP 0" should result in "video"
+            const sdpMid = sdpFragment.match(/m=([^\s]+)/)[1];
+            // matches the entire a= line without the "a="
+            const candidate = sdpFragment.match(/a=([^\\\r]+)/)[1];
+            const iceCandidate = this.createIceCandidate(sdpMid, candidate);
+            yield this.peerConnection.addIceCandidate(iceCandidate);
+        });
+    }
+    // this is for ice candidates we harvest for ourself
+    onIceCandidate(e) {
+        var _a, _b;
+        const candidateString = (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.candidate;
+        const sdpMid = (_b = e.candidate) === null || _b === void 0 ? void 0 : _b.sdpMid;
+        let sdpStr;
+        if (e.candidate) {
+            if (!this.allowTCP && e.candidate.protocol === 'tcp') {
+                return;
+            }
+            if (!this.allowIPv6) {
+                const addressRegex = /.+udp [^ ]+ ([^ ]+).*typ host/;
+                const matches = addressRegex.exec(e.candidate.candidate);
+                const ipv4Regex = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/;
+                if (matches && !matches[1].match(ipv4Regex)) {
+                    this.log('debug', 'Filtering out IPv6 candidate', e.candidate.candidate);
+                    return;
+                }
+            }
+            // this has too much information and can only be logged locally (debug)
+            this.log('debug', 'Processing ice candidate', e.candidate);
+            // this one is info level so it can go to the server
+            this.log('info', 'Discovered ice candidate to send to peer', { type: e.candidate.type });
+            this.iceCandidatesDiscovered++;
+            // media team asked us to send the mline and prefix the candidate with "a="
+            sdpStr = `m=${sdpMid} 9 RTP/AVP 0\r\na=${candidateString}\r\n`;
+        }
+        else {
+            sdpStr = 'a=end-of-candidates\r\n';
+            this.emit('endOfCandidates');
+        }
+        return this.sendGenesysWebrtc({
+            jsonrpc: '2.0',
+            method: 'iceCandidate',
+            params: {
+                sessionId: this.id,
+                sdp: sdpStr
+            }
+        });
+    }
+    onSessionTerminate(reason) {
+        this.state = 'ended';
+        if (this.peerConnection) {
+            this.peerConnection.close();
+        }
+        this.logger.info('emitting sdp media-session (terminate)');
+        this.emit('terminated', { condition: reason || 'success' });
+    }
+    addTrack(track, stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const availableTransceiver = this.peerConnection.getTransceivers().find((transceiver) => {
+                var _a;
+                return !transceiver.sender.track && ((_a = transceiver.receiver.track) === null || _a === void 0 ? void 0 : _a.kind) === track.kind;
+            });
+            if (availableTransceiver) {
+                return availableTransceiver.sender.replaceTrack(track);
+            }
+            this.peerConnection.addTrack(track, stream);
+        });
+    }
+    _setupDataChannel() {
+        var _a;
+        // this shouldn't happen, but we shouldn't set the datachannel up more than once
+        if (this.dataChannel) {
+            return;
+        }
+        // do nothing if a datachannel wasn't offered
+        if ((_a = this.peerConnection.remoteDescription) === null || _a === void 0 ? void 0 : _a.sdp.includes('webrtc-datachannel')) {
+            this.log('info', 'creating data channel');
+            this.dataChannel = this.peerConnection.createDataChannel('videoConferenceControl');
+            this.dataChannel.addEventListener('open', () => {
+                this.log('info', 'data channel opened');
+            });
+            this.dataChannel.addEventListener('message', this._handleDataChannelMessage.bind(this));
+            this.dataChannel.addEventListener('close', () => {
+                this.log('info', 'closing data channel');
+            });
+            this.dataChannel.addEventListener('error', (error) => {
+                this.log('error', 'Error occurred with the data channel', error);
+            });
+        }
+    }
+    _handleDataChannelMessage(event) {
+        try {
+            const message = JSON.parse(event.data);
+            this.emit('dataChannelMessage', message);
+        }
+        catch (e) {
+            this.log('error', 'Failed to parse data channel message', { error: e });
+        }
+    }
+    accept() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state = 'active';
+            const answer = yield this.peerConnection.createAnswer();
+            yield this.peerConnection.setLocalDescription(answer);
+            const params = {
+                sdp: answer.sdp,
+                sessionId: this.id
+            };
+            // Do not log the SDP payload to avoid logging sensitive information.
+            this.logger.info('sending sdp answer', { sessionId: this.id, conversationId: this.conversationId });
+            return this.sendGenesysWebrtc({
+                jsonrpc: '2.0',
+                method: 'answer',
+                params
+            });
+        });
+    }
+    mute(userId, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                sessionId: this.id,
+                type
+            };
+            return this.sendGenesysWebrtc({
+                jsonrpc: '2.0',
+                method: 'mute',
+                params
+            });
+        });
+    }
+    unmute(userId, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = {
+                sessionId: this.id,
+                type
+            };
+            return this.sendGenesysWebrtc({
+                jsonrpc: '2.0',
+                method: 'unmute',
+                params
+            });
+        });
+    }
+    /* istanbul ignore next */
+    removeTrack() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Not Implemented');
+        });
+    }
+    /* istanbul ignore next */
+    hold() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Not Implemented');
+        });
+    }
+    /* istanbul ignore next */
+    resume() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Not Implemented');
+        });
+    }
+    toString() {
+        return {
+            connectionState: this.connectionState,
+            state: this.state,
+            sessionType: this.sessionType,
+            fromJid: this.fromJid,
+            conversationId: this.conversationId,
+            id: this.id,
+            peerConnection: this.peerConnection
+        };
+    }
+}

package/dist/es/types/interfaces.d.ts

@@ -0,0 +1,310 @@
+import { ILogger, LogFormatterFn, LogLevel } from 'genesys-cloud-client-logger';
+import { AxiosError, ResponseType } from 'axios';
+import { NamedAgent } from './named-agent';
+import { JingleReasonCondition } from 'stanza/Constants';
+export { ILogger, LogLevel };
+export interface IClientOptions {
+    host: string;
+    apiHost?: string;
+    authToken?: string;
+    jwt?: string;
+    jid?: string;
+    userId?: string;
+    jidResource?: string;
+    reconnectOnNoLongerSubscribed?: boolean;
+    optOutOfWebrtcStatsTelemetry?: boolean;
+    allowIPv6?: boolean;
+    logger?: ILogger;
+    logLevel?: LogLevel;
+    logFormatters?: LogFormatterFn[];
+    signalIceConnected?: boolean;
+    useServerSidePings?: boolean;
+    appName?: string;
+    appVersion?: string;
+    appId?: string;
+    customHeaders?: ICustomHeader;
+    /** When true, creates a unique log uploader instance rather than sharing a singleton per URL. */
+    useUniqueLogUploader?: boolean;
+    /** Allow bulk topic resubscribe to succeed or fail per-topic rather than all or nothing */
+    enablePartialBulkResubscribe?: boolean;
+    /** Genesys internal use only - non-Genesys apps that pass in `alertableInteractionTypes` may experience unexpected behavior */
+    alertableInteractionTypes?: AlertableInteractionTypes[];
+}
+export interface ICustomHeader {
+    [header: string]: string;
+}
+export declare enum AlertableInteractionTypes {
+    voice = "voice"
+}
+/** The alerting status for an interaction type */
+export interface IAlertingStatus {
+    /**
+     * Indicates whether this client should be alerting. This can be because this client is the alerting
+     * leader for this interaction type, alerting leader functionality is not configured by an admin,
+     * or because setup for alerting leader failed and we fallback to `alerting: true` so interactions
+     * don't go unnoticed.
+     */
+    alerting: boolean;
+    /**
+     * Indicates if alerting leader functionality is configured by an admin. This will also be `false`
+     * if setup for alerting leader failed.
+    */
+    configured: boolean;
+    /** A string representing the client type of the alerting leader, based on OAuth client ID. */
+    clientType?: string;
+}
+/** The alerting leader status for this client. Currently only `voice` interactions are supported. */
+export interface ILeaderStatus {
+    voice?: IAlertingStatus;
+}
+export interface IClientConfig {
+    host: string;
+    apiHost: string;
+    authToken?: string;
+    jwt?: string;
+    userId?: string;
+    jid?: string;
+    jidResource?: string;
+    channelId: string;
+    appName?: string;
+    appVersion?: string;
+    appId?: string;
+    logLevel?: LogLevel;
+    customHeaders?: ICustomHeader;
+}
+export interface IHttpClientOptions {
+    customHeaders?: ICustomHeader;
+}
+export interface ExtendedRTCIceServer extends RTCIceServer {
+    type: string;
+}
+export declare type RequestApiOptions = {
+    method: 'get' | 'post' | 'patch' | 'put' | 'delete';
+    host: string;
+    data?: any;
+    version?: string;
+    responseType?: ResponseType;
+    contentType?: string;
+    authToken?: string;
+    logger?: any;
+    noAuthHeader?: boolean;
+    requestTimeout?: number;
+    customHeaders?: ICustomHeader;
+    maxAttempts?: number;
+    signal?: AbortSignal;
+};
+export interface IAxiosResponseError extends AxiosError {
+    text: string;
+}
+export interface ISuperagentNetworkError extends Error {
+    status: number | undefined;
+    method: string;
+    url: string;
+    crossDomain: boolean;
+}
+export interface ISuperagentResponseError {
+    original?: any;
+    status: number;
+    response: {
+        body: any;
+        error: ISuperagentNetworkError;
+        header: {
+            [key: string]: string;
+        };
+        headers: {
+            [key: string]: string;
+        };
+        status: number;
+        statusCode: number;
+        statusText: string;
+        text: string;
+        req: {
+            method: string;
+            _data?: string;
+        };
+    };
+}
+export interface INetworkError extends IError {
+    status: number;
+    method: string;
+    url: string;
+    crossDomain: boolean;
+}
+export interface IResponseError extends IError {
+    status: number;
+    correlationId: string;
+    responseBody: string;
+    method: string;
+    requestBody: string;
+    url: string;
+}
+export declare enum StreamingClientErrorTypes {
+    generic = "generic",
+    invalid_token = "invalid_token",
+    userCancelled = "user_cancelled"
+}
+export interface IError {
+    message: string;
+    name: string;
+    stack?: string;
+}
+export declare type SessionTypesAsStrings = 'softphone' | 'screenShare' | 'screenRecording' | 'liveScreenMonitoring' | 'collaborateVideo' | 'unknown';
+export declare enum SessionTypes {
+    softphone = "softphone",
+    collaborateVideo = "collaborateVideo",
+    acdScreenShare = "screenShare",
+    screenRecording = "screenRecording",
+    liveScreenMonitoring = "liveScreenMonitoring",
+    unknown = "unknown"
+}
+export interface ISessionInfo extends IPendingSession {
+}
+export interface IPendingSession {
+    sessionId: string;
+    id: string;
+    autoAnswer: boolean;
+    toJid: string;
+    fromJid: string;
+    conversationId: string;
+    originalRoomJid?: string;
+    sdpOverXmpp?: boolean;
+    privAnswerMode?: 'Auto';
+    fromUserId?: string;
+    roomJid?: string;
+    accepted?: boolean;
+    meetingId?: string;
+    sessionType: SessionTypes | SessionTypesAsStrings;
+}
+export interface StreamingClientExtension {
+    handleIq?: Function;
+    handleMessage?: Function;
+    handleStanzaInstanceChange: (stanzaInstance: NamedAgent) => void;
+    expose: any;
+}
+export interface StreamingClientConnectOptions {
+    /**
+     * @deprecated since version 15.1.1. Please use maxConnectionAttempts instead
+     */
+    keepTryingOnFailure?: boolean;
+    maxConnectionAttempts?: number;
+    maxDelayBetweenConnectionAttempts?: number;
+}
+export interface StreamingSubscriptionErrorDetails {
+    missingPermissions?: string[];
+}
+export declare type GenesysWebrtcBaseParams = {
+    sessionId: string;
+};
+export declare type GenesysWebrtcSdpParams = GenesysWebrtcBaseParams & {
+    sdp: string;
+};
+export declare type GenesysWebrtcOfferParams = GenesysWebrtcSdpParams & {
+    conversationId: string;
+    reinvite?: boolean;
+};
+export declare type GenesysInfoActiveParams = GenesysWebrtcBaseParams & {
+    status: 'active';
+};
+export declare type GenesysSessionTerminateParams = GenesysWebrtcBaseParams & {
+    reason?: JingleReasonCondition;
+};
+export declare type GenesysWebrtcMuteParams = GenesysWebrtcBaseParams & {
+    type: 'audio' | 'video';
+};
+export declare type TypedJsonRpcMessage<Method extends string, Params> = {
+    jsonrpc: string;
+    method: Method;
+    id?: string;
+    params?: Params;
+};
+export declare type JsonRpcMessage = TypedJsonRpcMessage<string, any>;
+export declare type GenesysWebrtcOffer = TypedJsonRpcMessage<'offer', GenesysWebrtcOfferParams>;
+export declare type GenesysWebrtcAnswer = TypedJsonRpcMessage<'answer', GenesysWebrtcSdpParams>;
+export declare type GenesysWebrtcInfo = TypedJsonRpcMessage<'info', GenesysInfoActiveParams>;
+export declare type GenesysWebrtcIceCandidate = TypedJsonRpcMessage<'iceCandidate', GenesysWebrtcSdpParams>;
+export declare type GenesysWebrtcTerminate = TypedJsonRpcMessage<'terminate', GenesysSessionTerminateParams>;
+export declare type GenesysWebrtcMute = TypedJsonRpcMessage<'mute', GenesysWebrtcMuteParams>;
+export declare type GenesysWebrtcUnmute = TypedJsonRpcMessage<'unmute', GenesysWebrtcMuteParams>;
+export declare type GenesysWebrtcJsonRpcMessage = GenesysWebrtcOffer | GenesysWebrtcAnswer | GenesysWebrtcInfo | GenesysWebrtcIceCandidate | GenesysWebrtcTerminate | GenesysWebrtcMute | GenesysWebrtcUnmute;
+export declare type HeadsetControlsRequestType = 'mediaHelper' | 'standard' | 'prioritized';
+export declare type HeadsetControlsRejectionReason = 'activeCall' | 'mediaHelper' | 'priority';
+export declare type HeadsetControlsRejectionParams = {
+    requestId: string;
+    reason: HeadsetControlsRejectionReason;
+};
+export declare type HeadsetControlsChangedParams = {
+    hasControls: boolean;
+};
+export declare type HeadsetControlsRequest = TypedJsonRpcMessage<'headsetControlsRequest', {
+    requestType: HeadsetControlsRequestType;
+}>;
+export declare type HeadsetControlsRejection = TypedJsonRpcMessage<'headsetControlsRejection', HeadsetControlsRejectionParams>;
+export declare type HeadsetControlsChanged = TypedJsonRpcMessage<'headsetControlsChanged', HeadsetControlsChangedParams>;
+export declare type GenesysMediaMessage = HeadsetControlsRequest | HeadsetControlsRejection | HeadsetControlsChanged;
+export declare type FlatObject = {
+    [key: string]: string | number | boolean | null | Date;
+};
+export declare type GenericAction = {
+    _eventType: string;
+};
+export declare type InsightReport = {
+    appName: string;
+    appVersion: string;
+    originAppName?: string;
+    originAppVersion?: string;
+    actions: InsightAction<any>[];
+};
+export declare type InsightAction<T extends {
+    _eventType: string;
+}> = {
+    actionName: 'WebrtcStats';
+    details: InsightActionDetails<T>;
+};
+export declare type InsightActionDetails<K extends {
+    _eventType: string;
+}> = {
+    _eventType: K['_eventType'];
+    /**
+     * This should be ms since epoch, e.g. new Date().getTime()
+     */
+    _eventTimestamp: number;
+    _appId?: string;
+    _appName?: string;
+    _appVersion?: string;
+} & K;
+export declare type OnlineStatusStat = InsightAction<{
+    _eventType: 'onlineStatus';
+    online: boolean;
+}>;
+export declare type FirstProposeStat = InsightAction<{
+    _eventType: 'firstPropose';
+    sdpViaXmppRequested: boolean;
+    sessionType: SessionTypesAsStrings;
+    originAppId?: string;
+    conversationId: string;
+    sessionId: string;
+}>;
+export declare type FirstAlertingConversationStat = InsightAction<{
+    _eventType: 'firstAlertingConversationUpdate';
+    conversationId: string;
+    participantId: string;
+}>;
+export declare type MediaStat = InsightAction<{
+    _eventType: 'mediaRequested' | 'mediaStarted' | 'mediaError';
+    requestId?: string;
+    message?: string;
+    audioRequested: boolean;
+    videoRequested: boolean;
+    displayRequested: boolean;
+    conversationId?: string;
+    sessionType?: SessionTypesAsStrings;
+    sessionId?: string;
+    elapsedMsFromInitialRequest?: number;
+}>;
+export declare type NRProxyStat = FirstAlertingConversationStat | MediaStat;
+export declare type SCConnectionData = {
+    currentDelayMs: number;
+    delayMsAfterNextReduction?: number;
+    nextDelayReductionTime?: number;
+    timeOfTotalReset?: number;
+};