@webex/calling 0.0.1-next.0

package/dist/module/CallingClient/calling/callManager.js

@@ -0,0 +1,274 @@
+import { CALL_MANAGER_FILE } from '../constants';
+import { EVENT_KEYS } from '../../Events/types';
+import { Eventing } from '../../Events/impl';
+import SDKConnector from '../../SDKConnector';
+import { CallDirection } from '../../common/types';
+import { MediaState, MobiusEventType, } from './types';
+import { createCall } from './call';
+import log from '../../Logger';
+let callManager;
+export class CallManager extends Eventing {
+    sdkConnector;
+    webex;
+    callCollection;
+    activeMobiusUrl;
+    serviceIndicator;
+    constructor(webex, indicator) {
+        super();
+        this.sdkConnector = SDKConnector;
+        this.serviceIndicator = indicator;
+        if (!this.sdkConnector.getWebex()) {
+            SDKConnector.setWebex(webex);
+        }
+        this.webex = this.sdkConnector.getWebex();
+        this.callCollection = {};
+        this.activeMobiusUrl = '';
+        this.listenForWsEvents();
+    }
+    createCall = (destination, direction, deviceId) => {
+        log.log('Creating call object', {});
+        const newCall = createCall(this.activeMobiusUrl, this.webex, destination, direction, deviceId, (correlationId) => {
+            delete this.callCollection[correlationId];
+            const activeCalls = Object.keys(this.getActiveCalls()).length;
+            log.info(`DELETE:: Deleted corelationId: ${newCall.getCorrelationId()} from CallManager, Number of call records :- ${activeCalls}`, {});
+            if (activeCalls === 0) {
+                this.emit(EVENT_KEYS.ALL_CALLS_CLEARED);
+            }
+        }, this.serviceIndicator);
+        this.callCollection[newCall.getCorrelationId()] = newCall;
+        log.log(`New call created with correlationId: ${newCall.getCorrelationId()}`, {});
+        log.info(`ADD:: Added corelationId: ${newCall.getCorrelationId()} to CallManager , Number of call records now:- ${Object.keys(this.getActiveCalls()).length}`, {});
+        return newCall;
+    };
+    updateActiveMobius(url) {
+        this.activeMobiusUrl = url;
+    }
+    listenForWsEvents() {
+        this.sdkConnector.registerListener('event:mobius', async (event) => {
+            this.dequeueWsEvents(event);
+        });
+    }
+    dequeueWsEvents(event) {
+        const mobiusEvent = event;
+        const { callId, correlationId } = mobiusEvent.data;
+        switch (mobiusEvent.data.eventType) {
+            case MobiusEventType.CALL_SETUP: {
+                log.log(`Received call Setup message for call: ${callId}`, {
+                    file: CALL_MANAGER_FILE,
+                    method: 'dequeueWsEvents',
+                });
+                if (mobiusEvent.data.midCallService) {
+                    mobiusEvent.data.midCallService.forEach((midCallEvent) => {
+                        const call = this.getCall(correlationId);
+                        if (call) {
+                            call.handleMidCallEvent(midCallEvent);
+                        }
+                        else {
+                            log.log(`Dropping midcall event of type: ${midCallEvent.eventType} as it doesn't match with any existing call`, {
+                                file: CALL_MANAGER_FILE,
+                                method: 'dequeueWsEvents',
+                            });
+                        }
+                    });
+                    return;
+                }
+                const newId = Object.keys(this.callCollection).find((id) => this.callCollection[id].getCallId() === callId);
+                let newCall;
+                if (!newId) {
+                    newCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId);
+                    log.log(`New incoming call created with correlationId from Call Setup message: ${newCall.getCorrelationId()}`, {
+                        file: CALL_MANAGER_FILE,
+                        method: 'dequeueWsEvents',
+                    });
+                    newCall.setCallId(callId);
+                    if (mobiusEvent.data.broadworksCorrelationInfo) {
+                        log.log(`Found broadworksCorrelationInfo: ${mobiusEvent.data.broadworksCorrelationInfo}`, {
+                            file: CALL_MANAGER_FILE,
+                            method: 'dequeueWsEvents',
+                        });
+                        newCall.setBroadworksCorrelationInfo(mobiusEvent.data.broadworksCorrelationInfo);
+                    }
+                }
+                else {
+                    log.info(`Found the call Object with a matching callId: ${callId} from our records with correlationId: ${newId}`, {
+                        file: CALL_MANAGER_FILE,
+                        method: 'dequeueWsEvents',
+                    });
+                    newCall = this.getCall(newId);
+                }
+                if (mobiusEvent.data.callerId) {
+                    log.info('Processing Caller-Id data', {
+                        file: CALL_MANAGER_FILE,
+                        method: 'dequeueWsEvents',
+                    });
+                    newCall.startCallerIdResolution(mobiusEvent.data.callerId);
+                }
+                this.emit(EVENT_KEYS.INCOMING_CALL, newCall);
+                newCall.sendCallStateMachineEvt({ type: 'E_RECV_CALL_SETUP', data: mobiusEvent.data });
+                break;
+            }
+            case MobiusEventType.CALL_PROGRESS: {
+                log.log(`Received call progress mobiusEvent for call: ${correlationId}`, {
+                    file: CALL_MANAGER_FILE,
+                    method: 'dequeueWsEvents',
+                });
+                const call = this.getCall(correlationId);
+                call.sendCallStateMachineEvt({ type: 'E_RECV_CALL_PROGRESS', data: mobiusEvent.data });
+                break;
+            }
+            case MobiusEventType.CALL_MEDIA: {
+                log.log(`Received call media mobiusEvent for call: ${correlationId}`, {
+                    file: CALL_MANAGER_FILE,
+                    method: 'dequeueWsEvents',
+                });
+                let activeCall;
+                if (correlationId) {
+                    activeCall = this.getCall(correlationId);
+                }
+                else {
+                    const newId = Object.keys(this.callCollection).find((id) => this.callCollection[id].getCallId() === callId);
+                    if (newId) {
+                        log.info(`Found the call Object with a matching callId: ${callId} from our records with correlationId: ${newId}`, {
+                            file: CALL_MANAGER_FILE,
+                            method: 'dequeueWsEvents',
+                        });
+                        activeCall = this.getCall(newId);
+                    }
+                    else {
+                        activeCall = this.createCall({}, CallDirection.INBOUND, mobiusEvent.data.deviceId);
+                        log.log(`New incoming call created with correlationId from ROAP Message: ${activeCall.getCorrelationId()}`, {
+                            file: CALL_MANAGER_FILE,
+                            method: 'dequeueWsEvents',
+                        });
+                        activeCall.setCallId(callId);
+                    }
+                }
+                if (activeCall) {
+                    log.info(`SDP from mobius ${mobiusEvent.data.message?.sdp}`, {
+                        file: CALL_MANAGER_FILE,
+                        method: 'dequeueWsEvents',
+                    });
+                    log.log(`ROAP message from mobius with type:  ${mobiusEvent.data.message?.messageType}, seq: ${mobiusEvent.data.message?.seq} , version: ${mobiusEvent.data.message?.version}`, {
+                        file: CALL_MANAGER_FILE,
+                        method: 'dequeueWsEvents',
+                    });
+                    const mediaState = mobiusEvent.data.message?.messageType;
+                    switch (mediaState) {
+                        case MediaState.OFFER: {
+                            log.log('Received OFFER', {
+                                file: CALL_MANAGER_FILE,
+                                method: 'dequeueWsEvents',
+                            });
+                            activeCall.sendMediaStateMachineEvt({
+                                type: 'E_RECV_ROAP_OFFER',
+                                data: mobiusEvent.data.message,
+                            });
+                            break;
+                        }
+                        case MediaState.ANSWER: {
+                            log.log('Received ANSWER', {
+                                file: CALL_MANAGER_FILE,
+                                method: 'dequeueWsEvents',
+                            });
+                            activeCall.sendMediaStateMachineEvt({
+                                type: 'E_RECV_ROAP_ANSWER',
+                                data: mobiusEvent.data.message,
+                            });
+                            break;
+                        }
+                        case MediaState.OFFER_REQUEST: {
+                            log.log('Received OFFER_REQUEST', {
+                                file: CALL_MANAGER_FILE,
+                                method: 'dequeueWsEvents',
+                            });
+                            activeCall.sendMediaStateMachineEvt({
+                                type: 'E_RECV_ROAP_OFFER_REQUEST',
+                                data: mobiusEvent.data.message,
+                            });
+                            break;
+                        }
+                        case MediaState.OK: {
+                            log.log('Received OK', {
+                                file: CALL_MANAGER_FILE,
+                                method: 'dequeueWsEvents',
+                            });
+                            const mediaOk = {
+                                received: true,
+                                message: mobiusEvent.data.message,
+                            };
+                            activeCall.sendMediaStateMachineEvt({
+                                type: 'E_ROAP_OK',
+                                data: mediaOk,
+                            });
+                            break;
+                        }
+                        case MediaState.ERROR: {
+                            log.log('Received Error...', {
+                                file: CALL_MANAGER_FILE,
+                                method: 'dequeueWsEvents',
+                            });
+                            break;
+                        }
+                        default: {
+                            log.log(`Unknown Media mobiusEvent: ${mediaState} `, {
+                                file: CALL_MANAGER_FILE,
+                                method: 'dequeueWsEvents',
+                            });
+                        }
+                    }
+                }
+                else {
+                    log.log(`CorrelationId: ${correlationId} doesn't exist , discarding..`, {
+                        file: CALL_MANAGER_FILE,
+                        method: 'dequeueWsEvents',
+                    });
+                }
+                break;
+            }
+            case MobiusEventType.CALL_CONNECTED: {
+                log.log(`Received call connect for call: ${correlationId}`, {
+                    file: CALL_MANAGER_FILE,
+                    method: 'dequeueWsEvents',
+                });
+                const call = this.getCall(correlationId);
+                call.sendCallStateMachineEvt({ type: 'E_RECV_CALL_CONNECT', data: mobiusEvent.data });
+                break;
+            }
+            case MobiusEventType.CALL_DISCONNECTED: {
+                log.log(`Received call disconnect for call: ${correlationId}`, {
+                    file: CALL_MANAGER_FILE,
+                    method: 'dequeueWsEvents',
+                });
+                const call = this.getCall(correlationId);
+                if (call) {
+                    call.sendCallStateMachineEvt({ type: 'E_RECV_CALL_DISCONNECT' });
+                }
+                break;
+            }
+            default: {
+                log.log(`Unknown Call Event mobiusEvent: ${mobiusEvent.data.eventType}`, {
+                    file: CALL_MANAGER_FILE,
+                    method: 'dequeueWsEvents',
+                });
+            }
+        }
+    }
+    endCall = (correlationId) => {
+        const call = this.getCall(correlationId);
+        if (call) {
+            call.end();
+        }
+    };
+    getCall = (correlationId) => {
+        return this.callCollection[correlationId];
+    };
+    getActiveCalls = () => {
+        return this.callCollection;
+    };
+}
+export const getCallManager = (webex, indicator) => {
+    if (!callManager) {
+        callManager = new CallManager(webex, indicator);
+    }
+    return callManager;
+};

