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

package/dist/CallingClient/calling/call.js

@@ -0,0 +1,3055 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCall = exports.Call = void 0;
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _assign = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/assign"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/assertThisInitialized"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _internalMediaCore = require("@webex/internal-media-core");
+var _xstate = require("xstate");
+var _uuid = require("uuid");
+var _types = require("../../Errors/types");
+var _Utils = require("../../common/Utils");
+var _types2 = require("../../common/types");
+var _CallError = require("../../Errors/catalog/CallError");
+var _constants = require("../constants");
+var _SDKConnector = _interopRequireDefault(require("../../SDKConnector"));
+var _impl = require("../../Events/impl");
+var _types3 = require("../../Events/types");
+var _types4 = require("./types");
+var _Logger = _interopRequireDefault(require("../../Logger"));
+var _CallerId = require("./CallerId");
+var _types5 = require("../../Metrics/types");
+var _Metrics = require("../../Metrics");
+var _constants2 = require("../../common/constants");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } } /* eslint-disable tsdoc/syntax */ /* eslint-disable no-param-reassign */
+/**
+ *
+ */
+var Call = exports.Call = /*#__PURE__*/function (_Eventing) {
+  (0, _inherits2.default)(Call, _Eventing);
+  var _super = _createSuper(Call);
+  /**
+   * @ignore
+   */
+  function Call(activeUrl, webex, destination, direction, deviceId, lineId, deleteCb, indicator) {
+    var _this;
+    (0, _classCallCheck2.default)(this, Call);
+    _this = _super.call(this);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "sdkConnector", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "webex", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "destination", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "direction", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "callId", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "correlationId", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "deviceId", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "lineId", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "disconnectReason", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "callStateMachine", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "mediaStateMachine", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "seq", void 0);
+    // TODO: remove later
+    /* TODO: Need to change the type from any to RoapMediaConnection  */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "mediaConnection", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "earlyMedia", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "connected", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "mediaInactivity", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "callerInfo", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "localRoapMessage", void 0);
+    // Use it for new offer
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "mobiusUrl", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "remoteRoapMessage", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "deleteCb", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "callerId", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "sessionTimer", void 0);
+    /* Used to wait for final responses for supplementary services */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "supplementaryServicesTimer", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "muted", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "held", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "metricManager", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "broadworksCorrelationInfo", void 0);
+    // Used in WxCC calls
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "serviceIndicator", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "mediaNegotiationCompleted", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "receivedRoapOKSeq", void 0);
+    /**
+     *
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "getDirection", function () {
+      return _this.direction;
+    });
+    /**
+     *
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "getCallId", function () {
+      return _this.callId;
+    });
+    /**
+     *
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "getCorrelationId", function () {
+      return _this.correlationId;
+    });
+    /**
+     * @param callId -.
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "setCallId", function (callId) {
+      _this.callId = callId;
+      _Logger.default.info("Setting callId : ".concat(_this.callId, " for correlationId: ").concat(_this.correlationId), {
+        file: _constants.CALL_FILE,
+        method: _this.setCallId.name
+      });
+    });
+    /**
+     * Gets the disconnection reason.
+     *
+     * @returns Reason.
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "getDisconnectReason", function () {
+      return _this.disconnectReason;
+    });
+    /**
+     * .
+     *
+     * @param roapMessage
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "post", /*#__PURE__*/function () {
+      var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(roapMessage) {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", _this.webex.request({
+                uri: "".concat(_this.mobiusUrl).concat(_constants.DEVICES_ENDPOINT_RESOURCE, "/").concat(_this.deviceId, "/").concat(_constants.CALL_ENDPOINT_RESOURCE),
+                method: _types2.HTTP_METHODS.POST,
+                service: _types2.ALLOWED_SERVICES.MOBIUS,
+                headers: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, _this.webex.internal.device.url), _constants.SPARK_USER_AGENT, _constants.CALLING_USER_AGENT),
+                body: {
+                  device: {
+                    deviceId: _this.deviceId,
+                    correlationId: _this.correlationId
+                  },
+                  callee: {
+                    type: _this.destination.type,
+                    address: _this.destination.address
+                  },
+                  localMedia: {
+                    roap: roapMessage,
+                    mediaId: (0, _uuid.v4)()
+                  }
+                }
+              }));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    /**
+     *
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "getCallerInfo", function () {
+      return _this.callerInfo;
+    });
+    /**
+     *
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "end", function () {
+      _this.sendCallStateMachineEvt({
+        type: 'E_SEND_CALL_DISCONNECT'
+      });
+    });
+    /**
+     *
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "doHoldResume", function () {
+      if (_this.held) {
+        _this.sendCallStateMachineEvt({
+          type: 'E_CALL_RESUME'
+        });
+      } else {
+        _this.sendCallStateMachineEvt({
+          type: 'E_CALL_HOLD'
+        });
+      }
+    });
+    /**
+     * Mutes/Unmutes the call.
+     *
+     * @param localAudioTrack -.
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "mute", function (localAudioStream) {
+      var localAudioTrack = localAudioStream.outputStream.getAudioTracks()[0];
+      if (_this.muted) {
+        localAudioTrack.enabled = true;
+        _this.muted = false;
+      } else {
+        localAudioTrack.enabled = false;
+        _this.muted = true;
+      }
+    });
+    /**
+     * Change the audio stream of the call.
+     *
+     * @param newAudioStream - The new audio stream to be used in the call.
+     */
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "updateMedia", function (newAudioStream) {
+      var localAudioTrack = newAudioStream.outputStream.getAudioTracks()[0];
+      if (!localAudioTrack) {
+        _Logger.default.warn("Did not find a local track while updating media for call ".concat(_this.getCorrelationId(), ". Will not update media"), {
+          file: _constants.CALL_FILE,
+          method: 'updateMedia'
+        });
+        return;
+      }
+      _this.mediaConnection.updateLocalTracks({
+        audio: localAudioTrack
+      });
+    });
+    _this.destination = destination;
+    _this.direction = direction;
+    _this.sdkConnector = _SDKConnector.default;
+    _this.deviceId = deviceId;
+    _this.serviceIndicator = indicator;
+    _this.lineId = lineId;
+
+    /* istanbul ignore else */
+    if (!_this.sdkConnector.getWebex()) {
+      _SDKConnector.default.setWebex(webex);
+    }
+    _this.webex = _this.sdkConnector.getWebex();
+    _this.metricManager = (0, _Metrics.getMetricManager)(_this.webex, _this.serviceIndicator);
+    _this.callId = "".concat(_constants.DEFAULT_LOCAL_CALL_ID, "_").concat((0, _uuid.v4)());
+    _this.correlationId = (0, _uuid.v4)();
+    _this.deleteCb = deleteCb;
+    _this.connected = false;
+    _this.mediaInactivity = false;
+    _this.held = false;
+    _this.earlyMedia = false;
+    _this.callerInfo = {};
+    _this.localRoapMessage = {};
+    _this.mobiusUrl = activeUrl;
+    _this.receivedRoapOKSeq = 0;
+    _this.mediaNegotiationCompleted = false;
+    _Logger.default.info("Webex Calling Url:- ".concat(_this.mobiusUrl), {
+      file: _constants.CALL_FILE,
+      method: 'constructor'
+    });
+    _this.seq = _constants.INITIAL_SEQ_NUMBER;
+    _this.callerId = (0, _CallerId.createCallerId)(webex, function (callerInfo) {
+      _this.callerInfo = callerInfo;
+      var emitObj = {
+        correlationId: _this.correlationId,
+        callerId: _this.callerInfo
+      };
+      _this.emit(_types3.CALL_EVENT_KEYS.CALLER_ID, emitObj);
+    });
+    _this.remoteRoapMessage = null;
+    _this.disconnectReason = {
+      code: _types4.DisconnectCode.NORMAL,
+      cause: _types4.DisconnectCause.NORMAL
+    };
+    var callMachine = (0, _xstate.createMachine)({
+      schema: {
+        context: {},
+        // The events this machine handles
+        events: {}
+      },
+      id: 'call-state',
+      initial: 'S_IDLE',
+      context: {},
+      states: {
+        S_IDLE: {
+          on: {
+            E_RECV_CALL_SETUP: {
+              target: 'S_RECV_CALL_SETUP',
+              actions: ['incomingCallSetup']
+            },
+            E_SEND_CALL_SETUP: {
+              target: 'S_SEND_CALL_SETUP',
+              actions: ['outgoingCallSetup']
+            },
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        /* CALL SETUP */
+        S_RECV_CALL_SETUP: {
+          on: {
+            E_SEND_CALL_ALERTING: {
+              target: 'S_SEND_CALL_PROGRESS',
+              actions: ['outgoingCallAlerting']
+            },
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        S_SEND_CALL_SETUP: {
+          on: {
+            E_RECV_CALL_PROGRESS: {
+              target: 'S_RECV_CALL_PROGRESS',
+              actions: ['incomingCallProgress']
+            },
+            E_RECV_CALL_CONNECT: {
+              target: 'S_RECV_CALL_CONNECT',
+              actions: ['incomingCallConnect']
+            },
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        /* CALL_PROGRESS */
+        S_RECV_CALL_PROGRESS: {
+          on: {
+            E_RECV_CALL_CONNECT: {
+              target: 'S_RECV_CALL_CONNECT',
+              actions: ['incomingCallConnect']
+            },
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            // Possible to have multiple E_RECV_CALL_PROGRESS events, handler should handle it
+            E_RECV_CALL_PROGRESS: {
+              target: 'S_RECV_CALL_PROGRESS',
+              actions: ['incomingCallProgress']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        S_SEND_CALL_PROGRESS: {
+          on: {
+            E_SEND_CALL_CONNECT: {
+              target: 'S_SEND_CALL_CONNECT',
+              actions: ['outgoingCallConnect']
+            },
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        /* CALL_CONNECT */
+        S_RECV_CALL_CONNECT: {
+          on: {
+            E_CALL_ESTABLISHED: {
+              target: 'S_CALL_ESTABLISHED',
+              actions: ['callEstablished']
+            },
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        S_SEND_CALL_CONNECT: {
+          on: {
+            E_CALL_ESTABLISHED: {
+              target: 'S_CALL_ESTABLISHED',
+              actions: ['callEstablished']
+            },
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        S_CALL_HOLD: {
+          on: {
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_CALL_ESTABLISHED: {
+              target: 'S_CALL_ESTABLISHED',
+              actions: ['callEstablished']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        S_CALL_RESUME: {
+          on: {
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_CALL_ESTABLISHED: {
+              target: 'S_CALL_ESTABLISHED',
+              actions: ['callEstablished']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        /* CALL_ESTABLISHED */
+        S_CALL_ESTABLISHED: {
+          on: {
+            E_CALL_HOLD: {
+              target: 'S_CALL_HOLD',
+              actions: ['initiateCallHold']
+            },
+            E_CALL_RESUME: {
+              target: 'S_CALL_RESUME',
+              actions: ['initiateCallResume']
+            },
+            E_RECV_CALL_DISCONNECT: {
+              target: 'S_RECV_CALL_DISCONNECT',
+              actions: ['incomingCallDisconnect']
+            },
+            E_SEND_CALL_DISCONNECT: {
+              target: 'S_SEND_CALL_DISCONNECT',
+              actions: ['outgoingCallDisconnect']
+            },
+            E_CALL_ESTABLISHED: {
+              target: 'S_CALL_ESTABLISHED',
+              actions: ['callEstablished']
+            },
+            E_UNKNOWN: {
+              target: 'S_UNKNOWN',
+              actions: ['unknownState']
+            }
+          }
+        },
+        /* CALL_DISCONNECT */
+        S_RECV_CALL_DISCONNECT: {
+          on: {
+            E_CALL_CLEARED: 'S_CALL_CLEARED'
+          }
+        },
+        S_SEND_CALL_DISCONNECT: {
+          on: {
+            E_CALL_CLEARED: 'S_CALL_CLEARED'
+          }
+        },
+        /* UNKNOWN_EVENTS */
+        S_UNKNOWN: {
+          on: {
+            E_CALL_CLEARED: 'S_CALL_CLEARED'
+          }
+        },
+        /* ERROR_EVENTS */
+        S_ERROR: {
+          on: {
+            E_CALL_CLEARED: 'S_CALL_CLEARED'
+          }
+        },
+        /* End of our state-machine */
+        S_CALL_CLEARED: {
+          type: 'final'
+        }
+      }
+    }, {
+      actions: {
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        incomingCallSetup: function incomingCallSetup(context, event) {
+          return _this.handleIncomingCallSetup(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        outgoingCallSetup: function outgoingCallSetup(context, event) {
+          return _this.handleOutgoingCallSetup(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        incomingCallProgress: function incomingCallProgress(context, event) {
+          return _this.handleIncomingCallProgress(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        outgoingCallAlerting: function outgoingCallAlerting(context, event) {
+          return _this.handleOutgoingCallAlerting(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        incomingCallConnect: function incomingCallConnect(context, event) {
+          return _this.handleIncomingCallConnect(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        outgoingCallConnect: function outgoingCallConnect(context, event) {
+          return _this.handleOutgoingCallConnect(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        callEstablished: function callEstablished(context, event) {
+          return _this.handleCallEstablished(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        initiateCallHold: function initiateCallHold(context, event) {
+          return _this.handleCallHold(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        initiateCallResume: function initiateCallResume(context, event) {
+          return _this.handleCallResume(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        incomingCallDisconnect: function incomingCallDisconnect(context, event) {
+          return _this.handleIncomingCallDisconnect(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        outgoingCallDisconnect: function outgoingCallDisconnect(context, event) {
+          return _this.handleOutgoingCallDisconnect(event);
+        },
+        /**
+         * .
+         *
+         * @param context
+         * @param event
+         */
+        unknownState: function unknownState(context, event) {
+          return _this.handleUnknownState(event);
+        }
+      }
+    });
+    var mediaMachine = (0, _xstate.createMachine)({
+      schema: {
+        // The context (extended state) of the machine
+        context: {},
+        // The events this machine handles
+        events: {}
+      },
+      id: 'roap-state',
+      initial: 'S_ROAP_IDLE',
+      context: {},
+      states: {
+        S_ROAP_IDLE: {
+          on: {
+            E_RECV_ROAP_OFFER_REQUEST: {
+              target: 'S_RECV_ROAP_OFFER_REQUEST',
+              actions: ['incomingRoapOfferRequest']
+            },
+            E_RECV_ROAP_OFFER: {
+              target: 'S_RECV_ROAP_OFFER',
+              actions: ['incomingRoapOffer']
+            },
+            E_SEND_ROAP_OFFER: {
+              target: 'S_SEND_ROAP_OFFER',
+              actions: ['outgoingRoapOffer']
+            }
+          }
+        },
+        S_RECV_ROAP_OFFER_REQUEST: {
+          on: {
+            E_SEND_ROAP_OFFER: {
+              target: 'S_SEND_ROAP_OFFER',
+              actions: ['outgoingRoapOffer']
+            },
+            E_ROAP_OK: {
+              target: 'S_ROAP_OK',
+              actions: ['roapEstablished']
+            },
+            E_ROAP_ERROR: {
+              target: 'S_ROAP_ERROR',
+              actions: ['roapError']
+            }
+          }
+        },
+        S_RECV_ROAP_OFFER: {
+          on: {
+            E_SEND_ROAP_ANSWER: {
+              target: 'S_SEND_ROAP_ANSWER',
+              actions: ['outgoingRoapAnswer']
+            },
+            E_ROAP_OK: {
+              target: 'S_ROAP_OK',
+              actions: ['roapEstablished']
+            },
+            E_ROAP_ERROR: {
+              target: 'S_ROAP_ERROR',
+              actions: ['roapError']
+            }
+          }
+        },
+        S_SEND_ROAP_OFFER: {
+          on: {
+            E_RECV_ROAP_ANSWER: {
+              target: 'S_RECV_ROAP_ANSWER',
+              actions: ['incomingRoapAnswer']
+            },
+            E_SEND_ROAP_ANSWER: {
+              target: 'S_SEND_ROAP_ANSWER',
+              actions: ['outgoingRoapAnswer']
+            },
+            E_SEND_ROAP_OFFER: {
+              target: 'S_SEND_ROAP_OFFER',
+              actions: ['outgoingRoapOffer']
+            },
+            E_ROAP_ERROR: {
+              target: 'S_ROAP_ERROR',
+              actions: ['roapError']
+            }
+          }
+        },
+        S_RECV_ROAP_ANSWER: {
+          on: {
+            E_ROAP_OK: {
+              target: 'S_ROAP_OK',
+              actions: ['roapEstablished']
+            },
+            E_ROAP_ERROR: {
+              target: 'S_ROAP_ERROR',
+              actions: ['roapError']
+            }
+          }
+        },
+        S_SEND_ROAP_ANSWER: {
+          on: {
+            E_RECV_ROAP_OFFER_REQUEST: {
+              target: 'S_RECV_ROAP_OFFER_REQUEST',
+              actions: ['incomingRoapOfferRequest']
+            },
+            E_RECV_ROAP_OFFER: {
+              target: 'S_RECV_ROAP_OFFER',
+              actions: ['incomingRoapOffer']
+            },
+            E_ROAP_OK: {
+              target: 'S_ROAP_OK',
+              actions: ['roapEstablished']
+            },
+            E_SEND_ROAP_ANSWER: {
+              target: 'S_SEND_ROAP_ANSWER',
+              actions: ['outgoingRoapAnswer']
+            },
+            E_ROAP_ERROR: {
+              target: 'S_ROAP_ERROR',
+              actions: ['roapError']
+            }
+          }
+        },
+        S_ROAP_OK: {
+          on: {
+            E_RECV_ROAP_OFFER_REQUEST: {
+              target: 'S_RECV_ROAP_OFFER_REQUEST',
+              actions: ['incomingRoapOfferRequest']
+            },
+            E_RECV_ROAP_OFFER: {
+              target: 'S_RECV_ROAP_OFFER',
+              actions: ['incomingRoapOffer']
+            },
+            E_ROAP_OK: {
+              target: 'S_ROAP_OK',
+              actions: ['roapEstablished']
+            },
+            E_SEND_ROAP_OFFER: {
+              target: 'S_SEND_ROAP_OFFER',
+              actions: ['outgoingRoapOffer']
+            },
+            E_ROAP_ERROR: {
+              target: 'S_ROAP_ERROR',
+              actions: ['roapError']
+            },
+            E_ROAP_TEARDOWN: {
+              target: 'S_ROAP_TEARDOWN'
+            }
+          }
+        },
+        S_ROAP_ERROR: {
+          on: {
+            E_ROAP_TEARDOWN: {
+              target: 'S_ROAP_TEARDOWN'
+            },
+            E_RECV_ROAP_OFFER_REQUEST: {
+              target: 'S_RECV_ROAP_OFFER_REQUEST',
+              actions: ['incomingRoapOfferRequest']
+            },
+            E_RECV_ROAP_OFFER: {
+              target: 'S_RECV_ROAP_OFFER',
+              actions: ['incomingRoapOffer']
+            },
+            E_RECV_ROAP_ANSWER: {
+              target: 'S_RECV_ROAP_ANSWER',
+              actions: ['incomingRoapAnswer']
+            },
+            E_ROAP_OK: {
+              target: 'S_ROAP_OK',
+              actions: ['roapEstablished']
+            }
+          }
+        },
+        S_ROAP_TEARDOWN: {
+          type: 'final'
+        }
+      }
+    }, {
+      actions: {
+        /**
+         * .
+         *
+         * @param context -.
+         * @param event -.
+         */
+        incomingRoapOffer: function incomingRoapOffer(context, event) {
+          return _this.handleIncomingRoapOffer(context, event);
+        },
+        /**
+         * .
+         *
+         * @param context -.
+         * @param event -.
+         */
+        incomingRoapAnswer: function incomingRoapAnswer(context, event) {
+          return _this.handleIncomingRoapAnswer(context, event);
+        },
+        /**
+         * .
+         *
+         * @param context -.
+         * @param event -.
+         */
+        incomingRoapOfferRequest: function incomingRoapOfferRequest(context, event) {
+          return _this.handleIncomingRoapOfferRequest(context, event);
+        },
+        /**
+         * .
+         *
+         * @param context -.
+         * @param event -.
+         */
+        outgoingRoapOffer: function outgoingRoapOffer(context, event) {
+          return _this.handleOutgoingRoapOffer(context, event);
+        },
+        /**
+         * .
+         *
+         * @param context -.
+         * @param event -.
+         */
+        outgoingRoapAnswer: function outgoingRoapAnswer(context, event) {
+          return _this.handleOutgoingRoapAnswer(context, event);
+        },
+        /**
+         * .
+         *
+         * @param context -.
+         * @param event -.
+         */
+        roapEstablished: function roapEstablished(context, event) {
+          return _this.handleRoapEstablished(context, event);
+        },
+        /**
+         * .
+         *
+         * @param context -.
+         * @param event -.
+         */
+        roapError: function roapError(context, event) {
+          return _this.handleRoapError(context, event);
+        }
+      }
+    });
+    _this.callStateMachine = (0, _xstate.interpret)(callMachine).onTransition(function (state, event) {
+      _Logger.default.log("Call StateMachine:- state=".concat(state.value, ", event=").concat((0, _stringify.default)(event.type)), {});
+      if (state.value !== 'S_UNKNOWN') {
+        _this.metricManager.submitCallMetric(_types5.METRIC_EVENT.CALL, state.value.toString(), _types5.METRIC_TYPE.BEHAVIORAL, _this.callId, _this.correlationId, undefined);
+      }
+    }).start();
+    _this.mediaStateMachine = (0, _xstate.interpret)(mediaMachine).onTransition(function (state, event) {
+      _Logger.default.log("Media StateMachine:- state=".concat(state.value, ", event=").concat((0, _stringify.default)(event.type)), {});
+      if (state.value !== 'S_ROAP_ERROR') {
+        var _this$remoteRoapMessa;
+        _this.metricManager.submitMediaMetric(_types5.METRIC_EVENT.MEDIA, state.value.toString(), _types5.METRIC_TYPE.BEHAVIORAL, _this.callId, _this.correlationId, _this.localRoapMessage.sdp, (_this$remoteRoapMessa = _this.remoteRoapMessage) === null || _this$remoteRoapMessa === void 0 ? void 0 : _this$remoteRoapMessa.sdp, undefined);
+      }
+    }).start();
+    _this.muted = false;
+    return _this;
+  }
+
+  /**
+   * Handle incoming Call setups.
+   *
+   * @param event - Call Events.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  (0, _createClass2.default)(Call, [{
+    key: "isMuted",
+    value:
+    /**
+     * Getter to check if the call is muted or not.
+     *
+     * @returns - Boolean.
+     */
+    function isMuted() {
+      return this.muted;
+    }
+
+    /**
+     * Getter to check if the call is connected or not.
+     *
+     * @returns - Boolean.
+     */
+  }, {
+    key: "isConnected",
+    value: function isConnected() {
+      return this.connected;
+    }
+
+    /**
+     * Getter to check if the call is held or not.
+     *
+     * @returns - Boolean.
+     */
+  }, {
+    key: "isHeld",
+    value: function isHeld() {
+      return this.held;
+    }
+  }, {
+    key: "handleIncomingCallSetup",
+    value: function handleIncomingCallSetup(event) {
+      _Logger.default.info("handleIncomingCallSetup: ".concat(this.getCorrelationId(), "  "), {
+        file: _constants.CALL_FILE,
+        method: this.handleIncomingCallSetup.name
+      });
+      this.sendCallStateMachineEvt({
+        type: 'E_SEND_CALL_ALERTING'
+      });
+    }
+
+    /**
+     * Handle outgoing Call setups.
+     * The handler sends a Post Message to the remote with ROAP body
+     * as offer. We also set the callId here based on the response received.
+     *
+     * @param event - Call Events.
+     */
+  }, {
+    key: "handleOutgoingCallSetup",
+    value: (function () {
+      var _handleOutgoingCallSetup = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(event) {
+        var _this2 = this;
+        var message, response, errData;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _Logger.default.info("handleOutgoingCallSetup: ".concat(this.getCorrelationId(), "  "), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallSetup.name
+              });
+              message = event.data;
+              _context2.prev = 2;
+              _context2.next = 5;
+              return this.post(message);
+            case 5:
+              response = _context2.sent;
+              _Logger.default.log("handleOutgoingCallSetup: Response code: ".concat(response.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallSetup.name
+              });
+              this.setCallId(response.body.callId);
+              _context2.next = 15;
+              break;
+            case 10:
+              _context2.prev = 10;
+              _context2.t0 = _context2["catch"](2);
+              _Logger.default.warn('Failed to setup the call', {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallSetup.name
+              });
+              errData = _context2.t0;
+              (0, _Utils.handleCallErrors)(function (error) {
+                _this2.emit(_types3.CALL_EVENT_KEYS.CALL_ERROR, error);
+                _this2.submitCallErrorMetric(error);
+                _this2.sendCallStateMachineEvt({
+                  type: 'E_UNKNOWN',
+                  data: errData
+                });
+              }, _types.ERROR_LAYER.CALL_CONTROL,
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              /* istanbul ignore next */
+              function (interval) {
+                return undefined;
+              }, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, _constants.CALL_FILE);
+            case 15:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[2, 10]]);
+      }));
+      function handleOutgoingCallSetup(_x2) {
+        return _handleOutgoingCallSetup.apply(this, arguments);
+      }
+      return handleOutgoingCallSetup;
+    }()
+    /**
+     * Handle Call Hold.
+     *
+     * @param event - Call Events.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    )
+  }, {
+    key: "handleCallHold",
+    value: (function () {
+      var _handleCallHold = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(event) {
+        var _this3 = this;
+        var response, errData;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              _Logger.default.info("handleCallHold: ".concat(this.getCorrelationId(), "  "), {
+                file: _constants.CALL_FILE,
+                method: this.handleCallHold.name
+              });
+              _context4.prev = 1;
+              _context4.next = 4;
+              return this.postSSRequest(undefined, _types3.SUPPLEMENTARY_SERVICES.HOLD);
+            case 4:
+              response = _context4.sent;
+              _Logger.default.log("Response code: ".concat(response.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleCallHold.name
+              });
+
+              /*
+               *  Avoid setting http response timeout if held event is already
+               *  received from Mobius and forwarded towards calling client
+               */
+              if (this.isHeld() === false) {
+                this.supplementaryServicesTimer = setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3() {
+                  var errorContext, callError;
+                  return _regenerator.default.wrap(function _callee3$(_context3) {
+                    while (1) switch (_context3.prev = _context3.next) {
+                      case 0:
+                        errorContext = {
+                          file: _constants.CALL_FILE,
+                          method: _this3.handleCallHold.name
+                        };
+                        _Logger.default.warn('Hold response timed out', {
+                          file: _constants.CALL_FILE,
+                          method: _this3.handleCallHold.name
+                        });
+                        callError = (0, _CallError.createCallError)('An error occurred while placing the call on hold. Wait a moment and try again.', errorContext, _types.ERROR_TYPE.TIMEOUT, _this3.getCorrelationId(), _types.ERROR_LAYER.CALL_CONTROL);
+                        _this3.emit(_types3.CALL_EVENT_KEYS.HOLD_ERROR, callError);
+                        _this3.submitCallErrorMetric(callError);
+                      case 5:
+                      case "end":
+                        return _context3.stop();
+                    }
+                  }, _callee3);
+                })), _constants.SUPPLEMENTARY_SERVICES_TIMEOUT);
+              }
+              _context4.next = 14;
+              break;
+            case 9:
+              _context4.prev = 9;
+              _context4.t0 = _context4["catch"](1);
+              _Logger.default.warn('Failed to put the call on hold', {
+                file: _constants.CALL_FILE,
+                method: this.handleCallHold.name
+              });
+              errData = _context4.t0;
+              (0, _Utils.handleCallErrors)(function (error) {
+                _this3.emit(_types3.CALL_EVENT_KEYS.HOLD_ERROR, error);
+                _this3.submitCallErrorMetric(error);
+                _this3.sendCallStateMachineEvt({
+                  type: 'E_CALL_ESTABLISHED',
+                  data: errData
+                });
+              }, _types.ERROR_LAYER.CALL_CONTROL,
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              /* istanbul ignore next */
+              function (interval) {
+                return undefined;
+              }, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, _constants.CALL_FILE);
+            case 14:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[1, 9]]);
+      }));
+      function handleCallHold(_x3) {
+        return _handleCallHold.apply(this, arguments);
+      }
+      return handleCallHold;
+    }()
+    /**
+     * Handle Call Resume.
+     *
+     * @param event - Call Events.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    )
+  }, {
+    key: "handleCallResume",
+    value: (function () {
+      var _handleCallResume = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(event) {
+        var _this4 = this;
+        var response, errData;
+        return _regenerator.default.wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              _Logger.default.info("handleCallResume: ".concat(this.getCorrelationId(), "  "), {
+                file: _constants.CALL_FILE,
+                method: this.handleCallResume.name
+              });
+              _context6.prev = 1;
+              _context6.next = 4;
+              return this.postSSRequest(undefined, _types3.SUPPLEMENTARY_SERVICES.RESUME);
+            case 4:
+              response = _context6.sent;
+              _Logger.default.log("Response code: ".concat(response.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleCallResume.name
+              });
+
+              /*
+               *  Avoid setting http response timeout if connected event is already
+               *  received from Mobius on resuming the call and forwarded towards calling client
+               */
+              if (this.isHeld() === true) {
+                this.supplementaryServicesTimer = setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+                  var errorContext, callError;
+                  return _regenerator.default.wrap(function _callee5$(_context5) {
+                    while (1) switch (_context5.prev = _context5.next) {
+                      case 0:
+                        errorContext = {
+                          file: _constants.CALL_FILE,
+                          method: _this4.handleCallResume.name
+                        };
+                        _Logger.default.warn('Resume response timed out', {
+                          file: _constants.CALL_FILE,
+                          method: _this4.handleCallResume.name
+                        });
+                        callError = (0, _CallError.createCallError)('An error occurred while resuming the call. Wait a moment and try again.', errorContext, _types.ERROR_TYPE.TIMEOUT, _this4.getCorrelationId(), _types.ERROR_LAYER.CALL_CONTROL);
+                        _this4.emit(_types3.CALL_EVENT_KEYS.RESUME_ERROR, callError);
+                        _this4.submitCallErrorMetric(callError);
+                      case 5:
+                      case "end":
+                        return _context5.stop();
+                    }
+                  }, _callee5);
+                })), _constants.SUPPLEMENTARY_SERVICES_TIMEOUT);
+              }
+              _context6.next = 14;
+              break;
+            case 9:
+              _context6.prev = 9;
+              _context6.t0 = _context6["catch"](1);
+              _Logger.default.warn('Failed to resume the call', {
+                file: _constants.CALL_FILE,
+                method: this.handleCallResume.name
+              });
+              errData = _context6.t0;
+              (0, _Utils.handleCallErrors)(function (error) {
+                _this4.emit(_types3.CALL_EVENT_KEYS.RESUME_ERROR, error);
+                _this4.submitCallErrorMetric(error);
+                _this4.sendCallStateMachineEvt({
+                  type: 'E_CALL_ESTABLISHED',
+                  data: errData
+                });
+              }, _types.ERROR_LAYER.CALL_CONTROL,
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              /* istanbul ignore next */
+              function (interval) {
+                return undefined;
+              }, this.getCorrelationId(), errData, this.handleOutgoingCallSetup.name, _constants.CALL_FILE);
+            case 14:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[1, 9]]);
+      }));
+      function handleCallResume(_x4) {
+        return _handleCallResume.apply(this, arguments);
+      }
+      return handleCallResume;
+    }()
+    /**
+     * Handle incoming Call Progress.
+     *
+     * @param event - Call Events.
+     */
+    )
+  }, {
+    key: "handleIncomingCallProgress",
+    value: function handleIncomingCallProgress(event) {
+      var _data$callProgressDat;
+      _Logger.default.info("handleIncomingCallProgress: ".concat(this.getCorrelationId(), "  "), {
+        file: _constants.CALL_FILE,
+        method: this.handleIncomingCallProgress.name
+      });
+      var data = event.data;
+      if (data !== null && data !== void 0 && (_data$callProgressDat = data.callProgressData) !== null && _data$callProgressDat !== void 0 && _data$callProgressDat.inbandMedia) {
+        _Logger.default.log('Inband media present. Setting Early Media flag', {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingCallProgress.name
+        });
+        this.earlyMedia = true;
+      } else {
+        _Logger.default.log('Inband media not present.', {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingCallProgress.name
+        });
+      }
+      if (data !== null && data !== void 0 && data.callerId) {
+        _Logger.default.info('Processing Caller-Id data', {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingCallProgress.name
+        });
+        this.startCallerIdResolution(data.callerId);
+      }
+      this.emit(_types3.CALL_EVENT_KEYS.PROGRESS, this.correlationId);
+    }
+
+    /**
+     * Handle incoming Call Progress.
+     *
+     * @param context
+     * @param event - Roap Events.
+     */
+  }, {
+    key: "handleIncomingRoapOfferRequest",
+    value: function handleIncomingRoapOfferRequest(context, event) {
+      _Logger.default.info("handleIncomingRoapOfferRequest: ".concat(this.getCorrelationId(), "  "), {
+        file: _constants.CALL_FILE,
+        method: this.handleIncomingRoapOfferRequest.name
+      });
+      var message = event.data;
+      if (!this.mediaConnection) {
+        _Logger.default.info('Media connection is not up, buffer the remote Offer Request for later handling', {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingRoapOfferRequest.name
+        });
+        this.seq = message.seq;
+        _Logger.default.info("Setting Sequence No: ".concat(this.seq), {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingRoapOfferRequest.name
+        });
+        this.remoteRoapMessage = message;
+      } else if (this.receivedRoapOKSeq === message.seq - 2) {
+        _Logger.default.info('Waiting for Roap OK, buffer the remote Offer Request for later handling', {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingRoapOfferRequest.name
+        });
+        this.remoteRoapMessage = message;
+      } else {
+        message.seq = this.seq + 1;
+        this.seq = message.seq;
+        this.mediaConnection.roapMessageReceived(message);
+      }
+    }
+
+    /**
+     * Handle Outgoing Call Progress.
+     *
+     * @param event - Call Events.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  }, {
+    key: "handleOutgoingCallAlerting",
+    value: (function () {
+      var _handleOutgoingCallAlerting = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(event) {
+        var _this5 = this;
+        var res, errData;
+        return _regenerator.default.wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _Logger.default.info("handleOutgoingCallAlerting: ".concat(this.getCorrelationId(), "  "), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallAlerting.name
+              });
+              _context7.prev = 1;
+              _context7.next = 4;
+              return this.patch(_types4.MobiusCallState.ALERTING);
+            case 4:
+              res = _context7.sent;
+              _Logger.default.log("PATCH response: ".concat(res.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallAlerting.name
+              });
+              _context7.next = 13;
+              break;
+            case 8:
+              _context7.prev = 8;
+              _context7.t0 = _context7["catch"](1);
+              _Logger.default.warn('Failed to signal call progression', {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallAlerting.name
+              });
+              errData = _context7.t0;
+              (0, _Utils.handleCallErrors)(function (error) {
+                _this5.emit(_types3.CALL_EVENT_KEYS.CALL_ERROR, error);
+                _this5.submitCallErrorMetric(error);
+                _this5.sendCallStateMachineEvt({
+                  type: 'E_UNKNOWN',
+                  data: errData
+                });
+              }, _types.ERROR_LAYER.CALL_CONTROL,
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              /* istanbul ignore next */
+              function (interval) {
+                return undefined;
+              }, this.getCorrelationId(), errData, this.handleOutgoingCallAlerting.name, _constants.CALL_FILE);
+            case 13:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this, [[1, 8]]);
+      }));
+      function handleOutgoingCallAlerting(_x5) {
+        return _handleOutgoingCallAlerting.apply(this, arguments);
+      }
+      return handleOutgoingCallAlerting;
+    }()
+    /**
+     * Handle incoming Call Connect.
+     *
+     * @param event - Call Events.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    )
+  }, {
+    key: "handleIncomingCallConnect",
+    value: function handleIncomingCallConnect(event) {
+      _Logger.default.info("handleIncomingCallConnect: ".concat(this.getCorrelationId(), "  "), {
+        file: _constants.CALL_FILE,
+        method: this.handleIncomingCallConnect.name
+      });
+      this.emit(_types3.CALL_EVENT_KEYS.CONNECT, this.correlationId);
+
+      /* In case of Early Media , media negotiations would have already started
+       * So we can directly go to call established state */
+
+      if (this.earlyMedia || this.mediaNegotiationCompleted) {
+        this.mediaNegotiationCompleted = false;
+        this.sendCallStateMachineEvt({
+          type: 'E_CALL_ESTABLISHED'
+        });
+      }
+    }
+
+    /**
+     * Handle outgoing Call Connect.
+     *
+     * @param event - Call Events.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  }, {
+    key: "handleOutgoingCallConnect",
+    value: (function () {
+      var _handleOutgoingCallConnect = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(event) {
+        var _this6 = this;
+        var res, errData;
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              _Logger.default.info("handleOutgoingCallConnect: ".concat(this.getCorrelationId(), "  "), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallConnect.name
+              });
+
+              /* We should have received an Offer by now */
+              if (this.remoteRoapMessage) {
+                _context8.next = 4;
+                break;
+              }
+              _Logger.default.warn('Offer not yet received from remote end... Exiting', {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallConnect.name
+              });
+              return _context8.abrupt("return");
+            case 4:
+              _context8.prev = 4;
+              /* Start Offer/Answer as we might have buffered the offer by now */
+              this.mediaConnection.roapMessageReceived(this.remoteRoapMessage);
+
+              /* send call_connect PATCH */
+              _context8.next = 8;
+              return this.patch(_types4.MobiusCallState.CONNECTED);
+            case 8:
+              res = _context8.sent;
+              _Logger.default.log("PATCH response: ".concat(res.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallConnect.name
+              });
+              _context8.next = 17;
+              break;
+            case 12:
+              _context8.prev = 12;
+              _context8.t0 = _context8["catch"](4);
+              _Logger.default.warn('Failed to connect the call', {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallConnect.name
+              });
+              errData = _context8.t0;
+              (0, _Utils.handleCallErrors)(function (error) {
+                _this6.emit(_types3.CALL_EVENT_KEYS.CALL_ERROR, error);
+                _this6.submitCallErrorMetric(error);
+                _this6.sendCallStateMachineEvt({
+                  type: 'E_UNKNOWN',
+                  data: errData
+                });
+              }, _types.ERROR_LAYER.CALL_CONTROL,
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              /* istanbul ignore next */
+              function (interval) {
+                return undefined;
+              }, this.getCorrelationId(), errData, this.handleOutgoingCallConnect.name, _constants.CALL_FILE);
+            case 17:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this, [[4, 12]]);
+      }));
+      function handleOutgoingCallConnect(_x6) {
+        return _handleOutgoingCallConnect.apply(this, arguments);
+      }
+      return handleOutgoingCallConnect;
+    }()
+    /**
+     * Handle incoming Call Disconnect.
+     *
+     * @param event - Call Events.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    )
+  }, {
+    key: "handleIncomingCallDisconnect",
+    value: (function () {
+      var _handleIncomingCallDisconnect = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(event) {
+        var response;
+        return _regenerator.default.wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              _Logger.default.info("handleIncomingCallDisconnect: ".concat(this.getCorrelationId(), "  "), {
+                file: _constants.CALL_FILE,
+                method: this.handleIncomingCallDisconnect.name
+              });
+              this.setDisconnectReason();
+              _context9.prev = 2;
+              _context9.next = 5;
+              return this.delete();
+            case 5:
+              response = _context9.sent;
+              _Logger.default.log("handleOutgoingCallDisconnect: Response code: ".concat(response.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleIncomingCallDisconnect.name
+              });
+              _context9.next = 12;
+              break;
+            case 9:
+              _context9.prev = 9;
+              _context9.t0 = _context9["catch"](2);
+              _Logger.default.warn('Failed to delete the call', {
+                file: _constants.CALL_FILE,
+                method: this.handleIncomingCallDisconnect.name
+              });
+            case 12:
+              this.deleteCb(this.correlationId);
+
+              /* istanbul ignore else */
+              if (this.sessionTimer) {
+                clearInterval(this.sessionTimer);
+              }
+
+              /* istanbul ignore else */
+              if (this.mediaConnection) {
+                this.mediaConnection.close();
+                _Logger.default.info('Closing media channel', {
+                  file: _constants.CALL_FILE,
+                  method: 'handleIncomingCallDisconnect'
+                });
+              }
+              this.sendMediaStateMachineEvt({
+                type: 'E_ROAP_TEARDOWN'
+              });
+              this.sendCallStateMachineEvt({
+                type: 'E_CALL_CLEARED'
+              });
+              this.emit(_types3.CALL_EVENT_KEYS.DISCONNECT, this.correlationId);
+            case 18:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this, [[2, 9]]);
+      }));
+      function handleIncomingCallDisconnect(_x7) {
+        return _handleIncomingCallDisconnect.apply(this, arguments);
+      }
+      return handleIncomingCallDisconnect;
+    }()
+    /**
+     * Handle outgoing Call Disconnect.
+     *
+     * @param event - Call Events.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    )
+  }, {
+    key: "handleOutgoingCallDisconnect",
+    value: (function () {
+      var _handleOutgoingCallDisconnect = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(event) {
+        var response;
+        return _regenerator.default.wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              this.setDisconnectReason();
+              _context10.prev = 1;
+              _context10.next = 4;
+              return this.delete();
+            case 4:
+              response = _context10.sent;
+              _Logger.default.log("handleOutgoingCallDisconnect: Response code: ".concat(response.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallDisconnect.name
+              });
+              _context10.next = 11;
+              break;
+            case 8:
+              _context10.prev = 8;
+              _context10.t0 = _context10["catch"](1);
+              _Logger.default.warn('Failed to delete the call', {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingCallDisconnect.name
+              });
+            case 11:
+              this.deleteCb(this.correlationId);
+
+              /* istanbul ignore else */
+              if (this.sessionTimer) {
+                clearInterval(this.sessionTimer);
+              }
+
+              /* istanbul ignore else */
+              if (this.mediaConnection) {
+                this.mediaConnection.close();
+                _Logger.default.info('Closing media channel', {
+                  file: _constants.CALL_FILE,
+                  method: 'handleOutgoingCallDisconnect'
+                });
+              }
+              this.sendMediaStateMachineEvt({
+                type: 'E_ROAP_TEARDOWN'
+              });
+              this.sendCallStateMachineEvt({
+                type: 'E_CALL_CLEARED'
+              });
+            case 16:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this, [[1, 8]]);
+      }));
+      function handleOutgoingCallDisconnect(_x8) {
+        return _handleOutgoingCallDisconnect.apply(this, arguments);
+      }
+      return handleOutgoingCallDisconnect;
+    }()
+    /**
+     * Handle Call Established - Roap related negotiations.
+     *
+     * @param event - Call Events.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    )
+  }, {
+    key: "handleCallEstablished",
+    value: function handleCallEstablished(event) {
+      var _this7 = this;
+      _Logger.default.info("handleCallEstablished: ".concat(this.getCorrelationId(), "  "), {
+        file: _constants.CALL_FILE,
+        method: this.handleCallEstablished.name
+      });
+      this.emit(_types3.CALL_EVENT_KEYS.ESTABLISHED, this.correlationId);
+
+      /* Reset Early dialog parameters */
+      this.earlyMedia = false;
+      this.connected = true;
+
+      /* Session timers need to be reset at all offer/answer exchanges */
+      if (this.sessionTimer) {
+        _Logger.default.log('Resetting session timer', {
+          file: _constants.CALL_FILE,
+          method: 'handleCallEstablished'
+        });
+        clearInterval(this.sessionTimer);
+      }
+      this.sessionTimer = setInterval( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11() {
+        var res, error;
+        return _regenerator.default.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              _context11.prev = 0;
+              _context11.next = 3;
+              return _this7.postStatus();
+            case 3:
+              res = _context11.sent;
+              _Logger.default.info("Session refresh successful", {
+                file: _constants.CALL_FILE,
+                method: 'handleCallEstablished'
+              });
+              _context11.next = 12;
+              break;
+            case 7:
+              _context11.prev = 7;
+              _context11.t0 = _context11["catch"](0);
+              error = _context11.t0;
+              /* We are clearing the timer here as all are error scenarios. Only scenario where
+               * timer reset won't be required is 503 with retry after. But that case will
+               * be handled automatically as Mobius will also reset timer when we post status
+               * in retry-after scenario.
+               */
+              /* istanbul ignore next */
+              if (_this7.sessionTimer) {
+                clearInterval(_this7.sessionTimer);
+              }
+              (0, _Utils.handleCallErrors)(function (callError) {
+                _this7.emit(_types3.CALL_EVENT_KEYS.CALL_ERROR, callError);
+                _this7.submitCallErrorMetric(callError);
+              }, _types.ERROR_LAYER.CALL_CONTROL, function (interval) {
+                setTimeout(function () {
+                  /* We first post the status and then recursively call the handler which
+                   * starts the timer again
+                   */
+                  _this7.postStatus();
+                  _this7.sendCallStateMachineEvt({
+                    type: 'E_CALL_ESTABLISHED'
+                  });
+                }, interval * 1000);
+              }, _this7.getCorrelationId(), error, _this7.handleCallEstablished.name, _constants.CALL_FILE);
+            case 12:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11, null, [[0, 7]]);
+      })), _constants.DEFAULT_SESSION_TIMER);
+    }
+
+    /**
+     * Handle Unknown events.
+     *
+     * @param event - Call Events.
+     */
+  }, {
+    key: "handleUnknownState",
+    value: (function () {
+      var _handleUnknownState = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12(event) {
+        var eventData, response;
+        return _regenerator.default.wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              _Logger.default.info("handleUnknownState: ".concat(this.getCorrelationId(), "  "), {
+                file: _constants.CALL_FILE,
+                method: this.handleUnknownState.name
+              });
+
+              /* We are handling errors at the source , in this state we just log and
+               * clear the resources
+               */
+              eventData = event.data;
+              if (!(eventData !== null && eventData !== void 0 && eventData.media)) {
+                _Logger.default.warn('Call failed due to signalling issue', {
+                  file: _constants.CALL_FILE,
+                  method: this.handleUnknownState.name
+                });
+              }
+
+              /* We need to clear the call at Mobius too. For delete failure
+               * error handling is not required
+               */
+              _context12.prev = 3;
+              this.setDisconnectReason();
+              _context12.next = 7;
+              return this.delete();
+            case 7:
+              response = _context12.sent;
+              _Logger.default.log("handleOutgoingCallDisconnect: Response code: ".concat(response.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleUnknownState.name
+              });
+              _context12.next = 14;
+              break;
+            case 11:
+              _context12.prev = 11;
+              _context12.t0 = _context12["catch"](3);
+              _Logger.default.warn('Failed to delete the call', {
+                file: _constants.CALL_FILE,
+                method: this.handleUnknownState.name
+              });
+            case 14:
+              this.deleteCb(this.correlationId);
+              if (this.sessionTimer) {
+                clearInterval(this.sessionTimer);
+              }
+              if (this.mediaConnection) {
+                this.mediaConnection.close();
+                _Logger.default.info('Closing media channel', {
+                  file: _constants.CALL_FILE,
+                  method: this.handleUnknownState.name
+                });
+              }
+              this.sendMediaStateMachineEvt({
+                type: 'E_ROAP_TEARDOWN'
+              });
+              this.sendCallStateMachineEvt({
+                type: 'E_CALL_CLEARED'
+              });
+            case 19:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee12, this, [[3, 11]]);
+      }));
+      function handleUnknownState(_x9) {
+        return _handleUnknownState.apply(this, arguments);
+      }
+      return handleUnknownState;
+    }()
+    /**
+     * Returns an error emitter callback method for handleCallErrors which can be used during
+     * midcall and call setup scenarios.
+     * Emits Call errors for UI Client
+     * Sends call error metrics
+     * Handles further state machine changes.
+     *
+     * @param errData - Instance of CallError.
+     */
+    )
+  }, {
+    key: "getEmitterCallback",
+    value: function getEmitterCallback(errData) {
+      var _this8 = this;
+      return function (error) {
+        switch (_this8.callStateMachine.state.value) {
+          case 'S_CALL_HOLD':
+            _this8.emit(_types3.CALL_EVENT_KEYS.HOLD_ERROR, error);
+            if (_this8.supplementaryServicesTimer) {
+              clearTimeout(_this8.supplementaryServicesTimer);
+              _this8.supplementaryServicesTimer = undefined;
+            }
+            _this8.submitCallErrorMetric(error);
+            _this8.sendCallStateMachineEvt({
+              type: 'E_CALL_ESTABLISHED',
+              data: errData
+            });
+            return;
+          case 'S_CALL_RESUME':
+            _this8.emit(_types3.CALL_EVENT_KEYS.RESUME_ERROR, error);
+            _this8.submitCallErrorMetric(error);
+            _this8.sendCallStateMachineEvt({
+              type: 'E_CALL_ESTABLISHED',
+              data: errData
+            });
+            return;
+          default:
+            _this8.emit(_types3.CALL_EVENT_KEYS.CALL_ERROR, error);
+            _this8.submitCallErrorMetric(error);
+            /* Disconnect call if it's not a midcall case */
+            /* istanbul ignore else */
+            if (!_this8.connected) {
+              _this8.sendMediaStateMachineEvt({
+                type: 'E_ROAP_ERROR',
+                data: errData
+              });
+            }
+        }
+      };
+    }
+
+    /**
+     * Handle Roap Established events.
+     *
+     * For outbound MediaOk , the message will be truthy as we need to send ROAP OK .
+     * For inbound MediaOK , we report it to Media-SDK  and transition our state.
+     * Both the cases should transition to Call Established state.
+     *
+     * @param context -.
+     * @param event - Roap Events.
+     */
+  }, {
+    key: "handleRoapEstablished",
+    value: (function () {
+      var _handleRoapEstablished = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13(context, event) {
+        var _this9 = this;
+        var _ref5, received, message, res, errData;
+        return _regenerator.default.wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              _Logger.default.info("handleRoapEstablished: ".concat(this.getCorrelationId(), "  "), {
+                file: _constants.CALL_FILE,
+                method: 'handleRoapEstablished'
+              });
+              _ref5 = event.data, received = _ref5.received, message = _ref5.message;
+              this.receivedRoapOKSeq = message.seq;
+              if (received) {
+                _context13.next = 22;
+                break;
+              }
+              _Logger.default.info('Sending Media Ok to the remote End', {
+                file: _constants.CALL_FILE,
+                method: 'handleRoapEstablished'
+              });
+              _context13.prev = 5;
+              if (this.callStateMachine.state.value === 'S_RECV_CALL_PROGRESS' || this.callStateMachine.state.value === 'S_SEND_CALL_SETUP') {
+                _Logger.default.info('Media negotiation completed before call connect. Setting media negotiation completed flag.', {
+                  file: _constants.CALL_FILE,
+                  method: 'handleRoapEstablished'
+                });
+                this.mediaNegotiationCompleted = true;
+              }
+              message.seq = this.seq;
+              _context13.next = 10;
+              return this.postMedia(message);
+            case 10:
+              res = _context13.sent;
+              _Logger.default.log("handleRoapEstablished: Response code: ".concat(res.statusCode), {
+                file: _constants.CALL_FILE,
+                method: 'handleRoapEstablished'
+              });
+              /* istanbul ignore else */
+              if (!this.earlyMedia && !this.mediaNegotiationCompleted) {
+                this.sendCallStateMachineEvt({
+                  type: 'E_CALL_ESTABLISHED'
+                });
+              }
+              _context13.next = 20;
+              break;
+            case 15:
+              _context13.prev = 15;
+              _context13.t0 = _context13["catch"](5);
+              _Logger.default.warn('Failed to process MediaOk request', {
+                file: _constants.CALL_FILE,
+                method: 'handleRoapEstablished'
+              });
+              errData = _context13.t0;
+              (0, _Utils.handleCallErrors)(this.getEmitterCallback(errData), _types.ERROR_LAYER.MEDIA, function (interval) {
+                /* Start retry if only it is a midcall case */
+                /* istanbul ignore else */
+                if (_this9.connected) {
+                  setTimeout(function () {
+                    _this9.sendMediaStateMachineEvt({
+                      type: 'E_ROAP_OK',
+                      data: event.data
+                    });
+                  }, interval * 1000);
+                }
+              }, this.getCorrelationId(), errData, this.handleRoapEstablished.name, _constants.CALL_FILE);
+            case 20:
+              _context13.next = 27;
+              break;
+            case 22:
+              _Logger.default.info('Notifying internal-media-core about ROAP OK message', {
+                file: _constants.CALL_FILE,
+                method: 'handleRoapEstablished'
+              });
+              message.seq = this.seq;
+
+              /* istanbul ignore else */
+              if (this.mediaConnection) {
+                this.mediaConnection.roapMessageReceived(message);
+              }
+              /* istanbul ignore else */
+              if (!this.earlyMedia) {
+                this.sendCallStateMachineEvt({
+                  type: 'E_CALL_ESTABLISHED'
+                });
+              }
+              if (this.remoteRoapMessage && this.remoteRoapMessage.seq > this.seq) {
+                if (this.remoteRoapMessage.messageType === 'OFFER_REQUEST') {
+                  this.sendMediaStateMachineEvt({
+                    type: 'E_RECV_ROAP_OFFER_REQUEST',
+                    data: this.remoteRoapMessage
+                  });
+                } else if (this.remoteRoapMessage.messageType === 'OFFER') {
+                  this.sendMediaStateMachineEvt({
+                    type: 'E_RECV_ROAP_OFFER',
+                    data: this.remoteRoapMessage
+                  });
+                }
+              }
+            case 27:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this, [[5, 15]]);
+      }));
+      function handleRoapEstablished(_x10, _x11) {
+        return _handleRoapEstablished.apply(this, arguments);
+      }
+      return handleRoapEstablished;
+    }()
+    /**
+     * Handle Roap Error events.
+     *
+     * @param context
+     * @param event - Roap Events.
+     */
+    )
+  }, {
+    key: "handleRoapError",
+    value: (function () {
+      var _handleRoapError = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14(context, event) {
+        var _this10 = this;
+        var message, res, errData;
+        return _regenerator.default.wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              _Logger.default.info("handleRoapError: ".concat(this.getCorrelationId()), {
+                file: _constants.CALL_FILE,
+                method: this.handleRoapError.name
+              });
+
+              /* if we receive ROAP_ERROR from internal-media-core , we post it to Mobius */
+              message = event.data;
+              /* istanbul ignore else */
+              if (!message) {
+                _context14.next = 15;
+                break;
+              }
+              _context14.prev = 3;
+              _context14.next = 6;
+              return this.postMedia(message);
+            case 6:
+              res = _context14.sent;
+              _Logger.default.info("Response code: ".concat(res.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleRoapError.name
+              });
+              _context14.next = 15;
+              break;
+            case 10:
+              _context14.prev = 10;
+              _context14.t0 = _context14["catch"](3);
+              _Logger.default.warn('Failed to communicate ROAP error to Webex Calling', {
+                file: _constants.CALL_FILE,
+                method: this.handleRoapError.name
+              });
+              errData = _context14.t0;
+              (0, _Utils.handleCallErrors)(function (error) {
+                _this10.emit(_types3.CALL_EVENT_KEYS.CALL_ERROR, error);
+                _this10.submitCallErrorMetric(error);
+              }, _types.ERROR_LAYER.MEDIA,
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              /* istanbul ignore next */
+              function (interval) {
+                return undefined;
+              }, this.getCorrelationId(), errData, this.handleRoapError.name, _constants.CALL_FILE);
+            case 15:
+              /* Only disconnect calls that are not yet connected yet */
+
+              if (!this.connected) {
+                _Logger.default.warn('Call failed due to media issue', {
+                  file: _constants.CALL_FILE,
+                  method: 'handleRoapError'
+                });
+                this.sendCallStateMachineEvt({
+                  type: 'E_UNKNOWN',
+                  data: {
+                    media: true
+                  }
+                });
+              }
+            case 16:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this, [[3, 10]]);
+      }));
+      function handleRoapError(_x12, _x13) {
+        return _handleRoapError.apply(this, arguments);
+      }
+      return handleRoapError;
+    }()
+    /**
+     * Handle Outgoing Roap Offer events.
+     *
+     * @param context
+     * @param event - Roap Events.
+     */
+    )
+  }, {
+    key: "handleOutgoingRoapOffer",
+    value: (function () {
+      var _handleOutgoingRoapOffer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15(context, event) {
+        var _this11 = this;
+        var message, res, errData;
+        return _regenerator.default.wrap(function _callee15$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              _Logger.default.info("handleOutgoingRoapOffer: ".concat(this.getCorrelationId()), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingRoapOffer.name
+              });
+              message = event.data;
+              if (message !== null && message !== void 0 && message.sdp) {
+                _context15.next = 6;
+                break;
+              }
+              _Logger.default.info('Initializing Offer...', {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingRoapOffer.name
+              });
+              this.mediaConnection.initiateOffer();
+              return _context15.abrupt("return");
+            case 6:
+              _context15.prev = 6;
+              _context15.next = 9;
+              return this.postMedia(message);
+            case 9:
+              res = _context15.sent;
+              _Logger.default.log("handleOutgoingRoapOffer: Response code: ".concat(res.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingRoapOffer.name
+              });
+              _context15.next = 18;
+              break;
+            case 13:
+              _context15.prev = 13;
+              _context15.t0 = _context15["catch"](6);
+              _Logger.default.warn('Failed to process MediaOk request', {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingRoapOffer.name
+              });
+              errData = _context15.t0;
+              (0, _Utils.handleCallErrors)(this.getEmitterCallback(errData), _types.ERROR_LAYER.MEDIA, function (interval) {
+                /* Start retry if only it is a midcall case */
+                if (_this11.connected) {
+                  setTimeout(function () {
+                    _this11.sendMediaStateMachineEvt({
+                      type: 'E_SEND_ROAP_OFFER',
+                      data: event.data
+                    });
+                  }, interval * 1000);
+                }
+              }, this.getCorrelationId(), errData, this.handleOutgoingRoapOffer.name, _constants.CALL_FILE);
+            case 18:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee15, this, [[6, 13]]);
+      }));
+      function handleOutgoingRoapOffer(_x14, _x15) {
+        return _handleOutgoingRoapOffer.apply(this, arguments);
+      }
+      return handleOutgoingRoapOffer;
+    }()
+    /**
+     * Handle Outgoing Roap Answer events.
+     *
+     * @param context
+     * @param event - Roap Events.
+     */
+    )
+  }, {
+    key: "handleOutgoingRoapAnswer",
+    value: (function () {
+      var _handleOutgoingRoapAnswer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16(context, event) {
+        var _this12 = this;
+        var message, res, errData;
+        return _regenerator.default.wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              _Logger.default.info("handleOutgoingRoapAnswer: ".concat(this.getCorrelationId()), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingRoapAnswer.name
+              });
+              message = event.data;
+              _context16.prev = 2;
+              message.seq = this.seq;
+              _context16.next = 6;
+              return this.postMedia(message);
+            case 6:
+              res = _context16.sent;
+              _Logger.default.log("handleOutgoingRoapAnswer: Response code: ".concat(res.statusCode), {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingRoapAnswer.name
+              });
+              _context16.next = 15;
+              break;
+            case 10:
+              _context16.prev = 10;
+              _context16.t0 = _context16["catch"](2);
+              _Logger.default.warn('Failed to send MediaAnswer request', {
+                file: _constants.CALL_FILE,
+                method: this.handleOutgoingRoapAnswer.name
+              });
+              errData = _context16.t0;
+              (0, _Utils.handleCallErrors)(this.getEmitterCallback(errData), _types.ERROR_LAYER.MEDIA, function (interval) {
+                /* Start retry if only it is a midcall case */
+                if (_this12.connected) {
+                  setTimeout(function () {
+                    _this12.sendMediaStateMachineEvt({
+                      type: 'E_SEND_ROAP_ANSWER',
+                      data: event.data
+                    });
+                  }, interval * 1000);
+                }
+              }, this.getCorrelationId(), errData, this.handleOutgoingRoapAnswer.name, _constants.CALL_FILE);
+            case 15:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this, [[2, 10]]);
+      }));
+      function handleOutgoingRoapAnswer(_x16, _x17) {
+        return _handleOutgoingRoapAnswer.apply(this, arguments);
+      }
+      return handleOutgoingRoapAnswer;
+    }()
+    /**
+     * Handle Incoming Roap Offer events.
+     *
+     * @param context
+     * @param event - Roap Events.
+     */
+    )
+  }, {
+    key: "handleIncomingRoapOffer",
+    value: function handleIncomingRoapOffer(context, event) {
+      _Logger.default.info("handleIncomingRoapOffer: ".concat(this.getCorrelationId()), {
+        file: _constants.CALL_FILE,
+        method: this.handleIncomingRoapOffer.name
+      });
+      var message = event.data;
+      this.remoteRoapMessage = message;
+      if (!this.mediaConnection) {
+        _Logger.default.info('Media connection is not up, buffer the remote offer for later handling', {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingRoapOffer.name
+        });
+        this.seq = message.seq;
+        _Logger.default.info("Setting Sequence No: ".concat(this.seq), {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingRoapOffer.name
+        });
+      } else if (this.receivedRoapOKSeq === message.seq - 2) {
+        _Logger.default.info('Waiting for Roap OK, buffer the remote offer for later handling', {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingRoapOffer.name
+        });
+        this.remoteRoapMessage = message;
+      } else {
+        _Logger.default.info('Handling new offer...', {
+          file: _constants.CALL_FILE,
+          method: this.handleIncomingRoapOffer.name
+        });
+        this.seq = message.seq;
+        /* istanbul ignore else */
+        if (this.mediaConnection) {
+          this.mediaConnection.roapMessageReceived(message);
+        }
+      }
+    }
+
+    /**
+     * Handle Incoming Roap Answer events.
+     *
+     * @param context
+     * @param event - Roap Events.
+     */
+  }, {
+    key: "handleIncomingRoapAnswer",
+    value: function handleIncomingRoapAnswer(context, event) {
+      _Logger.default.info("handleIncomingRoapAnswer: ".concat(this.getCorrelationId()), {
+        file: _constants.CALL_FILE,
+        method: this.handleIncomingRoapAnswer.name
+      });
+      var message = event.data;
+      this.remoteRoapMessage = message;
+      message.seq = this.seq;
+      /* istanbul ignore else */
+      if (this.mediaConnection) {
+        this.mediaConnection.roapMessageReceived(message);
+      }
+    }
+
+    /* istanbul ignore next */
+    /**
+     * Initialize Media Connection.
+     *
+     * @param settings -.
+     * @param settings.localAudioTrack - MediaStreamTrack.
+     * @param settings.debugId - String.
+     */
+  }, {
+    key: "initMediaConnection",
+    value: function initMediaConnection(localAudioTrack, debugId) {
+      var mediaConnection = new _internalMediaCore.RoapMediaConnection({
+        skipInactiveTransceivers: true,
+        iceServers: [],
+        sdpMunging: {
+          convertPort9to0: true,
+          addContentSlides: false
+        }
+      }, {
+        localTracks: {
+          audio: localAudioTrack
+        },
+        direction: {
+          audio: 'sendrecv',
+          video: 'inactive',
+          screenShareVideo: 'inactive'
+        }
+      }, debugId || "WebexCallSDK-".concat(this.correlationId));
+      this.mediaConnection = mediaConnection;
+    }
+  }, {
+    key: "sendCallStateMachineEvt",
+    value:
+    /**
+     * .
+     *
+     * @param event -.
+     */
+    function sendCallStateMachineEvt(event) {
+      this.callStateMachine.send(event);
+    }
+
+    /**
+     * .
+     *
+     * @param event -.
+     */
+  }, {
+    key: "sendMediaStateMachineEvt",
+    value: function sendMediaStateMachineEvt(event) {
+      this.mediaStateMachine.send(event);
+    }
+  }, {
+    key: "setDisconnectReason",
+    value:
+    /**
+     * Sets the Disconnect reason.
+     *
+     */
+    function setDisconnectReason() {
+      if (this.mediaInactivity) {
+        this.disconnectReason.code = _types4.DisconnectCode.MEDIA_INACTIVITY;
+        this.disconnectReason.cause = _types4.DisconnectCause.MEDIA_INACTIVITY;
+      } else if (this.connected || this.direction === _types2.CallDirection.OUTBOUND) {
+        this.disconnectReason.code = _types4.DisconnectCode.NORMAL;
+        this.disconnectReason.cause = _types4.DisconnectCause.NORMAL;
+      } else {
+        this.disconnectReason.code = _types4.DisconnectCode.BUSY;
+        this.disconnectReason.cause = _types4.DisconnectCause.BUSY;
+      }
+    }
+  }, {
+    key: "answer",
+    value: (
+    /**
+     * Answers the call with the provided local audio stream.
+     *
+     * @param localAudioStream - The local audio stream for the call.
+     */
+    function () {
+      var _answer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17(localAudioStream) {
+        var localAudioTrack;
+        return _regenerator.default.wrap(function _callee17$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              localAudioTrack = localAudioStream.outputStream.getAudioTracks()[0];
+              if (localAudioTrack) {
+                _context17.next = 6;
+                break;
+              }
+              _Logger.default.warn("Did not find a local track while answering the call ".concat(this.getCorrelationId()), {
+                file: _constants.CALL_FILE,
+                method: 'answer'
+              });
+              this.mediaInactivity = true;
+              this.sendCallStateMachineEvt({
+                type: 'E_SEND_CALL_DISCONNECT'
+              });
+              return _context17.abrupt("return");
+            case 6:
+              localAudioTrack.enabled = true;
+              if (!this.mediaConnection) {
+                this.initMediaConnection(localAudioTrack);
+                this.mediaRoapEventsListener();
+                this.mediaTrackListener();
+                this.outputTrackUpdateListener(localAudioStream);
+              }
+              if (this.callStateMachine.state.value === 'S_SEND_CALL_PROGRESS') {
+                this.sendCallStateMachineEvt({
+                  type: 'E_SEND_CALL_CONNECT'
+                });
+              } else {
+                _Logger.default.warn("Call cannot be answered because the state is : ".concat(this.callStateMachine.state.value), {
+                  file: _constants.CALL_FILE,
+                  method: 'answer'
+                });
+              }
+            case 9:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee17, this);
+      }));
+      function answer(_x18) {
+        return _answer.apply(this, arguments);
+      }
+      return answer;
+    }()
+    /**
+     * @param settings
+     * @param settings.localAudioTrack
+     */
+    )
+  }, {
+    key: "dial",
+    value: (function () {
+      var _dial = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18(localAudioStream) {
+        var localAudioTrack;
+        return _regenerator.default.wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              localAudioTrack = localAudioStream.outputStream.getAudioTracks()[0];
+              if (localAudioTrack) {
+                _context18.next = 6;
+                break;
+              }
+              _Logger.default.warn("Did not find a local track while dialing the call ".concat(this.getCorrelationId()), {
+                file: _constants.CALL_FILE,
+                method: 'dial'
+              });
+              this.deleteCb(this.getCorrelationId());
+              this.emit(_types3.CALL_EVENT_KEYS.DISCONNECT, this.getCorrelationId());
+              return _context18.abrupt("return");
+            case 6:
+              localAudioTrack.enabled = true;
+              if (!this.mediaConnection) {
+                this.initMediaConnection(localAudioTrack);
+                this.mediaRoapEventsListener();
+                this.mediaTrackListener();
+                this.outputTrackUpdateListener(localAudioStream);
+              }
+              if (this.mediaStateMachine.state.value === 'S_ROAP_IDLE') {
+                this.sendMediaStateMachineEvt({
+                  type: 'E_SEND_ROAP_OFFER'
+                });
+              } else {
+                _Logger.default.warn("Call cannot be dialed because the state is already : ".concat(this.mediaStateMachine.state.value), {
+                  file: _constants.CALL_FILE,
+                  method: 'dial'
+                });
+              }
+            case 9:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function dial(_x19) {
+        return _dial.apply(this, arguments);
+      }
+      return dial;
+    }())
+  }, {
+    key: "patch",
+    value: (
+    /**
+     * .
+     *
+     * @param state -.
+     */
+    function () {
+      var _patch = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19(state) {
+        return _regenerator.default.wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              _Logger.default.info("Send a PATCH for ".concat(state, " to Webex Calling"), {
+                file: _constants.CALL_FILE,
+                method: this.patch.name
+              });
+              return _context19.abrupt("return", this.webex.request({
+                // Sample uri: http://localhost/api/v1/calling/web/devices/{deviceid}/calls/{callid}
+
+                uri: "".concat(this.mobiusUrl).concat(_constants.DEVICES_ENDPOINT_RESOURCE, "/").concat(this.deviceId, "/").concat(_constants.CALLS_ENDPOINT_RESOURCE, "/").concat(this.callId),
+                method: _types2.HTTP_METHODS.PATCH,
+                service: _types2.ALLOWED_SERVICES.MOBIUS,
+                headers: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, this.webex.internal.device.url), _constants.SPARK_USER_AGENT, _constants.CALLING_USER_AGENT),
+                body: {
+                  device: {
+                    deviceId: this.deviceId,
+                    correlationId: this.correlationId
+                  },
+                  callId: this.callId,
+                  callState: state,
+                  inbandMedia: false // setting false for now
+                }
+              }));
+            case 2:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this);
+      }));
+      function patch(_x20) {
+        return _patch.apply(this, arguments);
+      }
+      return patch;
+    }()
+    /**
+     * Sends Supplementary request to Mobius.
+     *
+     * @param context - Context information related to a particular supplementary service.
+     * @param type - Type of Supplementary service.
+     */
+    )
+  }, {
+    key: "postSSRequest",
+    value: (function () {
+      var _postSSRequest = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20(context, type) {
+        var request, transferContext;
+        return _regenerator.default.wrap(function _callee20$(_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
+            case 0:
+              request = {
+                uri: "".concat(this.mobiusUrl).concat(_constants2.SERVICES_ENDPOINT),
+                method: _types2.HTTP_METHODS.POST,
+                service: _types2.ALLOWED_SERVICES.MOBIUS,
+                headers: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, this.webex.internal.device.url), _constants.SPARK_USER_AGENT, _constants.CALLING_USER_AGENT),
+                body: {
+                  device: {
+                    deviceId: this.deviceId,
+                    correlationId: this.correlationId
+                  },
+                  callId: this.callId
+                }
+              };
+              _context20.t0 = type;
+              _context20.next = _context20.t0 === _types3.SUPPLEMENTARY_SERVICES.HOLD ? 4 : _context20.t0 === _types3.SUPPLEMENTARY_SERVICES.RESUME ? 6 : _context20.t0 === _types3.SUPPLEMENTARY_SERVICES.TRANSFER ? 8 : 12;
+              break;
+            case 4:
+              request.uri = "".concat(request.uri, "/").concat(_constants.CALL_HOLD_SERVICE, "/").concat(_constants.HOLD_ENDPOINT);
+              return _context20.abrupt("break", 13);
+            case 6:
+              request.uri = "".concat(request.uri, "/").concat(_constants.CALL_HOLD_SERVICE, "/").concat(_constants.RESUME_ENDPOINT);
+              return _context20.abrupt("break", 13);
+            case 8:
+              request.uri = "".concat(request.uri, "/").concat(_constants.CALL_TRANSFER_SERVICE, "/").concat(_constants.TRANSFER_ENDPOINT);
+              transferContext = context;
+              if (transferContext.destination) {
+                (0, _assign.default)(request.body, {
+                  blindTransferContext: transferContext
+                });
+                (0, _assign.default)(request.body, {
+                  transferType: _types4.TransferType.BLIND
+                });
+              } /* istanbul ignore else */else if (transferContext.transferToCallId) {
+                (0, _assign.default)(request.body, {
+                  consultTransferContext: transferContext
+                });
+                (0, _assign.default)(request.body, {
+                  transferType: _types4.TransferType.CONSULT
+                });
+              }
+              return _context20.abrupt("break", 13);
+            case 12:
+              _Logger.default.warn("Unknown type for PUT request: ".concat(type), {
+                file: _constants.CALL_FILE,
+                method: this.postSSRequest.name
+              });
+            case 13:
+              return _context20.abrupt("return", this.webex.request(request));
+            case 14:
+            case "end":
+              return _context20.stop();
+          }
+        }, _callee20, this);
+      }));
+      function postSSRequest(_x21, _x22) {
+        return _postSSRequest.apply(this, arguments);
+      }
+      return postSSRequest;
+    }()
+    /**
+     * Sends Call status to Mobius.
+     */
+    )
+  }, {
+    key: "postStatus",
+    value: (function () {
+      var _postStatus = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
+        return _regenerator.default.wrap(function _callee21$(_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
+            case 0:
+              return _context21.abrupt("return", this.webex.request({
+                uri: "".concat(this.mobiusUrl).concat(_constants.DEVICES_ENDPOINT_RESOURCE, "/").concat(this.deviceId, "/").concat(_constants.CALLS_ENDPOINT_RESOURCE, "/").concat(this.callId, "/").concat(_constants.CALL_STATUS_RESOURCE),
+                method: _types2.HTTP_METHODS.POST,
+                service: _types2.ALLOWED_SERVICES.MOBIUS,
+                headers: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, this.webex.internal.device.url), _constants.SPARK_USER_AGENT, _constants.CALLING_USER_AGENT),
+                body: {
+                  device: {
+                    deviceId: this.deviceId,
+                    correlationId: this.correlationId
+                  },
+                  callId: this.callId
+                }
+              }));
+            case 1:
+            case "end":
+              return _context21.stop();
+          }
+        }, _callee21, this);
+      }));
+      function postStatus() {
+        return _postStatus.apply(this, arguments);
+      }
+      return postStatus;
+    }()
+    /**
+     * This function is called when user attempts to complete transfer(Blind or Consult)
+     * It checks if we have a valid transferCallId or transfer target and transfer type.
+     *
+     * @param transferType - Transfer type.
+     * @param transferCallId - Call Id where the current call will be merged for consult transfers.
+     * @param transferTarget - Destination for blind transfer.
+     */
+    )
+  }, {
+    key: "completeTransfer",
+    value: (function () {
+      var _completeTransfer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22(transferType, transferCallId, transferTarget) {
+        var _this13 = this;
+        var context, errData, _context22, _errData;
+        return _regenerator.default.wrap(function _callee22$(_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
+            case 0:
+              if (!(transferType === _types4.TransferType.BLIND && transferTarget)) {
+                _context23.next = 16;
+                break;
+              }
+              /* blind transfer */
+
+              _Logger.default.info("Initiating Blind transfer with : ".concat(transferTarget), {
+                file: _constants.CALL_FILE,
+                method: this.completeTransfer.name
+              });
+              context = {
+                transferorCallId: this.getCallId(),
+                destination: transferTarget
+              };
+              _context23.prev = 3;
+              _context23.next = 6;
+              return this.postSSRequest(context, _types3.SUPPLEMENTARY_SERVICES.TRANSFER);
+            case 6:
+              this.metricManager.submitCallMetric(_types5.METRIC_EVENT.CALL, _types5.TRANSFER_ACTION.BLIND, _types5.METRIC_TYPE.BEHAVIORAL, this.getCallId(), this.getCorrelationId(), undefined);
+              _context23.next = 14;
+              break;
+            case 9:
+              _context23.prev = 9;
+              _context23.t0 = _context23["catch"](3);
+              _Logger.default.warn("Blind Transfer failed for correlationId ".concat(this.getCorrelationId()), {
+                file: _constants.CALL_FILE,
+                method: this.completeTransfer.name
+              });
+              errData = _context23.t0;
+              (0, _Utils.handleCallErrors)(function (error) {
+                _this13.emit(_types3.CALL_EVENT_KEYS.TRANSFER_ERROR, error);
+                _this13.submitCallErrorMetric(error, _types5.TRANSFER_ACTION.BLIND);
+              }, _types.ERROR_LAYER.CALL_CONTROL,
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              /* istanbul ignore next */
+              function (interval) {
+                return undefined;
+              }, this.getCorrelationId(), errData, this.completeTransfer.name, _constants.CALL_FILE);
+            case 14:
+              _context23.next = 33;
+              break;
+            case 16:
+              if (!(transferType === _types4.TransferType.CONSULT && transferCallId)) {
+                _context23.next = 32;
+                break;
+              }
+              /* Consult transfer */
+
+              _Logger.default.info("Initiating Consult transfer between : ".concat(this.callId, " and ").concat(transferCallId), {
+                file: _constants.CALL_FILE,
+                method: this.completeTransfer.name
+              });
+              _context22 = {
+                transferorCallId: this.getCallId(),
+                transferToCallId: transferCallId
+              };
+              _context23.prev = 19;
+              _context23.next = 22;
+              return this.postSSRequest(_context22, _types3.SUPPLEMENTARY_SERVICES.TRANSFER);
+            case 22:
+              this.metricManager.submitCallMetric(_types5.METRIC_EVENT.CALL, _types5.TRANSFER_ACTION.CONSULT, _types5.METRIC_TYPE.BEHAVIORAL, this.getCallId(), this.getCorrelationId(), undefined);
+              _context23.next = 30;
+              break;
+            case 25:
+              _context23.prev = 25;
+              _context23.t1 = _context23["catch"](19);
+              _Logger.default.warn("Consult Transfer failed for correlationId ".concat(this.getCorrelationId()), {
+                file: _constants.CALL_FILE,
+                method: this.completeTransfer.name
+              });
+              _errData = _context23.t1;
+              (0, _Utils.handleCallErrors)(function (error) {
+                _this13.emit(_types3.CALL_EVENT_KEYS.TRANSFER_ERROR, error);
+                _this13.submitCallErrorMetric(error, _types5.TRANSFER_ACTION.CONSULT);
+              }, _types.ERROR_LAYER.CALL_CONTROL,
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              /* istanbul ignore next */
+              function (interval) {
+                return undefined;
+              }, this.getCorrelationId(), _errData, this.completeTransfer.name, _constants.CALL_FILE);
+            case 30:
+              _context23.next = 33;
+              break;
+            case 32:
+              _Logger.default.warn("Invalid information received, transfer failed for correlationId: ".concat(this.getCorrelationId()), {
+                file: _constants.CALL_FILE,
+                method: this.completeTransfer.name
+              });
+            case 33:
+            case "end":
+              return _context23.stop();
+          }
+        }, _callee22, this, [[3, 9], [19, 25]]);
+      }));
+      function completeTransfer(_x23, _x24, _x25) {
+        return _completeTransfer.apply(this, arguments);
+      }
+      return completeTransfer;
+    }()
+    /**
+     *
+     */
+    )
+  }, {
+    key: "getCallStats",
+    value: (function () {
+      var _getCallStats = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee23() {
+        var stats;
+        return _regenerator.default.wrap(function _callee23$(_context24) {
+          while (1) switch (_context24.prev = _context24.next) {
+            case 0:
+              _context24.prev = 0;
+              _context24.next = 3;
+              return this.mediaConnection.getStats();
+            case 3:
+              stats = _context24.sent;
+              _context24.next = 9;
+              break;
+            case 6:
+              _context24.prev = 6;
+              _context24.t0 = _context24["catch"](0);
+              _Logger.default.warn('Stats collection failed, using dummy stats', {
+                file: _constants.CALL_FILE,
+                method: this.getCallStats.name
+              });
+            case 9:
+              return _context24.abrupt("return", (0, _Utils.parseMediaQualityStatistics)(stats));
+            case 10:
+            case "end":
+              return _context24.stop();
+          }
+        }, _callee23, this, [[0, 6]]);
+      }));
+      function getCallStats() {
+        return _getCallStats.apply(this, arguments);
+      }
+      return getCallStats;
+    }()
+    /**
+     * .
+     *
+     * @param roapMessage -.
+     */
+    )
+  }, {
+    key: "postMedia",
+    value: (function () {
+      var _postMedia = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee24(roapMessage) {
+        return _regenerator.default.wrap(function _callee24$(_context25) {
+          while (1) switch (_context25.prev = _context25.next) {
+            case 0:
+              _Logger.default.log('Posting message to Webex Calling', {
+                file: _constants.CALL_FILE,
+                method: this.postMedia.name
+              });
+              return _context25.abrupt("return", this.webex.request({
+                uri: "".concat(this.mobiusUrl).concat(_constants.DEVICES_ENDPOINT_RESOURCE, "/").concat(this.deviceId, "/").concat(_constants.CALLS_ENDPOINT_RESOURCE, "/").concat(this.callId, "/").concat(_constants.MEDIA_ENDPOINT_RESOURCE),
+                method: _types2.HTTP_METHODS.POST,
+                service: _types2.ALLOWED_SERVICES.MOBIUS,
+                headers: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, this.webex.internal.device.url), _constants.SPARK_USER_AGENT, _constants.CALLING_USER_AGENT),
+                body: {
+                  device: {
+                    deviceId: this.deviceId,
+                    correlationId: this.correlationId
+                  },
+                  callId: this.callId,
+                  localMedia: {
+                    roap: roapMessage,
+                    mediaId: (0, _uuid.v4)()
+                  }
+                }
+              }));
+            case 2:
+            case "end":
+              return _context25.stop();
+          }
+        }, _callee24, this);
+      }));
+      function postMedia(_x26) {
+        return _postMedia.apply(this, arguments);
+      }
+      return postMedia;
+    }()
+    /* istanbul ignore next */
+    /**
+     * Setup a listener for roap events emitted by the media sdk.
+     */
+    )
+  }, {
+    key: "mediaRoapEventsListener",
+    value: function mediaRoapEventsListener() {
+      var _this14 = this;
+      this.mediaConnection.on(_internalMediaCore.Event.ROAP_MESSAGE_TO_SEND,
+      /*#__PURE__*/
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      function () {
+        var _ref6 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee25(event) {
+          var _event$roapMessage, _event$roapMessage2;
+          var mediaOk, sdpVideoPortZero;
+          return _regenerator.default.wrap(function _callee25$(_context26) {
+            while (1) switch (_context26.prev = _context26.next) {
+              case 0:
+                _Logger.default.info("ROAP message to send (rcv from MEDIA-SDK) :\n          \n type:  ".concat((_event$roapMessage = event.roapMessage) === null || _event$roapMessage === void 0 ? void 0 : _event$roapMessage.messageType, ", seq: ").concat(event.roapMessage.seq, " , version: ").concat(event.roapMessage.version), {});
+                _Logger.default.info("SDP message to send : \n ".concat((_event$roapMessage2 = event.roapMessage) === null || _event$roapMessage2 === void 0 ? void 0 : _event$roapMessage2.sdp), {
+                  file: _constants.CALL_FILE,
+                  method: _this14.mediaRoapEventsListener.name
+                });
+                _context26.t0 = event.roapMessage.messageType;
+                _context26.next = _context26.t0 === _types4.RoapScenario.OK ? 5 : _context26.t0 === _types4.RoapScenario.OFFER ? 8 : _context26.t0 === _types4.RoapScenario.ANSWER ? 13 : _context26.t0 === _types4.RoapScenario.ERROR ? 16 : _context26.t0 === _types4.RoapScenario.OFFER_RESPONSE ? 18 : 21;
+                break;
+              case 5:
+                mediaOk = {
+                  received: false,
+                  message: event.roapMessage
+                };
+                _this14.sendMediaStateMachineEvt({
+                  type: 'E_ROAP_OK',
+                  data: mediaOk
+                });
+                return _context26.abrupt("break", 21);
+              case 8:
+                // TODO: Remove these after the Media-Core adds the fix
+                sdpVideoPortZero = event.roapMessage.sdp.replace(/^m=(video) (?:\d+) /gim, 'm=$1 0 ');
+                event.roapMessage.sdp = sdpVideoPortZero;
+                _this14.localRoapMessage = event.roapMessage;
+                _this14.sendCallStateMachineEvt({
+                  type: 'E_SEND_CALL_SETUP',
+                  data: event.roapMessage
+                });
+                return _context26.abrupt("break", 21);
+              case 13:
+                _this14.localRoapMessage = event.roapMessage;
+                _this14.sendMediaStateMachineEvt({
+                  type: 'E_SEND_ROAP_ANSWER',
+                  data: event.roapMessage
+                });
+                return _context26.abrupt("break", 21);
+              case 16:
+                _this14.sendMediaStateMachineEvt({
+                  type: 'E_ROAP_ERROR',
+                  data: event.roapMessage
+                });
+                return _context26.abrupt("break", 21);
+              case 18:
+                _this14.localRoapMessage = event.roapMessage;
+                _this14.sendMediaStateMachineEvt({
+                  type: 'E_SEND_ROAP_OFFER',
+                  data: event.roapMessage
+                });
+                return _context26.abrupt("break", 21);
+              case 21:
+              case "end":
+                return _context26.stop();
+            }
+          }, _callee25);
+        }));
+        return function (_x27) {
+          return _ref6.apply(this, arguments);
+        };
+      }());
+    }
+
+    /* istanbul ignore next */
+    /**
+     * Setup a listener for remote track added event emitted by the media sdk.
+     */
+  }, {
+    key: "mediaTrackListener",
+    value: function mediaTrackListener() {
+      var _this15 = this;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.mediaConnection.on(_internalMediaCore.Event.REMOTE_TRACK_ADDED, function (e) {
+        if (e.type === _types3.MEDIA_CONNECTION_EVENT_KEYS.MEDIA_TYPE_AUDIO) {
+          _this15.emit(_types3.CALL_EVENT_KEYS.REMOTE_MEDIA, e.track);
+        }
+      });
+    }
+  }, {
+    key: "outputTrackUpdateListener",
+    value: function outputTrackUpdateListener(localAudioStream) {
+      var _this16 = this;
+      localAudioStream.on(_internalMediaCore.LocalStreamEventNames.OutputTrackChange, function (track) {
+        _this16.mediaConnection.updateLocalTracks({
+          audio: track
+        });
+      });
+    }
+  }, {
+    key: "delete",
+    value: function () {
+      var _delete2 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee26() {
+        var disconnectMetrics;
+        return _regenerator.default.wrap(function _callee26$(_context27) {
+          while (1) switch (_context27.prev = _context27.next) {
+            case 0:
+              _context27.next = 2;
+              return this.getCallStats();
+            case 2:
+              disconnectMetrics = _context27.sent;
+              return _context27.abrupt("return", this.webex.request({
+                uri: "".concat(this.mobiusUrl).concat(_constants.DEVICES_ENDPOINT_RESOURCE, "/").concat(this.deviceId, "/").concat(_constants.CALLS_ENDPOINT_RESOURCE, "/").concat(this.callId),
+                method: _types2.HTTP_METHODS.DELETE,
+                service: _types2.ALLOWED_SERVICES.MOBIUS,
+                headers: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, this.webex.internal.device.url), _constants.SPARK_USER_AGENT, _constants.CALLING_USER_AGENT),
+                body: {
+                  device: {
+                    deviceId: this.deviceId,
+                    correlationId: this.correlationId
+                  },
+                  callId: this.callId,
+                  metrics: disconnectMetrics,
+                  causecode: this.disconnectReason.code,
+                  cause: this.disconnectReason.cause
+                }
+              }));
+            case 4:
+            case "end":
+              return _context27.stop();
+          }
+        }, _callee26, this);
+      }));
+      function _delete() {
+        return _delete2.apply(this, arguments);
+      }
+      return _delete;
+    }()
+    /**
+     * @param state - Current state of the call state machine.
+     * @param error - Error object containing the message and type.
+     * @param transferMetricAction - Metric action type incase of a transfer metric.
+     */
+  }, {
+    key: "submitCallErrorMetric",
+    value: function submitCallErrorMetric(error, transferMetricAction) {
+      if (error.getCallError().errorLayer === _types.ERROR_LAYER.CALL_CONTROL) {
+        this.metricManager.submitCallMetric(_types5.METRIC_EVENT.CALL_ERROR, transferMetricAction || this.callStateMachine.state.value.toString(), _types5.METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, error);
+      } else {
+        var _this$remoteRoapMessa2;
+        this.metricManager.submitMediaMetric(_types5.METRIC_EVENT.MEDIA_ERROR, this.mediaStateMachine.state.value.toString(), _types5.METRIC_TYPE.BEHAVIORAL, this.callId, this.correlationId, this.localRoapMessage.sdp, (_this$remoteRoapMessa2 = this.remoteRoapMessage) === null || _this$remoteRoapMessa2 === void 0 ? void 0 : _this$remoteRoapMessa2.sdp, error);
+      }
+    }
+
+    /**
+     * Handler for mid call events.
+     *
+     * @param event - Midcall Events from Mobius.
+     */
+  }, {
+    key: "handleMidCallEvent",
+    value: function handleMidCallEvent(event) {
+      var eventType = event.eventType,
+        eventData = event.eventData;
+      switch (eventType) {
+        case _types4.MidCallEventType.CALL_INFO:
+          {
+            _Logger.default.log("Received Midcall CallInfo Event for correlationId : ".concat(this.correlationId), {
+              file: _constants.CALL_FILE,
+              method: 'handleMidCallEvent'
+            });
+            var callerData = eventData;
+            this.startCallerIdResolution(callerData.callerId);
+            break;
+          }
+        case _types4.MidCallEventType.CALL_STATE:
+          {
+            _Logger.default.log("Received Midcall call event for correlationId : ".concat(this.correlationId), {
+              file: _constants.CALL_FILE,
+              method: 'handleMidCallEvent'
+            });
+            var data = eventData;
+
+            /* Emit Events as per the state.
+             * We will enter this state only when media negotiation is done
+             * So, it's safe to emit events from here.
+             */
+
+            switch (data.callState) {
+              case _types3.MOBIUS_MIDCALL_STATE.HELD:
+                {
+                  _Logger.default.log("Call is successfully held : ".concat(this.correlationId), {
+                    file: _constants.CALL_FILE,
+                    method: 'handleMidCallEvent'
+                  });
+                  this.emit(_types3.CALL_EVENT_KEYS.HELD, this.correlationId);
+                  this.held = true;
+                  if (this.supplementaryServicesTimer) {
+                    clearTimeout(this.supplementaryServicesTimer);
+                    this.supplementaryServicesTimer = undefined;
+                  }
+                  break;
+                }
+              case _types3.MOBIUS_MIDCALL_STATE.CONNECTED:
+                {
+                  _Logger.default.log("Call is successfully resumed : ".concat(this.correlationId), {
+                    file: _constants.CALL_FILE,
+                    method: 'handleMidCallEvent'
+                  });
+                  this.emit(_types3.CALL_EVENT_KEYS.RESUMED, this.correlationId);
+                  this.held = false;
+                  if (this.supplementaryServicesTimer) {
+                    clearTimeout(this.supplementaryServicesTimer);
+                    this.supplementaryServicesTimer = undefined;
+                  }
+                  break;
+                }
+              default:
+                {
+                  _Logger.default.warn("Unknown Supplementary service state: ".concat(data.callState, " for correlationId : ").concat(this.correlationId), {
+                    file: _constants.CALL_FILE,
+                    method: 'handleMidCallEvent'
+                  });
+                }
+            }
+            break;
+          }
+        default:
+          {
+            _Logger.default.warn("Unknown Midcall type: ".concat(eventType, " for correlationId : ").concat(this.correlationId), {
+              file: _constants.CALL_FILE,
+              method: 'handleMidCallEvent'
+            });
+          }
+      }
+    }
+  }, {
+    key: "startCallerIdResolution",
+    value:
+    /**
+     * .
+     *
+     * @param callerInfo
+     */
+    function startCallerIdResolution(callerInfo) {
+      this.callerInfo = this.callerId.fetchCallerDetails(callerInfo);
+    }
+
+    /**
+     * Sends digit over the established call.
+     *
+     * @param tone - DTMF tones.
+     */
+  }, {
+    key: "sendDigit",
+    value: function sendDigit(tone) {
+      /* istanbul ignore else */
+      try {
+        _Logger.default.info("Sending digit : ".concat(tone), {
+          file: _constants.CALL_FILE,
+          method: 'sendDigit'
+        });
+        this.mediaConnection.insertDTMF(tone);
+      } catch (e) {
+        _Logger.default.warn("Unable to send digit on call: ".concat(e.message), {
+          file: _constants.CALL_FILE,
+          method: 'sendDigit'
+        });
+      }
+    }
+  }, {
+    key: "setBroadworksCorrelationInfo",
+    value:
+    /**
+     * @param broadworksCorrelationInfo
+     */
+    function setBroadworksCorrelationInfo(broadworksCorrelationInfo) {
+      this.broadworksCorrelationInfo = broadworksCorrelationInfo;
+    }
+
+    /**
+     *
+     */
+  }, {
+    key: "getBroadworksCorrelationInfo",
+    value: function getBroadworksCorrelationInfo() {
+      return this.broadworksCorrelationInfo;
+    }
+
+    /**
+     * Get call stats for an active call.
+     *
+     * @returns Promise<CallRtpStats> Call Stats.
+     */
+  }, {
+    key: "getCallRtpStats",
+    value: function getCallRtpStats() {
+      return this.getCallStats();
+    }
+  }]);
+  return Call;
+}(_impl.Eventing);
+/**
+ * @param activeUrl
+ * @param webex -.
+ * @param dest -.
+ * @param dir -.
+ * @param deviceId -.
+ * @param lineId -.
+ * @param serverCb
+ * @param deleteCb
+ * @param indicator - Service Indicator.
+ */
+var createCall = exports.createCall = function createCall(activeUrl, webex, dest, dir, deviceId, lineId, deleteCb, indicator) {
+  return new Call(activeUrl, webex, dest, dir, deviceId, lineId, deleteCb, indicator);
+};
+//# sourceMappingURL=call.js.map