@webex/calling 3.0.0-next.2 → 3.0.0-next.4

package/dist/module/CallSettings/testFixtures.js

@@ -1,62 +1,62 @@
-export const xsiEndpointUrlResponse = {
-    items: [
-        {
-            id: 'Y2lzY',
-            displayName: 'Atlas_Test_WxC_SI_AS10_VAR_WebrtcMobius_DND',
-            created: '2022-03-16T11:20:04.561Z',
-            xsiDomain: 'api-proxy-si.net',
-            xsiActionsEndpoint: 'https://api-proxy-si.broadcloudpbx.net/com.broadsoft.xsi-actions',
-            xsiEventsEndpoint: 'https://api-proxy-si.broadcloudpbx.net/com.broadsoft.xsi-events',
-            xsiEventsChannelEndpoint: 'https://api-proxy-si.broadcloudpbx.net/com.broadsoft.async/com.broadsoft.xsi-events',
-        },
-    ],
-};
-export const callForwardPayload = {
-    callForwarding: {
-        always: {
-            enabled: true,
-            destination: '123456789',
-            ringReminderEnabled: false,
-            destinationVoicemailEnabled: false,
-        },
-        busy: {
-            enabled: false,
-        },
-        noAnswer: {
-            enabled: true,
-            destination: '123123',
-            numberOfRings: 3,
-        },
-    },
-    businessContinuity: {
-        enabled: false,
-    },
-};
-export const dummyEmail = 'abc@test.com';
-export const voicemailPayload = {
-    enabled: true,
-    sendAllCalls: {
-        enabled: true,
-    },
-    sendBusyCalls: {
-        enabled: true,
-    },
-    sendUnansweredCalls: {
-        enabled: true,
-        numberOfRings: 3,
-    },
-    notifications: {
-        enabled: true,
-        destination: dummyEmail,
-    },
-    emailCopyOfMessage: {
-        enabled: true,
-        emailId: dummyEmail,
-    },
-    messageStorage: {
-        mwiEnabled: true,
-        storageType: 'INTERNAL',
-        externalEmail: dummyEmail,
-    },
-    voiceMessageForwardingEnabled: false,
-};
+export const xsiEndpointUrlResponse = {
+    items: [
+        {
+            id: 'Y2lzY',
+            displayName: 'Atlas_Test_WxC_SI_AS10_VAR_WebrtcMobius_DND',
+            created: '2022-03-16T11:20:04.561Z',
+            xsiDomain: 'api-proxy-si.net',
+            xsiActionsEndpoint: 'https://api-proxy-si.broadcloudpbx.net/com.broadsoft.xsi-actions',
+            xsiEventsEndpoint: 'https://api-proxy-si.broadcloudpbx.net/com.broadsoft.xsi-events',
+            xsiEventsChannelEndpoint: 'https://api-proxy-si.broadcloudpbx.net/com.broadsoft.async/com.broadsoft.xsi-events',
+        },
+    ],
+};
+export const callForwardPayload = {
+    callForwarding: {
+        always: {
+            enabled: true,
+            destination: '123456789',
+            ringReminderEnabled: false,
+            destinationVoicemailEnabled: false,
+        },
+        busy: {
+            enabled: false,
+        },
+        noAnswer: {
+            enabled: true,
+            destination: '123123',
+            numberOfRings: 3,
+        },
+    },
+    businessContinuity: {
+        enabled: false,
+    },
+};
+export const dummyEmail = 'abc@test.com';
+export const voicemailPayload = {
+    enabled: true,
+    sendAllCalls: {
+        enabled: true,
+    },
+    sendBusyCalls: {
+        enabled: true,
+    },
+    sendUnansweredCalls: {
+        enabled: true,
+        numberOfRings: 3,
+    },
+    notifications: {
+        enabled: true,
+        destination: dummyEmail,
+    },
+    emailCopyOfMessage: {
+        enabled: true,
+        emailId: dummyEmail,
+    },
+    messageStorage: {
+        mwiEnabled: true,
+        storageType: 'INTERNAL',
+        externalEmail: dummyEmail,
+    },
+    voiceMessageForwardingEnabled: false,
+};