package/dist/module/CallingClient/calling/index.js

@@ -0,0 +1,2 @@
+export * from './call';
+export * from './callManager';

package/dist/module/CallingClient/calling/types.js

@@ -0,0 +1,53 @@
+export var MobiusEventType;
+(function (MobiusEventType) {
+    MobiusEventType["CALL_SETUP"] = "mobius.call";
+    MobiusEventType["CALL_PROGRESS"] = "mobius.callprogress";
+    MobiusEventType["CALL_CONNECTED"] = "mobius.callconnected";
+    MobiusEventType["CALL_MEDIA"] = "mobius.media";
+    MobiusEventType["CALL_DISCONNECTED"] = "mobius.calldisconnected";
+})(MobiusEventType || (MobiusEventType = {}));
+export var MediaState;
+(function (MediaState) {
+    MediaState["OFFER"] = "OFFER";
+    MediaState["ANSWER"] = "ANSWER";
+    MediaState["OFFER_REQUEST"] = "OFFER_REQUEST";
+    MediaState["OK"] = "OK";
+    MediaState["ERROR"] = "ERROR";
+})(MediaState || (MediaState = {}));
+export var DisconnectCode;
+(function (DisconnectCode) {
+    DisconnectCode[DisconnectCode["BUSY"] = 115] = "BUSY";
+    DisconnectCode[DisconnectCode["NORMAL"] = 0] = "NORMAL";
+    DisconnectCode[DisconnectCode["MEDIA_INACTIVITY"] = 131] = "MEDIA_INACTIVITY";
+})(DisconnectCode || (DisconnectCode = {}));
+export var DisconnectCause;
+(function (DisconnectCause) {
+    DisconnectCause["BUSY"] = "User Busy.";
+    DisconnectCause["NORMAL"] = "Normal Disconnect.";
+    DisconnectCause["MEDIA_INACTIVITY"] = "Media Inactivity.";
+})(DisconnectCause || (DisconnectCause = {}));
+export var MidCallEventType;
+(function (MidCallEventType) {
+    MidCallEventType["CALL_INFO"] = "callInfo";
+    MidCallEventType["CALL_STATE"] = "callState";
+})(MidCallEventType || (MidCallEventType = {}));
+export var RoapScenario;
+(function (RoapScenario) {
+    RoapScenario["ANSWER"] = "ANSWER";
+    RoapScenario["OK"] = "OK";
+    RoapScenario["OFFER"] = "OFFER";
+    RoapScenario["ERROR"] = "ERROR";
+    RoapScenario["OFFER_RESPONSE"] = "OFFER_RESPONSE";
+})(RoapScenario || (RoapScenario = {}));
+export var MobiusCallState;
+(function (MobiusCallState) {
+    MobiusCallState["PROCEEDING"] = "sig_proceeding";
+    MobiusCallState["PROGRESS"] = "sig_progress";
+    MobiusCallState["ALERTING"] = "sig_alerting";
+    MobiusCallState["CONNECTED"] = "sig_connected";
+})(MobiusCallState || (MobiusCallState = {}));
+export var TransferType;
+(function (TransferType) {
+    TransferType["BLIND"] = "BLIND";
+    TransferType["CONSULT"] = "CONSULT";
+})(TransferType || (TransferType = {}));

