@webex/calling 0.0.1-next.0

package/dist/module/CallSettings/WxCallBackendConnector.js

@@ -0,0 +1,287 @@
+import SDKConnector from '../SDKConnector';
+import log from '../Logger';
+import { HTTP_METHODS, DecodeType, CALLING_BACKEND } from '../common/types';
+import { SERVICES_ENDPOINT, STATUS_CODE, SUCCESS_MESSAGE, XML_TYPE, WEBEX_CALLING_CONNECTOR_FILE, } from '../common/constants';
+import { CALL_SETTINGS_FILE, CALL_WAITING_ENDPOINT, CF_ENDPOINT, DND_ENDPOINT, ORG_ENDPOINT, PEOPLE_ENDPOINT, USER_ENDPOINT, VM_ENDPOINT, XSI_VERSION, } from './constants';
+import { getXsiActionEndpoint, inferIdFromUuid, serviceErrorCodeHandler } from '../common/Utils';
+export class WxCallBackendConnector {
+    sdkConnector;
+    webex;
+    userId;
+    personId;
+    orgId;
+    xsiEndpoint;
+    hydraEndpoint;
+    VOICEMAIL = 'VOICEMAIL';
+    constructor(webex, logger) {
+        this.sdkConnector = SDKConnector;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.webex = this.sdkConnector.getWebex();
+        this.hydraEndpoint = this.webex.internal.services._serviceUrls.hydra;
+        log.setLogger(logger.level, WEBEX_CALLING_CONNECTOR_FILE);
+        this.userId = this.webex.internal.device.userId;
+        this.personId = inferIdFromUuid(this.webex.internal.device.userId, DecodeType.PEOPLE);
+        this.orgId = inferIdFromUuid(this.webex.internal.device.orgId, DecodeType.ORGANIZATION);
+    }
+    async getCallWaitingSetting() {
+        const loggerContext = {
+            file: CALL_SETTINGS_FILE,
+            method: 'getCallWaitingSetting',
+        };
+        try {
+            if (!this.xsiEndpoint) {
+                this.xsiEndpoint = await getXsiActionEndpoint(this.webex, loggerContext, CALLING_BACKEND.WXC);
+                log.info(`xsiEndpoint: ${this.xsiEndpoint}`, loggerContext);
+            }
+            const callWaitingUrl = `${this.xsiEndpoint}/${XSI_VERSION}/${USER_ENDPOINT}/${this.userId}/${SERVICES_ENDPOINT}/${CALL_WAITING_ENDPOINT}`;
+            const response = await fetch(`${callWaitingUrl}`, {
+                method: HTTP_METHODS.GET,
+                headers: {
+                    Authorization: await this.webex.credentials.getUserToken(),
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`${response.status}`);
+            }
+            const xmlData = await response.text();
+            const parser = new DOMParser();
+            const xmlDOM = parser.parseFromString(xmlData, XML_TYPE);
+            const callWaitingDetails = xmlDOM.getElementsByTagName('active');
+            const status = callWaitingDetails[0].childNodes[0].textContent;
+            const toggleSetting = {
+                enabled: status === 'true',
+            };
+            const responseDetails = {
+                statusCode: 200,
+                data: {
+                    callSetting: toggleSetting,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = {
+                statusCode: err instanceof Error ? Number(err.message) : '',
+            };
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getDoNotDisturbSetting() {
+        const loggerContext = {
+            file: CALL_SETTINGS_FILE,
+            method: 'getDoNotDisturbSetting',
+        };
+        try {
+            const resp = await this.webex.request({
+                uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${DND_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
+                method: HTTP_METHODS.GET,
+            });
+            const dndSettingResponse = resp.body;
+            const responseDetails = {
+                statusCode: Number(resp[STATUS_CODE]),
+                data: {
+                    callSetting: dndSettingResponse,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async setDoNotDisturbSetting(enabled) {
+        const loggerContext = {
+            file: CALL_SETTINGS_FILE,
+            method: 'setDoNotDisturbSetting',
+        };
+        try {
+            const dndRequestBody = {
+                enabled,
+                ringSplashEnabled: false,
+            };
+            const resp = await this.webex.request({
+                uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${DND_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
+                method: HTTP_METHODS.PUT,
+                body: dndRequestBody,
+            });
+            const responseDetails = {
+                statusCode: Number(resp[STATUS_CODE]),
+                data: {
+                    callSetting: dndRequestBody,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getCallForwardSetting() {
+        const loggerContext = {
+            file: CALL_SETTINGS_FILE,
+            method: 'getCallForwardingSetting',
+        };
+        try {
+            const resp = await this.webex.request({
+                uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${CF_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
+                method: HTTP_METHODS.GET,
+            });
+            const cfResponse = resp.body;
+            const responseDetails = {
+                statusCode: Number(resp[STATUS_CODE]),
+                data: {
+                    callSetting: cfResponse,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async setCallForwardSetting(callForwardingRequest) {
+        const loggerContext = {
+            file: CALL_SETTINGS_FILE,
+            method: 'setCallForwardingSetting',
+        };
+        try {
+            const resp = await this.webex.request({
+                uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${CF_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
+                method: HTTP_METHODS.PUT,
+                body: callForwardingRequest,
+            });
+            const responseDetails = {
+                statusCode: Number(resp[STATUS_CODE]),
+                data: {
+                    callSetting: callForwardingRequest,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getVoicemailSetting() {
+        const loggerContext = {
+            file: CALL_SETTINGS_FILE,
+            method: 'getVoicemailSetting',
+        };
+        try {
+            const resp = await this.webex.request({
+                uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${VM_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
+                method: HTTP_METHODS.GET,
+            });
+            const vmResponse = resp.body;
+            const responseDetails = {
+                statusCode: Number(resp[STATUS_CODE]),
+                data: {
+                    callSetting: vmResponse,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async setVoicemailSetting(voicemailRequest) {
+        const loggerContext = {
+            file: CALL_SETTINGS_FILE,
+            method: 'setVoicemailSetting',
+        };
+        try {
+            const resp = await this.webex.request({
+                uri: `${this.hydraEndpoint}/${PEOPLE_ENDPOINT}/${this.personId}/${VM_ENDPOINT}?${ORG_ENDPOINT}=${this.orgId}`,
+                method: HTTP_METHODS.PUT,
+                body: voicemailRequest,
+            });
+            const responseDetails = {
+                statusCode: Number(resp[STATUS_CODE]),
+                data: {
+                    callSetting: voicemailRequest,
+                },
+                message: SUCCESS_MESSAGE,
+            };
+            return responseDetails;
+        }
+        catch (err) {
+            const errorInfo = err;
+            const errorStatus = serviceErrorCodeHandler(errorInfo, loggerContext);
+            return errorStatus;
+        }
+    }
+    async getCallForwardAlwaysSetting() {
+        const loggerContext = {
+            file: WEBEX_CALLING_CONNECTOR_FILE,
+            method: this.getCallForwardAlwaysSetting.name,
+        };
+        const cfResponse = await this.getCallForwardSetting();
+        if (cfResponse.statusCode === 200) {
+            const cfa = cfResponse.data.callSetting.callForwarding.always;
+            if (cfa.enabled) {
+                if (cfa.destination) {
+                    const response = {
+                        ...cfResponse,
+                        data: {
+                            callSetting: cfa,
+                        },
+                    };
+                    return response;
+                }
+                log.warn(`CFA is enabled, but destination is not set`, loggerContext);
+            }
+            const vmResponse = await this.getVoicemailSetting();
+            if (vmResponse.statusCode === 200) {
+                const vm = vmResponse.data.callSetting;
+                if (vm.enabled && vm.sendAllCalls.enabled) {
+                    const response = {
+                        ...cfResponse,
+                        data: {
+                            callSetting: {
+                                ...cfa,
+                                enabled: true,
+                                destination: this.VOICEMAIL,
+                            },
+                        },
+                    };
+                    return response;
+                }
+                const response = {
+                    ...cfResponse,
+                    data: {
+                        callSetting: {
+                            ...cfa,
+                            enabled: false,
+                            destination: undefined,
+                        },
+                    },
+                };
+                return response;
+            }
+            log.warn(`Unable to retrieve voicemail settings.`, loggerContext);
+            vmResponse.data.error = 'Unable to retrieve voicemail settings.';
+            return vmResponse;
+        }
+        return cfResponse;
+    }
+}

package/dist/module/CallSettings/constants.js

@@ -0,0 +1,11 @@
+export const CALL_SETTINGS_FILE = 'CallSettings';
+export const PEOPLE_ENDPOINT = 'people';
+export const USER_ENDPOINT = 'user';
+export const ORG_ENDPOINT = 'orgId';
+export const DND_ENDPOINT = 'features/doNotDisturb';
+export const CF_ENDPOINT = 'features/callForwarding';
+export const VM_ENDPOINT = 'features/voicemail';
+export const CALL_WAITING_ENDPOINT = 'CallWaiting';
+export const XSI_VERSION = 'v2.0';
+export const WEBEX_APIS_INT_URL = 'https://integration.webexapis.com/v1/uc/config';
+export const WEBEX_APIS_PROD_URL = 'https://webexapis.com/v1/uc/config';

package/dist/module/CallSettings/testFixtures.js

@@ -0,0 +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,
+};

package/dist/module/CallSettings/types.js

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

package/dist/module/CallingClient/CallingClient.js

@@ -0,0 +1,268 @@
+import * as Media from '@webex/internal-media-core';
+import { Mutex } from 'async-mutex';
+import { filterMobiusUris, handleCallingClientErrors, validateServiceData } from '../common/Utils';
+import { ERROR_TYPE } from '../Errors/types';
+import { LOGGER } from '../Logger/types';
+import SDKConnector from '../SDKConnector';
+import { Eventing } from '../Events/impl';
+import { EVENT_KEYS, MOBIUS_EVENT_KEYS, SessionType, } from '../Events/types';
+import { MobiusStatus, CallDirection, ServiceIndicator, ALLOWED_SERVICES, HTTP_METHODS, } from '../common/types';
+import log from '../Logger';
+import { getCallManager } from './calling/callManager';
+import { CALLING_CLIENT_FILE, VALID_PHONE, 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 { CallingClientError } from '../Errors';
+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.incomingCallListener();
+        this.registerCallsClearedListener();
+    }
+    async init() {
+        await this.getMobiusServers();
+        await this.createLine();
+        this.detectNetworkChange();
+    }
+    incomingCallListener() {
+        const logContext = {
+            file: CALLING_CLIENT_FILE,
+            method: this.incomingCallListener.name,
+        };
+        log.log('Listening for incoming calls... ', logContext);
+        this.callManager.on(EVENT_KEYS.INCOMING_CALL, (callObj) => {
+            this.emit(EVENT_KEYS.INCOMING_CALL, callObj);
+        });
+    }
+    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(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(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(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();
+    }
+    getCall = (correlationId) => {
+        return this.callManager.getCall(correlationId);
+    };
+    makeCall = (dest) => {
+        let call;
+        const { registration } = Object.values(this.lineDict)[0];
+        if (dest) {
+            const match = dest.address.match(VALID_PHONE);
+            if (match && match[0].length === dest.address.length) {
+                const sanitizedNumber = dest.address
+                    .replace(/[^[*+]\d#]/gi, '')
+                    .replace(/\s+/gi, '')
+                    .replace(/-/gi, '');
+                const formattedDest = {
+                    type: dest.type,
+                    address: `tel:${sanitizedNumber}`,
+                };
+                call = this.callManager.createCall(formattedDest, CallDirection.OUTBOUND, registration.getDeviceInfo().device?.deviceId);
+                log.log(`New call created, callId: ${call.getCallId()}`, {});
+            }
+            else {
+                log.warn('Invalid phone number detected', {});
+                const err = new CallingClientError('An invalid phone number was detected. Check the number and try again.', {}, ERROR_TYPE.CALL_ERROR, MobiusStatus.ACTIVE);
+                this.emit(EVENT_KEYS.ERROR, err);
+            }
+            return call;
+        }
+        return undefined;
+    };
+    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(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;
+    }
+}
+export const createClient = async (webex, config) => {
+    const callingClientInstance = new CallingClient(webex, config);
+    await callingClientInstance.init();
+    return callingClientInstance;
+};