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

package/dist/cjs/types/stanza-media-session.js

@@ -0,0 +1,255 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StanzaMediaSession = void 0;
+/* istanbul ignore file */
+const events_1 = __importDefault(require("events"));
+const jingle_1 = require("stanza/jingle");
+const Constants_1 = require("stanza/Constants");
+const webrtc_stats_gatherer_1 = __importDefault(require("webrtc-stats-gatherer"));
+const interfaces_1 = require("./interfaces");
+const loggingOverrides = {
+    'Discovered new ICE candidate': { skipMessage: true }
+};
+// because we are trying to unify the interfaces between stanza and genesys media session
+// we kind of have to hack the stanza one so it works with typescript
+class StanzaMediaSession extends jingle_1.MediaSession {
+    constructor(params) {
+        super(params.options);
+        this.iceCandidatesDiscovered = 0;
+        this.iceCandidatesReceivedFromPeer = 0;
+        this.reinvite = false;
+        this.logger = params.logger;
+        this.conversationId = params.conversationId;
+        this.peerConnection = this.pc;
+        this.fromUserId = params.fromUserId;
+        this.meetingId = params.meetingId;
+        this.id = this.sid;
+        this.originalRoomJid = params.originalRoomJid;
+        this.sessionType = interfaces_1.SessionTypes[params.sessionType];
+        this.ignoreHostCandidatesFromRemote = !!params.ignoreHostCandidatesFromRemote;
+        this.allowIPv6 = !!params.allowIPv6;
+        this.allowTCP = !!params.allowTCP;
+        this.privAnswerMode = params.privAnswerMode;
+        // 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 events_1.default();
+        Object.keys(eventEmitter.__proto__).forEach((name) => {
+            this[name] = eventEmitter[name];
+        });
+        if (!params.optOutOfWebrtcStatsTelemetry) {
+            this.setupStatsGatherer();
+        }
+        this.pc.addEventListener('connectionstatechange', this.onConnectionStateChange.bind(this));
+        this.pc.addEventListener('icecandidateerror', this.onIceCandidateError.bind(this));
+    }
+    getLogDetails() {
+        return {
+            conversationId: this.conversationId,
+            sessionId: this.id,
+            sessionType: this.sessionType
+        };
+    }
+    async onTransportInfo(changes, cb) {
+        var _a, _b;
+        const transport = (_a = changes.contents) === null || _a === void 0 ? void 0 : _a[0].transport;
+        const candidates = transport === null || transport === void 0 ? void 0 : transport.candidates;
+        if (this.ignoreHostCandidatesFromRemote) {
+            const nonHostCandidates = candidates === null || candidates === void 0 ? void 0 : candidates.filter(candidate => candidate.type !== 'host');
+            if ((nonHostCandidates === null || nonHostCandidates === void 0 ? void 0 : nonHostCandidates.length) !== ((_b = transport === null || transport === void 0 ? void 0 : transport.candidates) === null || _b === void 0 ? void 0 : _b.length)) {
+                this._log('info', 'Ignoring remote host ice candidates');
+                transport.candidates = nonHostCandidates;
+            }
+        }
+        if (candidates) {
+            for (const candidate of candidates) {
+                this._log('info', 'Received candidate from peer', { candidateType: candidate.type });
+                this.iceCandidatesReceivedFromPeer++;
+            }
+        }
+        return super.onTransportInfo(changes, cb);
+    }
+    _log(level, message, ...data) {
+        const redactionInfo = loggingOverrides[message];
+        if (redactionInfo === null || redactionInfo === void 0 ? void 0 : redactionInfo.skipMessage) {
+            return;
+        }
+        let details;
+        if (data.length) {
+            const firstItem = data[0];
+            // if first item is an object, merge the details, else wrap them
+            if (typeof firstItem === 'object' &&
+                !Array.isArray(firstItem) &&
+                firstItem !== null) {
+                Object.assign(data[0], this.getLogDetails());
+                details = data;
+            }
+            else {
+                details = { ...this.getLogDetails(), data: firstItem };
+            }
+        }
+        else {
+            details = [...data, this.getLogDetails()];
+        }
+        this.logger[level](message, details);
+    }
+    async end(reason = 'success', silent = false) {
+        this.state = 'ended';
+        this.processingQueue.kill();
+        if (typeof reason === 'string') {
+            reason = { condition: reason };
+        }
+        if (!silent) {
+            this._log('info', 'sending jingle session-terminate');
+            this.send('session-terminate', { reason });
+        }
+        // After sending session-terminate, wait for the peer connection to die -> if it doesn't, we will manually close it.
+        setTimeout(() => {
+            if (this.pc.connectionState === 'connected' || this.pc.connectionState === 'connecting') {
+                this.pc.close();
+            }
+        }, 2000);
+        this.parent.emit('terminated', this, reason);
+        this.parent.forgetSession(this);
+    }
+    setupStatsGatherer() {
+        this.statsGatherer = new webrtc_stats_gatherer_1.default(this.pc);
+        this.statsGatherer.on('stats', this.emit.bind(this, 'stats'));
+    }
+    onIceStateChange() {
+        const iceState = this.pc.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.pc.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');
+            this.send(Constants_1.JingleAction.SessionInfo, {
+                info: {
+                    infoType: Constants_1.JINGLE_INFO_ACTIVE
+                }
+            });
+            this._setupDataChannel();
+        }
+        else if (iceState === 'failed') {
+            this._log('info', 'ICE connection failed', {
+                candidatesDiscovered: this.iceCandidatesDiscovered,
+                candidatesReceivedFromPeer: this.iceCandidatesReceivedFromPeer
+            });
+        }
+        super.onIceStateChange();
+    }
+    onConnectionStateChange() {
+        const connectionState = this.pc.connectionState;
+        const sessionId = this.id;
+        const conversationId = this.conversationId;
+        const sessionType = this.sessionType;
+        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', { sessionId, conversationId, sessionType });
+            }
+        }
+    }
+    onIceCandidateError(ev) {
+        const event = ev;
+        this._log('error', 'IceCandidateError', {
+            errorCode: event.errorCode,
+            errorText: event.errorText,
+            url: event.url
+        });
+        console.error('IceCandidateError', event);
+    }
+    onIceCandidate(e) {
+        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.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++;
+        }
+        return super.onIceCandidate(e);
+    }
+    onIceEndOfCandidates() {
+        super.onIceEndOfCandidates();
+        this.emit('endOfCandidates');
+    }
+    addTrack(track, stream) {
+        if (track.kind === 'audio') {
+            this.includesAudio = true;
+        }
+        if (track.kind === 'video') {
+            this.includesVideo = true;
+        }
+        return this.processLocal('addtrack', async () => {
+            // find an available sender with the correct type
+            const availableTransceiver = this.pc.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.pc.addTrack(track, stream);
+            return;
+        });
+    }
+    _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.pc.localDescription) === null || _a === void 0 ? void 0 : _a.sdp.includes('webrtc-datachannel')) {
+            this._log('info', 'creating data channel');
+            this.dataChannel = this.pc.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 });
+        }
+    }
+}
+exports.StanzaMediaSession = StanzaMediaSession;