package/dist/module/CallingClient/callingClientFixtures.js

@@ -0,0 +1,38 @@
+import { getMobiusDiscoveryResponse, getTestUtilsWebex } from '../common/testUtil';
+import { URL_ENDPOINT } from './constants';
+import { mockPostResponse } from './registration/registerFixtures';
+const webex = getTestUtilsWebex();
+const mockIPReturnBody = {
+    ipv4: '1.1.1.1',
+    ipv6: '2.2.2.2',
+};
+const ipPayload = {
+    statusCode: 200,
+    body: mockIPReturnBody,
+};
+const regionBody = {
+    attribution: 'This product includes GeoLite2 data created by MaxMind, available from http://www.maxmind.com',
+    clientAddress: '72.163.220.6',
+    clientRegion: 'AP-SOUTHEAST',
+    countryCode: 'IN',
+    disclaimer: 'This service is intended for use by Webex Team only. Unauthorized use is prohibited.',
+    regionCode: 'AP-SOUTHEAST',
+    timezone: 'Asia/Kolkata',
+};
+const regionPayload = {
+    statusCode: 200,
+    body: regionBody,
+};
+const discoveryBody = getMobiusDiscoveryResponse();
+const primaryUrl = `${discoveryBody.primary.uris[0]}/calling/web/`;
+const discoveryPayload = {
+    statusCode: 200,
+    body: discoveryBody,
+};
+const registrationPayload = {
+    statusCode: 200,
+    body: mockPostResponse,
+};
+const uri = `${webex.internal.services._serviceUrls.mobius}${URL_ENDPOINT}`;
+const myIP = mockIPReturnBody.ipv4;
+export { ipPayload, regionBody, regionPayload, primaryUrl, discoveryPayload, registrationPayload, uri, myIP, };