package/dist/module/CallSettings/types.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/module/CallingClient/CallingClient.js

@@ -1,248 +1,248 @@
-import * as Media from '@webex/internal-media-core';
-import { Mutex } from 'async-mutex';
-import { filterMobiusUris, handleCallingClientErrors, validateServiceData } from '../common/Utils';
-import { LOGGER } from '../Logger/types';
-import SDKConnector from '../SDKConnector';
-import { Eventing } from '../Events/impl';
-import { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../Events/types';
-import { ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, } from '../common/types';
-import log from '../Logger';
-import { getCallManager } from './calling/callManager';
-import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, NETWORK_FLAP_TIMEOUT, } from './constants';
-import Line from './line';
-import { LINE_EVENTS, LineStatus } from './line/types';
-import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
-import { getMetricManager } from '../Metrics';
-export class CallingClient extends Eventing {
-    sdkConnector;
-    webex;
-    mutex;
-    callManager;
-    metricManager;
-    sdkConfig;
-    primaryMobiusUris;
-    backupMobiusUris;
-    mediaEngine;
-    lineDict = {};
-    constructor(webex, config) {
-        super();
-        this.sdkConnector = SDKConnector;
-        if (!this.sdkConnector.getWebex()) {
-            SDKConnector.setWebex(webex);
-        }
-        this.mutex = new Mutex();
-        this.webex = this.sdkConnector.getWebex();
-        this.sdkConfig = config;
-        const serviceData = this.sdkConfig?.serviceData?.indicator
-            ? this.sdkConfig.serviceData
-            : { indicator: ServiceIndicator.CALLING, domain: '' };
-        const logLevel = this.sdkConfig?.logger?.level ? this.sdkConfig.logger.level : LOGGER.ERROR;
-        validateServiceData(serviceData);
-        this.callManager = getCallManager(this.webex, serviceData.indicator);
-        this.metricManager = getMetricManager(this.webex, serviceData.indicator);
-        this.mediaEngine = Media;
-        this.primaryMobiusUris = [];
-        this.backupMobiusUris = [];
-        this.registerSessionsListener();
-        log.setLogger(logLevel, CALLING_CLIENT_FILE);
-        this.registerCallsClearedListener();
-    }
-    async init() {
-        await this.getMobiusServers();
-        await this.createLine();
-        this.detectNetworkChange();
-    }
-    async detectNetworkChange() {
-        let retry = false;
-        const line = Object.values(this.lineDict)[0];
-        setInterval(async () => {
-            if (!this.webex.internal.mercury.connected &&
-                !retry &&
-                !Object.keys(this.callManager.getActiveCalls()).length) {
-                log.warn(`Network has flapped, waiting for mercury connection to be up`, {
-                    file: CALLING_CLIENT_FILE,
-                    method: this.detectNetworkChange.name,
-                });
-                line.lineEmitter(LINE_EVENTS.UNREGISTERED);
-                line.registration.clearKeepaliveTimer();
-                retry = true;
-            }
-            if (retry && this.webex.internal.mercury.connected) {
-                retry = await line.registration.handleConnectionRestoration(retry);
-            }
-        }, NETWORK_FLAP_TIMEOUT);
-    }
-    async getClientRegionInfo() {
-        const regionInfo = {};
-        try {
-            const temp = await this.webex.request({
-                uri: `${this.webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}${IP_ENDPOINT}`,
-                method: HTTP_METHODS.GET,
-                headers: {
-                    [CISCO_DEVICE_URL]: this.webex.internal.device.url,
-                    [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                },
-                service: ALLOWED_SERVICES.MOBIUS,
-            });
-            const myIP = temp.body.ipv4;
-            const response = await this.webex.request({
-                uri: `${DISCOVERY_URL}/${myIP}`,
-                method: HTTP_METHODS.GET,
-                addAuthHeader: false,
-                headers: {
-                    [SPARK_USER_AGENT]: null,
-                },
-            });
-            const clientRegionInfo = response.body;
-            regionInfo.clientRegion = clientRegionInfo?.clientRegion ? clientRegionInfo.clientRegion : '';
-            regionInfo.countryCode = clientRegionInfo?.countryCode ? clientRegionInfo.countryCode : '';
-        }
-        catch (err) {
-            handleCallingClientErrors(err, (clientError) => {
-                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
-                this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
-            }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
-            regionInfo.clientRegion = '';
-            regionInfo.countryCode = '';
-        }
-        return regionInfo;
-    }
-    async getMobiusServers() {
-        let useDefault = false;
-        let clientRegion;
-        let countryCode;
-        if (this.sdkConfig?.discovery?.country && this.sdkConfig?.discovery?.region) {
-            log.info('Updating region and country from the SDK config', {
-                file: CALLING_CLIENT_FILE,
-                method: GET_MOBIUS_SERVERS_UTIL,
-            });
-            clientRegion = this.sdkConfig?.discovery?.region;
-            countryCode = this.sdkConfig?.discovery?.country;
-        }
-        else {
-            log.info('Updating region and country through Region discovery', {
-                file: CALLING_CLIENT_FILE,
-                method: GET_MOBIUS_SERVERS_UTIL,
-            });
-            const regionInfo = await this.getClientRegionInfo();
-            clientRegion = regionInfo.clientRegion;
-            countryCode = regionInfo.countryCode;
-        }
-        if (clientRegion && countryCode) {
-            log.log(`Found Region: ${clientRegion} and country: ${countryCode}, going to fetch Mobius server`, '');
-            try {
-                const temp = await this.webex.request({
-                    uri: `${this.webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}?regionCode=${clientRegion}&countryCode=${countryCode}`,
-                    method: HTTP_METHODS.GET,
-                    headers: {
-                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
-                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
-                    },
-                    service: ALLOWED_SERVICES.MOBIUS,
-                });
-                log.log('Mobius Server found for the region', '');
-                const mobiusServers = temp.body;
-                const mobiusUris = filterMobiusUris(mobiusServers, this.webex.internal.services._serviceUrls.mobius);
-                this.primaryMobiusUris = mobiusUris.primary;
-                this.backupMobiusUris = mobiusUris.backup;
-                log.info(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, '');
-            }
-            catch (err) {
-                handleCallingClientErrors(err, (clientError) => {
-                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
-                    this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
-                }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
-                useDefault = true;
-            }
-        }
-        else {
-            useDefault = true;
-        }
-        if (useDefault) {
-            log.warn('Error in finding Mobius Servers. Will use the default URL.', '');
-            this.primaryMobiusUris = [
-                `${this.webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}`,
-            ];
-        }
-    }
-    registerCallsClearedListener() {
-        const logContext = {
-            file: CALLING_CLIENT_FILE,
-            method: this.registerCallsClearedListener.name,
-        };
-        log.log('Registering listener for all calls cleared event', logContext);
-        this.callManager.on(CALLING_CLIENT_EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
-    }
-    callsClearedHandler = async () => {
-        const { registration } = Object.values(this.lineDict)[0];
-        if (!registration.isDeviceRegistered()) {
-            await this.mutex.runExclusive(async () => {
-                if (registration.isReconnectPending()) {
-                    log.log('All calls cleared, reconnecting', {
-                        file: CALLING_CLIENT_FILE,
-                        method: CALLS_CLEARED_HANDLER_UTIL,
-                    });
-                    await registration.reconnectOnFailure(CALLS_CLEARED_HANDLER_UTIL);
-                }
-            });
-        }
-    };
-    getLoggingLevel() {
-        return log.getLogLevel();
-    }
-    getSDKConnector() {
-        return this.sdkConnector;
-    }
-    registerSessionsListener() {
-        this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE, async (event) => {
-            if (event && event.data.userSessions.userSessions) {
-                const sessionArr = event?.data.userSessions.userSessions;
-                if (sessionArr.length === 1) {
-                    if (sessionArr[0].sessionType !== SessionType.WEBEX_CALLING) {
-                        return;
-                    }
-                }
-                for (let i = 0; i < sessionArr.length; i += 1) {
-                    if (sessionArr[i].sessionType !== SessionType.WEBEX_CALLING) {
-                        sessionArr.splice(i, 1);
-                    }
-                }
-                this.emit(CALLING_CLIENT_EVENT_KEYS.USER_SESSION_INFO, event);
-            }
-        });
-    }
-    async createLine() {
-        const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, LineStatus.INACTIVE, this.mutex, this.primaryMobiusUris, this.backupMobiusUris, this.getLoggingLevel(), this.sdkConfig?.serviceData);
-        this.lineDict[line.lineId] = line;
-    }
-    getLines() {
-        return this.lineDict;
-    }
-    getActiveCalls() {
-        const activeCalls = {};
-        const calls = this.callManager.getActiveCalls();
-        Object.keys(calls).forEach((correlationId) => {
-            const call = calls[correlationId];
-            if (!activeCalls[call.lineId]) {
-                activeCalls[call.lineId] = [];
-            }
-            activeCalls[call.lineId].push(call);
-        });
-        return activeCalls;
-    }
-    getConnectedCall() {
-        let connectCall;
-        const calls = this.callManager.getActiveCalls();
-        Object.keys(calls).forEach((correlationId) => {
-            if (calls[correlationId].isConnected() && !calls[correlationId].isHeld()) {
-                connectCall = calls[correlationId];
-            }
-        });
-        return connectCall;
-    }
-}
-export const createClient = async (webex, config) => {
-    const callingClientInstance = new CallingClient(webex, config);
-    await callingClientInstance.init();
-    return callingClientInstance;
-};
+import * as Media from '@webex/internal-media-core';
+import { Mutex } from 'async-mutex';
+import { filterMobiusUris, handleCallingClientErrors, validateServiceData } from '../common/Utils';
+import { LOGGER } from '../Logger/types';
+import SDKConnector from '../SDKConnector';
+import { Eventing } from '../Events/impl';
+import { MOBIUS_EVENT_KEYS, SessionType, CALLING_CLIENT_EVENT_KEYS, } from '../Events/types';
+import { ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, } from '../common/types';
+import log from '../Logger';
+import { getCallManager } from './calling/callManager';
+import { CALLING_CLIENT_FILE, CALLS_CLEARED_HANDLER_UTIL, CALLING_USER_AGENT, CISCO_DEVICE_URL, DISCOVERY_URL, GET_MOBIUS_SERVERS_UTIL, IP_ENDPOINT, SPARK_USER_AGENT, URL_ENDPOINT, NETWORK_FLAP_TIMEOUT, } from './constants';
+import Line from './line';
+import { LINE_EVENTS, LineStatus } from './line/types';
+import { METRIC_EVENT, REG_ACTION, METRIC_TYPE } from '../Metrics/types';
+import { getMetricManager } from '../Metrics';
+export class CallingClient extends Eventing {
+    sdkConnector;
+    webex;
+    mutex;
+    callManager;
+    metricManager;
+    sdkConfig;
+    primaryMobiusUris;
+    backupMobiusUris;
+    mediaEngine;
+    lineDict = {};
+    constructor(webex, config) {
+        super();
+        this.sdkConnector = SDKConnector;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.mutex = new Mutex();
+        this.webex = this.sdkConnector.getWebex();
+        this.sdkConfig = config;
+        const serviceData = this.sdkConfig?.serviceData?.indicator
+            ? this.sdkConfig.serviceData
+            : { indicator: ServiceIndicator.CALLING, domain: '' };
+        const logLevel = this.sdkConfig?.logger?.level ? this.sdkConfig.logger.level : LOGGER.ERROR;
+        validateServiceData(serviceData);
+        this.callManager = getCallManager(this.webex, serviceData.indicator);
+        this.metricManager = getMetricManager(this.webex, serviceData.indicator);
+        this.mediaEngine = Media;
+        this.primaryMobiusUris = [];
+        this.backupMobiusUris = [];
+        this.registerSessionsListener();
+        log.setLogger(logLevel, CALLING_CLIENT_FILE);
+        this.registerCallsClearedListener();
+    }
+    async init() {
+        await this.getMobiusServers();
+        await this.createLine();
+        this.detectNetworkChange();
+    }
+    async detectNetworkChange() {
+        let retry = false;
+        const line = Object.values(this.lineDict)[0];
+        setInterval(async () => {
+            if (!this.webex.internal.mercury.connected &&
+                !retry &&
+                !Object.keys(this.callManager.getActiveCalls()).length) {
+                log.warn(`Network has flapped, waiting for mercury connection to be up`, {
+                    file: CALLING_CLIENT_FILE,
+                    method: this.detectNetworkChange.name,
+                });
+                line.lineEmitter(LINE_EVENTS.UNREGISTERED);
+                line.registration.clearKeepaliveTimer();
+                retry = true;
+            }
+            if (retry && this.webex.internal.mercury.connected) {
+                retry = await line.registration.handleConnectionRestoration(retry);
+            }
+        }, NETWORK_FLAP_TIMEOUT);
+    }
+    async getClientRegionInfo() {
+        const regionInfo = {};
+        try {
+            const temp = await this.webex.request({
+                uri: `${this.webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}${IP_ENDPOINT}`,
+                method: HTTP_METHODS.GET,
+                headers: {
+                    [CISCO_DEVICE_URL]: this.webex.internal.device.url,
+                    [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+                },
+                service: ALLOWED_SERVICES.MOBIUS,
+            });
+            const myIP = temp.body.ipv4;
+            const response = await this.webex.request({
+                uri: `${DISCOVERY_URL}/${myIP}`,
+                method: HTTP_METHODS.GET,
+                addAuthHeader: false,
+                headers: {
+                    [SPARK_USER_AGENT]: null,
+                },
+            });
+            const clientRegionInfo = response.body;
+            regionInfo.clientRegion = clientRegionInfo?.clientRegion ? clientRegionInfo.clientRegion : '';
+            regionInfo.countryCode = clientRegionInfo?.countryCode ? clientRegionInfo.countryCode : '';
+        }
+        catch (err) {
+            handleCallingClientErrors(err, (clientError) => {
+                this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
+                this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
+            }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+            regionInfo.clientRegion = '';
+            regionInfo.countryCode = '';
+        }
+        return regionInfo;
+    }
+    async getMobiusServers() {
+        let useDefault = false;
+        let clientRegion;
+        let countryCode;
+        if (this.sdkConfig?.discovery?.country && this.sdkConfig?.discovery?.region) {
+            log.info('Updating region and country from the SDK config', {
+                file: CALLING_CLIENT_FILE,
+                method: GET_MOBIUS_SERVERS_UTIL,
+            });
+            clientRegion = this.sdkConfig?.discovery?.region;
+            countryCode = this.sdkConfig?.discovery?.country;
+        }
+        else {
+            log.info('Updating region and country through Region discovery', {
+                file: CALLING_CLIENT_FILE,
+                method: GET_MOBIUS_SERVERS_UTIL,
+            });
+            const regionInfo = await this.getClientRegionInfo();
+            clientRegion = regionInfo.clientRegion;
+            countryCode = regionInfo.countryCode;
+        }
+        if (clientRegion && countryCode) {
+            log.log(`Found Region: ${clientRegion} and country: ${countryCode}, going to fetch Mobius server`, '');
+            try {
+                const temp = await this.webex.request({
+                    uri: `${this.webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}?regionCode=${clientRegion}&countryCode=${countryCode}`,
+                    method: HTTP_METHODS.GET,
+                    headers: {
+                        [CISCO_DEVICE_URL]: this.webex.internal.device.url,
+                        [SPARK_USER_AGENT]: CALLING_USER_AGENT,
+                    },
+                    service: ALLOWED_SERVICES.MOBIUS,
+                });
+                log.log('Mobius Server found for the region', '');
+                const mobiusServers = temp.body;
+                const mobiusUris = filterMobiusUris(mobiusServers, this.webex.internal.services._serviceUrls.mobius);
+                this.primaryMobiusUris = mobiusUris.primary;
+                this.backupMobiusUris = mobiusUris.backup;
+                log.info(`Final list of Mobius Servers, primary: ${mobiusUris.primary} and backup: ${mobiusUris.backup}`, '');
+            }
+            catch (err) {
+                handleCallingClientErrors(err, (clientError) => {
+                    this.metricManager.submitRegistrationMetric(METRIC_EVENT.REGISTRATION_ERROR, REG_ACTION.REGISTER, METRIC_TYPE.BEHAVIORAL, clientError);
+                    this.emit(CALLING_CLIENT_EVENT_KEYS.ERROR, clientError);
+                }, { method: GET_MOBIUS_SERVERS_UTIL, file: CALLING_CLIENT_FILE });
+                useDefault = true;
+            }
+        }
+        else {
+            useDefault = true;
+        }
+        if (useDefault) {
+            log.warn('Error in finding Mobius Servers. Will use the default URL.', '');
+            this.primaryMobiusUris = [
+                `${this.webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}`,
+            ];
+        }
+    }
+    registerCallsClearedListener() {
+        const logContext = {
+            file: CALLING_CLIENT_FILE,
+            method: this.registerCallsClearedListener.name,
+        };
+        log.log('Registering listener for all calls cleared event', logContext);
+        this.callManager.on(CALLING_CLIENT_EVENT_KEYS.ALL_CALLS_CLEARED, this.callsClearedHandler);
+    }
+    callsClearedHandler = async () => {
+        const { registration } = Object.values(this.lineDict)[0];
+        if (!registration.isDeviceRegistered()) {
+            await this.mutex.runExclusive(async () => {
+                if (registration.isReconnectPending()) {
+                    log.log('All calls cleared, reconnecting', {
+                        file: CALLING_CLIENT_FILE,
+                        method: CALLS_CLEARED_HANDLER_UTIL,
+                    });
+                    await registration.reconnectOnFailure(CALLS_CLEARED_HANDLER_UTIL);
+                }
+            });
+        }
+    };
+    getLoggingLevel() {
+        return log.getLogLevel();
+    }
+    getSDKConnector() {
+        return this.sdkConnector;
+    }
+    registerSessionsListener() {
+        this.sdkConnector.registerListener(MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE, async (event) => {
+            if (event && event.data.userSessions.userSessions) {
+                const sessionArr = event?.data.userSessions.userSessions;
+                if (sessionArr.length === 1) {
+                    if (sessionArr[0].sessionType !== SessionType.WEBEX_CALLING) {
+                        return;
+                    }
+                }
+                for (let i = 0; i < sessionArr.length; i += 1) {
+                    if (sessionArr[i].sessionType !== SessionType.WEBEX_CALLING) {
+                        sessionArr.splice(i, 1);
+                    }
+                }
+                this.emit(CALLING_CLIENT_EVENT_KEYS.USER_SESSION_INFO, event);
+            }
+        });
+    }
+    async createLine() {
+        const line = new Line(this.webex.internal.device.userId, this.webex.internal.device.url, LineStatus.INACTIVE, this.mutex, this.primaryMobiusUris, this.backupMobiusUris, this.getLoggingLevel(), this.sdkConfig?.serviceData);
+        this.lineDict[line.lineId] = line;
+    }
+    getLines() {
+        return this.lineDict;
+    }
+    getActiveCalls() {
+        const activeCalls = {};
+        const calls = this.callManager.getActiveCalls();
+        Object.keys(calls).forEach((correlationId) => {
+            const call = calls[correlationId];
+            if (!activeCalls[call.lineId]) {
+                activeCalls[call.lineId] = [];
+            }
+            activeCalls[call.lineId].push(call);
+        });
+        return activeCalls;
+    }
+    getConnectedCall() {
+        let connectCall;
+        const calls = this.callManager.getActiveCalls();
+        Object.keys(calls).forEach((correlationId) => {
+            if (calls[correlationId].isConnected() && !calls[correlationId].isHeld()) {
+                connectCall = calls[correlationId];
+            }
+        });
+        return connectCall;
+    }
+}
+export const createClient = async (webex, config) => {
+    const callingClientInstance = new CallingClient(webex, config);
+    await callingClientInstance.init();
+    return callingClientInstance;
+};