package/dist/cjs/types/streaming-client-extension.d.ts

@@ -0,0 +1,14 @@
+import { TokenBucket } from 'limiter';
+import { IQ, Message } from 'stanza/protocol';
+import { NamedAgent } from './named-agent';
+export interface StreamingClientExtension {
+    handleIq?: (iq: IQ) => void;
+    handleMessage?: (message: Message) => void;
+    tokenBucket?: TokenBucket;
+    on?: (eventName: string, ...args: any[]) => void;
+    expose?: {
+        [fnName: string]: any;
+    };
+    configureNewStanzaInstance?: (stanzaInstance: NamedAgent) => Promise<any>;
+    handleStanzaInstanceChange: (stanzaInstance: NamedAgent) => void;
+}

package/dist/cjs/types/streaming-client-extension.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/timeout-error.d.ts

@@ -0,0 +1,3 @@
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}

package/dist/cjs/types/timeout-error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = void 0;
+class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/cjs/types/user-cancelled-error.d.ts

@@ -0,0 +1,2 @@
+export default class UserCancelledError extends Error {
+}

package/dist/cjs/types/user-cancelled-error.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class UserCancelledError extends Error {
+}
+exports.default = UserCancelledError;

package/dist/cjs/utils.d.ts

@@ -0,0 +1,34 @@
+import { StreamingClientErrorTypes, StreamingSubscriptionErrorDetails } from './types/interfaces';
+export declare class StreamingClientError extends Error {
+    type: StreamingClientErrorTypes;
+    details?: unknown;
+    constructor(type: StreamingClientErrorTypes | null, messageOrError: string | Error, details?: unknown);
+}
+export declare class StreamingSubscriptionError extends Error {
+    readonly topic?: string | undefined;
+    readonly operation?: "subscribe" | "unsubscribe" | undefined;
+    name: string;
+    missingPermissions?: string[];
+    constructor(message: string, topic?: string | undefined, operation?: "subscribe" | "unsubscribe" | undefined, details?: StreamingSubscriptionErrorDetails);
+}
+export declare function timeoutPromise(fn: Function, timeoutMs: number, msg: string, details?: any): Promise<any>;
+export declare function delay(ms: number): Promise<void>;
+export declare function splitIntoIndividualTopics(topicString: string): string[];
+export declare const isAcdJid: (jid: string) => boolean;
+export declare const isScreenRecordingJid: (jid: string) => boolean;
+export declare const isLiveScreenMonitoringJid: (jid: string) => boolean;
+export declare const isSoftphoneJid: (jid: string) => boolean;
+export declare const isVideoJid: (jid: string) => boolean;
+export declare type RetryPromise<T = any> = {
+    promise: Promise<T>;
+    cancel: (reason?: string | Error) => void;
+    complete: (value?: T) => void;
+    hasCompleted: () => boolean;
+    _id: string;
+};
+export declare function retryPromise<T = any>(promiseFn: () => Promise<T>, retryFn: (error?: Error | any) => boolean | number, retryInterval?: number, logger?: any): RetryPromise<T>;
+export declare const parseJwt: (token: string) => any;
+export declare function calculatePayloadSize(trace: any): number;
+export declare function getUfragFromSdp(sdp: string | undefined): string | null;
+export declare function getIcePwdFromSdp(sdp: string | undefined): string | null;
+export declare function iceIsDifferent(sdp1: string | undefined, sdp2: string | undefined): boolean;