package/dist/module/CallingClient/constants.js

@@ -0,0 +1,122 @@
+export const VERSION = '1.71.1';
+export const REPO_NAME = 'web-calling-sdk';
+export const CALLING_FEATURE = 'web-calling';
+export const CALLING_USER_AGENT = `${REPO_NAME}/${VERSION} (${CALLING_FEATURE})`;
+export const CALL_ENDPOINT_RESOURCE = 'call';
+export const CALL_STATUS_RESOURCE = 'status';
+export const CALLS_ENDPOINT_RESOURCE = 'calls';
+export const CISCO_DEVICE_URL = 'cisco-device-url';
+export const CRLF = '\r\n';
+export const DEFAULT_KEEPALIVE_INTERVAL = 30;
+export const DEFAULT_LOCAL_CALL_ID = 'DefaultLocalId';
+export const DEFAULT_REHOMING_INTERVAL_MAX = 120;
+export const DEFAULT_REHOMING_INTERVAL_MIN = 60;
+export const DEFAULT_SESSION_TIMER = 1000 * 60 * 10;
+export const DEVICES_ENDPOINT_RESOURCE = 'devices';
+export const DISCOVERY_URL = 'https://ds.ciscospark.com/v1/region';
+export const DUMMY_METRICS = {
+    'rtp-rxstat': {
+        Dur: 0,
+        Pkt: 0,
+        Oct: 0,
+        LatePkt: 0,
+        LostPkt: 0,
+        AvgJit: 0,
+        VQMetrics: {
+            VoRxCodec: 'unknown',
+            VoPktSizeMs: 0,
+            maxJitter: 0,
+            VoOneWayDelayMs: 0,
+            networkType: 'unknown',
+            hwType: 'unknown',
+        },
+    },
+    'rtp-txstat': {
+        Dur: 0,
+        Pkt: 0,
+        Oct: 0,
+        VQMetrics: {
+            VoTxCodec: 'unknown',
+            rtpBitRate: 0,
+        },
+    },
+};
+export const DUMMY_MOBIUS_URL = 'https://mobius.aintgen-a-1.int.infra.webex.com/api/v1';
+export const FETCH_NAME = /^[a-zA-Z ]+/;
+export const IDENTITY_BROKER = 'https://identitybts.webex.com/';
+export const IP_ENDPOINT = 'myip';
+export const IDENTITY_ENDPOINT_RESOURCE = 'identity';
+export const INITIAL_SEQ_NUMBER = 1;
+export const MEDIA_ENDPOINT_RESOURCE = 'media';
+export const NETWORK_FLAP_TIMEOUT = 2000;
+export const CALL_HOLD_SERVICE = 'callhold';
+export const CALL_TRANSFER_SERVICE = 'calltransfer';
+export const HOLD_ENDPOINT = 'hold';
+export const TRANSFER_ENDPOINT = 'commit';
+export const RESUME_ENDPOINT = 'resume';
+export const SCIM_ENDPOINT_RESOURCE = 'scim';
+export const SCIM_USER_FILTER = 'v1/Users?filter=';
+export const SPARK_USER_AGENT = 'spark-user-agent';
+export const REGISTER_RETRY_TIMEOUT = 10000;
+export const SUPPLEMENTARY_SERVICES_TIMEOUT = 10000;
+export const URL_ENDPOINT = '/calling/web/';
+export const VALID_PHONE = /[\d\s()*#+.-]+/;
+export const WEB_AGENT = '(web)';
+export const WEBEX = 'webex';
+export const WEBEX_WEB_CLIENT = 'webex-web-client';
+export const CALLER_ID_FILE = 'CallerId';
+export const UTILS_FILE = 'utils';
+export const CALLING_CLIENT_FILE = 'CallingClient';
+export const LINE_FILE = 'line';
+export const CALL_FILE = 'call';
+export const CALL_MANAGER_FILE = 'callManager';
+export const METRIC_FILE = 'metric';
+export const REGISTRATION_FILE = 'register';
+export const CODEC_ID = 'codecId';
+export const MEDIA_ID = 'id';
+export const RTC_ICE_CANDIDATE_PAIR = 'RTCIceCandidatePair_';
+export const LOCAL_CANDIDATE_ID = 'localCandidateId';
+export const RTC_ICE_CANDIDATE = 'RTCIceCandidate_';
+export const NETWORK_TYPE = 'networkType';
+export const RTC_CODEC = 'RTCCodec_';
+export const INBOUND_CODEC_MATCH = 'CIT01_';
+export const OUTBOUND_CODEC_MATCH = 'COT01_';
+export const MIME_TYPE = 'mimeType';
+export const REMOTE_INBOUND_RTP = 'remote-inbound-rtp';
+export const TOTAL_ROUND_TRIP_TIME = 'totalRoundTripTime';
+export const ROUND_TRIP_TIME_MEASUREMENTS = 'roundTripTimeMeasurements';
+export const INBOUND_RTP = 'inbound-rtp';
+export const OUTBOUND_RTP = 'outbound-rtp';
+export const PACKETS_RECEIVED = 'packetsReceived';
+export const PACKETS_SENT = 'packetsSent';
+export const PACKETS_LOST = 'packetsLost';
+export const PACKETS_DISCARDED = 'packetsDiscarded';
+export const JITTER_BUFFER_DELAY = 'jitterBufferDelay';
+export const JITTER_BUFFER_EMITTED_COUNT = 'jitterBufferEmittedCount';
+export const TIMESTAMP = 'timestamp';
+export const TYPE = 'type';
+export const TRANSPORT = 'transport';
+export const TARGET_BIT_RATE = 'targetBitrate';
+export const MEDIA_SOURCE = 'media-source';
+export const BYTES_RECEIVED = 'bytesReceived';
+export const BYTES_SENT = 'bytesSent';
+export const SELECTED_CANDIDATE_PAIR_ID = 'selectedCandidatePairId';
+export const TOTAL_SAMPLES_DURATION = 'totalSamplesDuration';
+export const RTP_RX_STAT = 'rtp-rxstat';
+export const RTP_TX_STAT = 'rtp-txstat';
+export const BASE_REG_TIMER_MFACTOR = 2;
+export const BASE_REG_RETRY_TIMER_VAL_IN_SEC = 30;
+export const SEC_TO_MSEC_MFACTOR = 1000;
+export const MINUTES_TO_SEC_MFACTOR = 60;
+export const REG_RANDOM_T_FACTOR_UPPER_LIMIT = 10000;
+export const REG_TRY_BACKUP_TIMER_VAL_IN_SEC = 1200;
+export const REG_FAILBACK_429_MAX_RETRIES = 5;
+export const REGISTER_UTIL = 'registerDevice';
+export const GET_MOBIUS_SERVERS_UTIL = 'getMobiusServers';
+export const KEEPALIVE_UTIL = 'startKeepaliveTimer';
+export const FAILBACK_UTIL = 'executeFailback';
+export const FAILBACK_429_RETRY_UTIL = 'scheduleFailback429Retry';
+export const FAILOVER_UTIL = 'startFailoverTimer';
+export const NETWORK_CHANGE_DETECTION_UTIL = 'detectNetworkChange';
+export const CALLS_CLEARED_HANDLER_UTIL = 'callsClearedHandler';
+export const RECONNECT_UTIL = 'reconnectOnFailure';

package/dist/module/CallingClient/line/index.js

@@ -0,0 +1,110 @@
+import { v4 as uuid } from 'uuid';
+import { MobiusStatus, ServiceIndicator } from '../../common/types';
+import { LINE_EVENTS } from './types';
+import { LINE_FILE } from '../constants';
+import log from '../../Logger';
+import { createRegistration } from '../registration';
+import { Eventing } from '../../Events/impl';
+import { validateServiceData } from '../../common';
+import SDKConnector from '../../SDKConnector';
+export default class Line extends Eventing {
+    #webex;
+    #mutex;
+    #sdkConnector;
+    registration;
+    userId;
+    clientDeviceUri;
+    lineId;
+    mobiusDeviceId;
+    mobiusUri;
+    phoneNumber;
+    extension;
+    status;
+    sipAddresses;
+    voicemail;
+    lastSeen;
+    keepaliveInterval;
+    callKeepaliveInterval;
+    rehomingIntervalMin;
+    rehomingIntervalMax;
+    voicePortalNumber;
+    voicePortalExtension;
+    #primaryMobiusUris;
+    #backupMobiusUris;
+    constructor(userId, clientDeviceUri, status, mutex, primaryMobiusUris, backupMobiusUris, logLevel, serviceDataConfig, phoneNumber, extension, voicemail) {
+        super();
+        this.lineId = uuid();
+        this.userId = userId;
+        this.clientDeviceUri = clientDeviceUri;
+        this.status = status;
+        this.phoneNumber = phoneNumber;
+        this.extension = extension;
+        this.voicemail = voicemail;
+        this.#sdkConnector = SDKConnector;
+        this.#webex = this.#sdkConnector.getWebex();
+        this.#mutex = mutex;
+        this.#primaryMobiusUris = primaryMobiusUris;
+        this.#backupMobiusUris = backupMobiusUris;
+        const serviceData = serviceDataConfig?.indicator
+            ? serviceDataConfig
+            : { indicator: ServiceIndicator.CALLING, domain: '' };
+        validateServiceData(serviceData);
+        this.registration = createRegistration(this.#webex, serviceData, this.#mutex, this.lineEmitter, logLevel);
+        this.registration.setStatus(MobiusStatus.DEFAULT);
+        log.setLogger(logLevel, LINE_FILE);
+    }
+    async register() {
+        await this.#mutex.runExclusive(async () => {
+            this.registration.setStatus(MobiusStatus.DEFAULT);
+            this.emit(LINE_EVENTS.CONNECTING);
+            this.registration.setMobiusServers(this.#primaryMobiusUris, this.#backupMobiusUris);
+            await this.registration.triggerRegistration();
+        });
+    }
+    async deregister() {
+        this.registration.deregister();
+    }
+    normalizeLine(deviceInfo) {
+        const { device, keepaliveInterval, callKeepaliveInterval, rehomingIntervalMin, rehomingIntervalMax, voicePortalNumber, voicePortalExtension, } = deviceInfo;
+        this.mobiusDeviceId = device?.deviceId;
+        this.mobiusUri = device?.uri;
+        this.lastSeen = device?.lastSeen;
+        this.sipAddresses = device?.addresses;
+        this.keepaliveInterval = keepaliveInterval;
+        this.callKeepaliveInterval = callKeepaliveInterval;
+        this.rehomingIntervalMin = rehomingIntervalMin;
+        this.rehomingIntervalMax = rehomingIntervalMax;
+        this.voicePortalNumber = voicePortalNumber;
+        this.voicePortalExtension = voicePortalExtension;
+    }
+    lineEmitter = (event, deviceInfo, lineError) => {
+        switch (event) {
+            case LINE_EVENTS.REGISTERED:
+                if (deviceInfo) {
+                    this.normalizeLine(deviceInfo);
+                    this.emit(event, this);
+                }
+                break;
+            case LINE_EVENTS.UNREGISTERED:
+            case LINE_EVENTS.RECONNECTED:
+            case LINE_EVENTS.RECONNECTING:
+                this.emit(event);
+                break;
+            case LINE_EVENTS.ERROR:
+                if (lineError) {
+                    this.emit(event, lineError);
+                }
+                break;
+            default:
+                break;
+        }
+    };
+    getLoggingLevel() {
+        return log.getLogLevel();
+    }
+    getActiveMobiusUrl() {
+        return this.registration.getActiveMobiusUrl();
+    }
+    getRegistrationStatus = () => this.registration.getStatus();
+    getDeviceId = () => this.registration.getDeviceInfo().device?.deviceId;
+}

package/dist/module/CallingClient/line/types.js

@@ -0,0 +1,14 @@
+export var LineStatus;
+(function (LineStatus) {
+    LineStatus["INACTIVE"] = "inactive";
+    LineStatus["ACTIVE"] = "active";
+})(LineStatus || (LineStatus = {}));
+export var LINE_EVENTS;
+(function (LINE_EVENTS) {
+    LINE_EVENTS["CONNECTING"] = "connecting";
+    LINE_EVENTS["ERROR"] = "error";
+    LINE_EVENTS["RECONNECTED"] = "reconnected";
+    LINE_EVENTS["RECONNECTING"] = "reconnecting";
+    LINE_EVENTS["REGISTERED"] = "registered";
+    LINE_EVENTS["UNREGISTERED"] = "unregistered";
+})(LINE_EVENTS || (LINE_EVENTS = {}));

package/dist/module/CallingClient/registration/index.js

@@ -0,0 +1 @@
+export * from './register';