package/dist/cjs/utils.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iceIsDifferent = exports.getIcePwdFromSdp = exports.getUfragFromSdp = exports.calculatePayloadSize = exports.parseJwt = exports.retryPromise = exports.isVideoJid = exports.isSoftphoneJid = exports.isLiveScreenMonitoringJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.delay = exports.timeoutPromise = exports.StreamingSubscriptionError = exports.StreamingClientError = void 0;
+const timeout_error_1 = require("./types/timeout-error");
+const interfaces_1 = require("./types/interfaces");
+class StreamingClientError extends Error {
+    constructor(type, messageOrError, details) {
+        let message;
+        if (messageOrError instanceof Error) {
+            message = messageOrError.message;
+        }
+        else {
+            message = messageOrError;
+        }
+        super(message);
+        if (messageOrError instanceof Error) {
+            this.name = messageOrError.name;
+        }
+        this.type = type !== null && type !== void 0 ? type : interfaces_1.StreamingClientErrorTypes.generic;
+        this.details = details;
+    }
+}
+exports.StreamingClientError = StreamingClientError;
+class StreamingSubscriptionError extends Error {
+    constructor(message, topic, operation, details) {
+        super(message);
+        this.topic = topic;
+        this.operation = operation;
+        this.name = 'StreamingSubscriptionError';
+        this.missingPermissions = details === null || details === void 0 ? void 0 : details.missingPermissions;
+    }
+}
+exports.StreamingSubscriptionError = StreamingSubscriptionError;
+/* istanbul ignore next */
+function timeoutPromise(fn, timeoutMs, msg, details) {
+    return new Promise(function (resolve, reject) {
+        const timeout = setTimeout(function () {
+            const err = new timeout_error_1.TimeoutError(`Timeout: ${msg}`);
+            err.details = details;
+            reject(err);
+        }, timeoutMs);
+        const done = function (resolvedValue) {
+            clearTimeout(timeout);
+            resolve(resolvedValue);
+        };
+        fn(done, reject);
+    });
+}
+exports.timeoutPromise = timeoutPromise;
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+exports.delay = delay;
+function splitIntoIndividualTopics(topicString) {
+    const topics = [];
+    if (topicString.includes('?')) {
+        const split = topicString.split('?');
+        const prefix = split[0];
+        const postfixes = split[1] && split[1].split('&');
+        if (postfixes && postfixes.length) {
+            postfixes.forEach(postfix => {
+                topics.push(`${prefix}.${postfix}`);
+            });
+        }
+    }
+    else {
+        topics.push(topicString);
+    }
+    return topics;
+}
+exports.splitIntoIndividualTopics = splitIntoIndividualTopics;
+const isAcdJid = function (jid) {
+    return jid.startsWith('acd-') && !(0, exports.isSoftphoneJid)(jid);
+};
+exports.isAcdJid = isAcdJid;
+const isScreenRecordingJid = function (jid) {
+    return jid.startsWith('screenrecording-') && !(0, exports.isSoftphoneJid)(jid);
+};
+exports.isScreenRecordingJid = isScreenRecordingJid;
+const isLiveScreenMonitoringJid = function (jid) {
+    return jid.startsWith('livemonitor-') && !(0, exports.isSoftphoneJid)(jid);
+};
+exports.isLiveScreenMonitoringJid = isLiveScreenMonitoringJid;
+const isSoftphoneJid = function (jid) {
+    if (!jid) {
+        return false;
+    }
+    return !!jid.match(/.*@.*gjoll.*/i);
+};
+exports.isSoftphoneJid = isSoftphoneJid;
+const isVideoJid = function (jid) {
+    return !!(jid && jid.match(/@conference/) && !(0, exports.isAcdJid)(jid));
+};
+exports.isVideoJid = isVideoJid;
+function retryPromise(promiseFn, 
+// if a number is returned, that's how long we will wait before retrying (in milliseconds)
+retryFn, retryInterval = 15000, logger = console) {
+    let timeout;
+    let cancel;
+    let complete;
+    let tryPromiseFn;
+    let _hasCompleted = false;
+    const promise = new Promise((resolve, reject) => {
+        tryPromiseFn = async () => {
+            try {
+                const val = await promiseFn();
+                complete(val);
+            }
+            catch (error) {
+                let timeToWait = retryInterval;
+                const retryValue = retryFn(error);
+                if (Number.isInteger(retryValue)) {
+                    timeToWait = retryValue;
+                }
+                if (retryValue !== false) {
+                    logger.debug('Retrying promise', error);
+                    timeout = setTimeout(tryPromiseFn, timeToWait);
+                }
+                else {
+                    cancel(error);
+                }
+            }
+        };
+        complete = (value) => {
+            clearTimeout(timeout);
+            _hasCompleted = true;
+            resolve(value);
+        };
+        cancel = (reason) => {
+            clearTimeout(timeout);
+            _hasCompleted = true;
+            reject(reason);
+        };
+        tryPromiseFn();
+    });
+    return {
+        promise,
+        cancel,
+        complete,
+        _id: globalThis.crypto.randomUUID(),
+        hasCompleted: () => _hasCompleted
+    };
+}
+exports.retryPromise = retryPromise;
+// from https://stackoverflow.com/questions/38552003/how-to-decode-jwt-token-in-javascript
+const parseJwt = (token) => {
+    const base64Url = token.split('.')[1];
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const jsonPayload = decodeURIComponent(window.atob(base64).split('').map(function (c) {
+        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+    }).join(''));
+    return JSON.parse(jsonPayload);
+};
+exports.parseJwt = parseJwt;
+function calculatePayloadSize(trace) {
+    const str = JSON.stringify(trace);
+    // http://stackoverflow.com/questions/5515869/string-length-in-bytes-in-javascript
+    // Matches only the 10.. bytes that are non-initial characters in a multi-byte sequence.
+    const m = encodeURIComponent(str).match(/%[89ABab]/g);
+    return str.length + (m ? m.length : 0);
+}
+exports.calculatePayloadSize = calculatePayloadSize;
+function getUfragFromSdp(sdp) {
+    if (!sdp) {
+        return null;
+    }
+    const regex = /a=ice-ufrag:(\S+)/;
+    const match = sdp.match(regex);
+    return match ? match[1] : null;
+}
+exports.getUfragFromSdp = getUfragFromSdp;
+function getIcePwdFromSdp(sdp) {
+    if (!sdp) {
+        return null;
+    }
+    const regex = /a=ice-pwd:(\S+)/;
+    const match = sdp.match(regex);
+    return match ? match[1] : null;
+}
+exports.getIcePwdFromSdp = getIcePwdFromSdp;
+function iceIsDifferent(sdp1, sdp2) {
+    return getUfragFromSdp(sdp1) !== getUfragFromSdp(sdp2) || getIcePwdFromSdp(sdp1) !== getIcePwdFromSdp(sdp2);
+}
+exports.iceIsDifferent = iceIsDifferent;
+// unsed, but handy. no test coverage until used
+// function mergeOptions (destination, provided) {
+//   for (var key in provided) {
+//     let value = provided[key];
+//     if (value instanceof Object) {
+//       if (!destination[key]) {
+//         destination[key] = {};
+//       }
+//       mergeOptions(destination[key], value);
+//     } else {
+//       destination[key] = provided[key];
+//     }
+//   }
+//
+//   return destination;
+// }

package/dist/cjs/webrtc.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { IQ } from 'stanza/protocol';
+import { LRUCache } from 'lru-cache';
+import { SessionManager } from 'stanza/jingle';
+import { SessionOpts } from 'stanza/jingle/Session';
+import { Client } from './client';
+import { ExtendedRTCIceServer, IClientOptions, SessionTypes, IPendingSession, StreamingClientExtension, NRProxyStat, InsightAction } from './types/interfaces';
+import { NamedAgent } from './types/named-agent';
+import { StanzaMediaSession } from './types/stanza-media-session';
+import { IMediaSession } from './types/media-session';
+import Logger from 'genesys-cloud-client-logger';
+export interface InitRtcSessionOptions {
+    stream?: MediaStream;
+    provideVideo?: boolean;
+    provideAudio?: boolean;
+    mediaPurpose?: string;
+    jid?: string;
+    conversationId?: string;
+    sourceCommunicationId?: string;
+    videoGuest?: boolean;
+}
+export declare class WebrtcExtension extends EventEmitter implements StreamingClientExtension {
+    client: Client;
+    ignoredSessions: LRUCache<string, boolean, unknown>;
+    private earlyIceCandidates;
+    logger: Logger;
+    pendingSessions: {
+        [sessionId: string]: IPendingSession;
+    };
+    config: {
+        allowIPv6: boolean;
+        optOutOfWebrtcStatsTelemetry?: boolean;
+    };
+    private statsArr;
+    private throttleSendStatsInterval;
+    private currentMaxStatSize;
+    private statsSizeDecreaseAmount;
+    private statBuffer;
+    private throttledSendStats;
+    private discoRetries;
+    private refreshIceServersRetryPromise;
+    private refreshIceServersTimer;
+    private iceServers;
+    private stanzaInstance?;
+    private stanzaSessions;
+    private webrtcSessions;
+    private reinviteCache;
+    private sessionsMap;
+    get jid(): string | undefined;
+    constructor(client: Client, clientOptions: IClientOptions);
+    private onOnlineStatusChange;
+    handleStanzaInstanceChange(stanzaInstance: NamedAgent): Promise<void>;
+    configureNewStanzaInstance(stanzaInstance: NamedAgent): Promise<void>;
+    private configureStanzaIceServers;
+    private handleGenesysOffer;
+    private applyEarlyIceCandidates;
+    private handleGenesysRenegotiate;
+    private handleGenesysIceCandidate;
+    private handleGenesysTerminate;
+    private getSessionById;
+    sendIq(iq: IQ): Promise<any>;
+    handleMessage(msg: any): Promise<void>;
+    handleGenesysWebrtcStanza(iq: IQ): Promise<boolean | void>;
+    prepareSession(options: SessionOpts): StanzaMediaSession | undefined;
+    proxyStatsForSession(session: IMediaSession): void;
+    addStatToQueue<T extends {
+        _eventType: string;
+    }>(stat: InsightAction<T>): void;
+    getLogDetailsForPendingSessionId(sessionId: string): {
+        conversationId?: string;
+        sessionId: string;
+        sessionType?: SessionTypes;
+    };
+    sendStatsImmediately(): void;
+    sendStats(): Promise<void>;
+    addEventListeners(): void;
+    /**
+     * Stanza Handlers
+     */
+    private handlePropose;
+    private handleRetract;
+    /**
+     * Inform the client that another client has already taken care of the pendingSession
+     */
+    private handledIncomingRtcSession;
+    /**
+     * Exposed Api
+     */
+    initiateRtcSession(opts: InitRtcSessionOptions): Promise<any>;
+    acceptRtcSession(sessionId: string): Promise<void>;
+    rejectRtcSession(sessionId: string, ignore?: boolean): Promise<void>;
+    rtcSessionAccepted(sessionId: string): Promise<void>;
+    notifyScreenShareStart(session: IMediaSession): Promise<void>;
+    notifyScreenShareStop(session: IMediaSession): Promise<void>;
+    cancelRtcSession(sessionId: string): Promise<void>;
+    refreshIceServers(): Promise<ExtendedRTCIceServer[]>;
+    _refreshIceServers(stanzaInstance?: NamedAgent): Promise<ExtendedRTCIceServer[]>;
+    setIceServers(iceServers: any[], stanzaInstance: NamedAgent): void;
+    getIceTransportPolicy(): RTCIceTransportPolicy | undefined;
+    setIceTransportPolicy(policy: 'relay' | 'all', stanzaInstance: NamedAgent): void;
+    getSessionTypeByJid(jid: string): SessionTypes;
+    getSessionManager(): SessionManager | undefined;
+    getAllSessions(): IMediaSession[];
+    proxyNRStat(stat: NRProxyStat): void;
+    get expose(): WebrtcExtensionAPI;
+}
+export interface WebrtcExtensionAPI {
+    on: (event: string, handler: (...args: any) => void) => void;
+    once: (event: string, handler: (...args: any) => void) => void;
+    off: (event: string, handler: (...args: any) => void) => void;
+    removeAllListeners(event?: string | symbol): void;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): void;
+    refreshIceServers(): Promise<any[]>;
+    acceptRtcSession(sessionId: string): void;
+    rejectRtcSession(sessionId: string, ignore?: boolean): void;
+    cancelRtcSession(sessionId: string): void;
+    rtcSessionAccepted(sessionId: string): void;
+    initiateRtcSession(opts: InitRtcSessionOptions): Promise<void>;
+    notifyScreenShareStart(session: IMediaSession): void;
+    notifyScreenShareStop(session: IMediaSession): void;
+    getSessionTypeByJid(jid: string): SessionTypes;
+    getSessionManager: () => SessionManager | undefined;
+    getAllSessions: () => IMediaSession[];
+    proxyNRStat: (stat: NRProxyStat) => void;
+}