@wazo/sdk 0.38.22 → 0.39.0-beta.10

package/src/domain/Phone/{WebRTCPhone.js → WebRTCPhone.ts}

@@ -1,12 +1,10 @@
 /* eslint-disable no-param-reassign */
 /* eslint-disable no-underscore-dangle */
-// @flow
 import type { Message } from 'sip.js/lib/api/message';
-import type { Session } from 'sip.js/lib/core/session';
-import { Invitation } from 'sip.js/lib/api/invitation';
 import { SessionState } from 'sip.js/lib/api/session-state';
 import type { IncomingRequestMessage } from 'sip.js/lib/core/messages/incoming-request-message';
-
+import { OutgoingInviteRequest } from 'sip.js/lib/core';
+import { Inviter, Invitation, Session } from 'sip.js/lib/api';
 import CallSession from '../CallSession';
 import type { Phone, AvailablePhoneOptions } from './Phone';
 import WazoWebRTCClient from '../../web-rtc-client';
@@ -55,68 +53,26 @@ export const ON_CHAT = 'phone/ON_CHAT';
 export const ON_SIGNAL = 'phone/ON_SIGNAL';
 export const ON_DISCONNECTED = 'onDisconnected';
 export const ON_EARLY_MEDIA = 'onEarlyMedia';
-
 export const MESSAGE_TYPE_CHAT = 'message/TYPE_CHAT';
 export const MESSAGE_TYPE_SIGNAL = 'message/TYPE_SIGNAL';
-
-export const events = [
-  ON_USER_AGENT,
-  ON_REGISTERED,
-  ON_UNREGISTERED,
-  ON_PROGRESS,
-  ON_CALL_ACCEPTED,
-  ON_CALL_ANSWERED,
-  ON_CALL_INCOMING,
-  ON_CALL_OUTGOING,
-  ON_CALL_MUTED,
-  ON_CALL_UNMUTED,
-  ON_CALL_RESUMED,
-  ON_CALL_HELD,
-  ON_CALL_UNHELD,
-  ON_CAMERA_DISABLED,
-  ON_CALL_FAILED,
-  ON_CALL_ENDED,
-  ON_CALL_REJECTED,
-  ON_MESSAGE,
-  ON_REINVITE,
-  ON_TRACK,
-  ON_AUDIO_STREAM,
-  ON_VIDEO_STREAM,
-  ON_REMOVE_STREAM,
-  ON_SHARE_SCREEN_ENDED,
-  ON_TERMINATE_SOUND,
-  ON_PLAY_RING_SOUND,
-  ON_PLAY_INBOUND_CALL_SIGNAL_SOUND,
-  ON_PLAY_HANGUP_SOUND,
-  ON_PLAY_PROGRESS_SOUND,
-  ON_VIDEO_INPUT_CHANGE,
-  ON_SHARE_SCREEN_STARTED,
-  ON_CALL_ERROR,
-  ON_CHAT,
-  ON_SIGNAL,
-  ON_NETWORK_STATS,
-  ON_DISCONNECTED,
-  ON_EARLY_MEDIA,
-];
-
+export const events = [ON_USER_AGENT, ON_REGISTERED, ON_UNREGISTERED, ON_PROGRESS, ON_CALL_ACCEPTED, ON_CALL_ANSWERED, ON_CALL_INCOMING, ON_CALL_OUTGOING, ON_CALL_MUTED, ON_CALL_UNMUTED, ON_CALL_RESUMED, ON_CALL_HELD, ON_CALL_UNHELD, ON_CAMERA_DISABLED, ON_CALL_FAILED, ON_CALL_ENDED, ON_CALL_REJECTED, ON_MESSAGE, ON_REINVITE, ON_TRACK, ON_AUDIO_STREAM, ON_VIDEO_STREAM, ON_REMOVE_STREAM, ON_SHARE_SCREEN_ENDED, ON_TERMINATE_SOUND, ON_PLAY_RING_SOUND, ON_PLAY_INBOUND_CALL_SIGNAL_SOUND, ON_PLAY_HANGUP_SOUND, ON_PLAY_PROGRESS_SOUND, ON_VIDEO_INPUT_CHANGE, ON_SHARE_SCREEN_STARTED, ON_CALL_ERROR, ON_CHAT, ON_SIGNAL, ON_NETWORK_STATS, ON_DISCONNECTED, ON_EARLY_MEDIA];
 const logger = IssueReporter.loggerFor('webrtc-phone');
-
 export default class WebRTCPhone extends Emitter implements Phone {
   client: WazoWebRTCClient;
 
   allowVideo: boolean;
 
-  callSessions: { [string]: CallSession };
+  callSessions: Record<string, CallSession>;
 
   incomingSessions: string[];
 
-  currentSipSession: Session;
+  currentSipSession: Invitation | Inviter | undefined;
 
-  currentCallSession: ?CallSession;
+  currentCallSession: CallSession | null | undefined;
 
-  audioOutputDeviceId: ?string;
+  audioOutputDeviceId: string | null | undefined;
 
-  audioRingDeviceId: ?string;
+  audioRingDeviceId: string | null | undefined;
 
   audioOutputVolume: number;
 
@@ -124,26 +80,20 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
   ringingEnabled: boolean;
 
-  acceptedSessions: Object;
+  acceptedSessions: Record<string, any>;
 
-  rejectedSessions: Object;
+  rejectedSessions: Record<string, any>;
 
-  ignoredSessions: Object;
+  ignoredSessions: Record<string, any>;
 
-  currentScreenShare: Object;
+  currentScreenShare: Record<string, any> | null;
 
-  lastScreenShare: Object;
+  lastScreenShare: Record<string, any> | null;
 
   shouldSendReinvite: boolean;
 
-  constructor(
-    client: WazoWebRTCClient,
-    audioOutputDeviceId: ?string,
-    allowVideo: boolean = false,
-    audioRingDeviceId?: string,
-  ) {
+  constructor(client: WazoWebRTCClient, audioOutputDeviceId: string | null | undefined, allowVideo = false, audioRingDeviceId?: string) {
     super();
-
     this.client = client;
     this.allowVideo = allowVideo;
     this.callSessions = {};
@@ -154,25 +104,28 @@ export default class WebRTCPhone extends Emitter implements Phone {
     this.incomingSessions = [];
     this.ringingEnabled = true;
     this.shouldSendReinvite = false;
-
     this.bindClientEvents();
-
     this.acceptedSessions = {};
     this.rejectedSessions = {};
     this.ignoredSessions = {};
   }
 
   register() {
+    logger.info('WebRTC register', { client: !!this.client });
     if (!this.client) {
       return Promise.resolve();
     }
 
     return this.client.register().then(() => {
+      logger.info('WebRTC register, registered');
       return this.bindClientEvents();
     }).catch(error => {
       // Avoid exception on `t.server.scheme` in sip transport when losing the webrtc socket connection
       console.error('register error', error, error.message, error.stack);
-      logger.error('WebRTC register error', { message: error.message, stack: error.stack });
+      logger.error('WebRTC register error', {
+        message: error.message,
+        stack: error.stack,
+      });
     });
   }
 
@@ -180,6 +133,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     if (!this.client || !this.client.isRegistered()) {
       return null;
     }
+
     return this.client.unregister();
   }
 
@@ -187,6 +141,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     if (!this.client) {
       return;
     }
+
     logger.info('WebRTC phone stop');
     this.client.stop();
   }
@@ -199,8 +154,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return true;
   }
 
-  async sendReinvite(callSession: ?CallSession, constraints: ?Object = null, conference: boolean = false,
-    audioOnly: boolean = false, iceRestart: boolean = false) {
+  async sendReinvite(callSession: CallSession | null | undefined, constraints: Record<string, any> | null | undefined = null, conference = false, audioOnly = false, iceRestart = false): Promise<OutgoingInviteRequest | void> {
     const sipSession = this.findSipSession(callSession);
     logger.info('WebRTC phone - send reinvite', {
       sessionId: sipSession ? sipSession.id : null,
@@ -211,24 +165,25 @@ export default class WebRTCPhone extends Emitter implements Phone {
     });
 
     if (!sipSession) {
-      return false;
+      return;
     }
 
-    // $FlowFixMe
-    const shouldScreenShare = constraints && constraints.screen;
-    const isUpgrade = shouldScreenShare || (constraints && constraints.video);
+    const shouldScreenShare = constraints?.screen;
+    const isUpgrade = shouldScreenShare || constraints?.video;
 
     // Downgrade
     if (constraints && !isUpgrade) {
       // No reinvite needed
       this._downgradeToAudio(callSession);
-      return false;
+
+      return;
     }
 
     if (isUpgrade) {
       const shouldReinvite = await this._upgradeToVideo(callSession, constraints, conference);
+
       if (!shouldReinvite) {
-        return false;
+        return;
       }
     }
 
@@ -236,11 +191,15 @@ export default class WebRTCPhone extends Emitter implements Phone {
   }
 
   getUserAgent() {
-    return (this.client && this.client.config && this.client.config.userAgentString) || 'webrtc-phone';
+    return this.client?.config?.userAgentString || 'webrtc-phone';
   }
 
   startHeartbeat() {
-    logger.info('WebRTC phone - start heartbeat', { client: !!this.client, hasHeartbeat: this.client.hasHeartbeat() });
+    logger.info('WebRTC phone - start heartbeat', {
+      client: !!this.client,
+      hasHeartbeat: this.client.hasHeartbeat(),
+    });
+
     if (!this.client || this.client.hasHeartbeat()) {
       return;
     }
@@ -249,7 +208,10 @@ export default class WebRTCPhone extends Emitter implements Phone {
   }
 
   stopHeartbeat() {
-    logger.info('WebRTC phone - stopHeartbeat', { client: !!this.client });
+    logger.info('WebRTC phone - stopHeartbeat', {
+      client: !!this.client,
+    });
+
     if (!this.client) {
       return;
     }
@@ -257,19 +219,23 @@ export default class WebRTCPhone extends Emitter implements Phone {
     this.client.stopHeartbeat();
   }
 
-  setOnHeartbeatTimeout(cb: Function) {
+  setOnHeartbeatTimeout(cb: (...args: Array<any>) => any) {
     this.client.setOnHeartbeatTimeout(cb);
   }
 
-  setOnHeartbeatCallback(cb: Function) {
+  setOnHeartbeatCallback(cb: (...args: Array<any>) => any) {
     this.client.setOnHeartbeatCallback(cb);
   }
 
   reconnect() {
-    logger.info('WebRTC phone - reconnect', { client: !!this.client });
+    logger.info('WebRTC phone - reconnect', {
+      client: !!this.client,
+    });
+
     if (!this.client) {
       return;
     }
+
     this.client.attemptReconnection();
   }
 
@@ -291,6 +257,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     if (!this.client) {
       return Promise.reject(new Error('No webrtc client'));
     }
+
     return this.client.onConnect();
   }
 
@@ -298,21 +265,26 @@ export default class WebRTCPhone extends Emitter implements Phone {
     if (!this.client) {
       return Promise.reject(new Error('No webrtc client'));
     }
+
     return this.client.onDisconnect();
   }
 
-  _downgradeToAudio(callSession: ?CallSession, withMessage: boolean = true) {
+  _downgradeToAudio(callSession: CallSession | null | undefined, withMessage = true) {
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return false;
     }
 
-    logger.info('Downgrade to video', { id: callSession ? callSession.getId() : null, withMessage });
-
+    logger.info('Downgrade to video', {
+      id: callSession ? callSession.getId() : null,
+      withMessage,
+    });
     this.client.downgradeToAudio(sipSession);
 
     if (callSession) {
       callSession.cameraEnabled = false;
+
       this._updateCallSession(callSession);
     }
 
@@ -324,8 +296,9 @@ export default class WebRTCPhone extends Emitter implements Phone {
   }
 
   // Returns true if we need to send a re-INVITE request
-  async _upgradeToVideo(callSession: ?CallSession, constraints: ?Object, isConference: boolean): Promise<boolean> {
+  async _upgradeToVideo(callSession: CallSession | null | undefined, constraints: Record<string, any>, isConference: boolean): Promise<boolean> {
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return Promise.resolve(false);
     }
@@ -335,16 +308,16 @@ export default class WebRTCPhone extends Emitter implements Phone {
       constraints,
       isConference,
     });
-
     const shouldScreenShare = constraints && !!constraints.screen;
     const desktop = constraints && constraints.desktop;
     const options = sipSession.sessionDescriptionHandlerOptionsReInvite;
-    const wasAudioOnly = options && options.audioOnly;
-
+    // @ts-ignore
+    const wasAudioOnly = options?.audioOnly;
     const newStream = await this.client.upgradeToVideo(sipSession, constraints, isConference);
 
     if (callSession) {
       callSession.cameraEnabled = true;
+
       this._updateCallSession(callSession);
     }
 
@@ -368,13 +341,12 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return false;
   }
 
-  _sendReinviteMessage(callSession: ?CallSession, isUpgrade: boolean) {
+  _sendReinviteMessage(callSession: CallSession | null | undefined, isUpgrade: boolean) {
     const sipSession = this.findSipSession(callSession);
     logger.info('Sending reinvite message', {
       id: callSession ? callSession.getId() : null,
       isUpgrade,
     });
-
     // Have to send the message after a delay due to latency to update the remote peer
     setTimeout(() => {
       this.sendMessage(sipSession, JSON.stringify({
@@ -382,7 +354,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
         content: {
           type: ON_MESSAGE_TRACK_UPDATED,
           update: isUpgrade ? 'upgrade' : 'downgrade',
-          sipCallId: this.getSipSessionId(sipSession),
+          sipCallId: sipSession && this.getSipSessionId(sipSession),
           callId: callSession ? callSession.callId : null,
           number: callSession ? callSession.number : null,
           callerNumber: callSession ? callSession.callerNumber : null,
@@ -391,18 +363,23 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }, 2500);
   }
 
-  _bindEvents(sipSession: Session) {
-    if (sipSession._onCancel) {
+  _bindEvents(sipSession: Invitation | Inviter) {
+    const sipSessionId = this.getSipSessionId(sipSession);
+
+    if (sipSession instanceof Invitation) {
       // Monkey patch to know when canceled with the CANCEL message
       const onCancel = sipSession._onCancel.bind(sipSession);
-      sipSession._onCancel = (message: IncomingRequestMessage) => {
-        logger.trace('on sip session canceled', { callId: message.callId });
 
+      sipSession._onCancel = (message: IncomingRequestMessage) => {
+        logger.trace('on sip session canceled', {
+          callId: message.callId,
+          sipSessionId,
+        });
         onCancel(message);
         const elsewhere = message.data.indexOf('cause=26') !== -1 && message.data.indexOf('completed elsewhere') !== -1;
         const callSession = this._createCallSession(sipSession);
-        delete this.callSessions[callSession.getId()];
 
+        delete this.callSessions[sipSessionId];
         this.eventEmitter.emit(ON_CALL_CANCELED, callSession, elsewhere);
       };
     } else if (sipSession instanceof Invitation) {
@@ -416,29 +393,36 @@ export default class WebRTCPhone extends Emitter implements Phone {
             // No need to trigger progress for an invitation (eg: when we answer the call).
             return;
           }
+
           // When receiving a progress event, we know we are the caller so we have to force incoming to false
-          return this.eventEmitter.emit(
-            ON_PROGRESS,
-            this._createCallSession(sipSession, null, { incoming: false, ringing: true }),
-            this.audioOutputDeviceId,
-            this.audioOutputVolume,
-          );
-        case SessionState.Terminating:
-          logger.info('WebRTC phone - call terminating', { sipId: sipSession.id });
+          return this.eventEmitter.emit(ON_PROGRESS, this._createCallSession(sipSession, null, {
+            incoming: false,
+            ringing: true,
+          }), this.audioOutputDeviceId, this.audioOutputVolume);
 
+        case SessionState.Terminating:
+          logger.info('WebRTC phone - call terminating', {
+            sipId: sipSession.id,
+          });
           this.eventEmitter.emit(ON_CALL_ENDING, this._createCallSession(sipSession));
-
           break;
-        case SessionState.Terminated: {
-          logger.info('WebRTC phone - call terminated', { sipId: sipSession.id });
+
+        case SessionState.Terminated:
+        {
+          logger.info('WebRTC phone - call terminated', {
+            sipId: sipSession.id,
+          });
 
           // Should be called before `_onCallTerminated` or the callCount will not decrement...
           const callSession = this._createCallSession(sipSession);
+
           callSession.endTime = new Date();
+
           const wasCurrentSession = this._onCallTerminated(sipSession);
 
           return this.eventEmitter.emit(ON_CALL_ENDED, callSession, wasCurrentSession);
         }
+
         default:
           break;
       }
@@ -449,12 +433,15 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }
 
     // Video events
-    const { peerConnection } = sipSession.sessionDescriptionHandler;
-    peerConnection.ontrack = rawEvent => {
+    const {
+      // @ts-ignore
+      peerConnection,
+    } = sipSession.sessionDescriptionHandler;
+
+    peerConnection.ontrack = (rawEvent: any) => {
       const event = rawEvent;
       const [stream] = event.streams;
       const kind = event && event.track && event.track.kind;
-
       logger.info('on track stream called on the peer connection', {
         callId: this.getSipSessionId(sipSession),
         streamId: stream ? stream.id : null,
@@ -474,29 +461,31 @@ export default class WebRTCPhone extends Emitter implements Phone {
       return this.eventEmitter.emit(ON_VIDEO_STREAM, stream, event.track.id, event, sipSession);
     };
 
-    peerConnection.onremovestream = event => {
+    peerConnection.onremovestream = (event: any) => {
       logger.info('on remove stream called on the peer connection', {
         id: event.stream.id,
         tracks: event.stream.getTracks(),
       });
-
       this.eventEmitter.emit(ON_REMOVE_STREAM, event.stream);
     };
   }
 
-  async startScreenSharing(constraints: Object, callSession?: CallSession) {
-    logger.info('WebRTC - start screen sharing', { constraints, id: callSession ? callSession.getId() : null });
-
+  async startScreenSharing(constraints: Record<string, any>, callSession?: CallSession): Promise<MediaStream> {
+    logger.info('WebRTC - start screen sharing', {
+      constraints,
+      id: callSession ? callSession.getId() : null,
+    });
     const screenShareStream = await this.client.getStreamFromConstraints(constraints);
+
     if (!screenShareStream) {
       throw new Error(`Can't create media stream for screensharing with: ${JSON.stringify(constraints)}`);
     }
 
     const screenTrack = screenShareStream.getVideoTracks()[0];
     const sipSession = this.currentSipSession;
-    const pc = this.client.getPeerConnection(this.getSipSessionId(sipSession));
-    const sender = pc && pc.getSenders && pc.getSenders().find(s => s && s.track && s.track.kind === 'video');
-    const localStream = this.client.getLocalStream(this.getSipSessionId(sipSession));
+    const pc = sipSession && this.client.getPeerConnection(this.getSipSessionId(sipSession));
+    const sender = pc && pc.getSenders && pc.getSenders().find((s: any) => s && s.track && s.track.kind === 'video');
+    const localStream = sipSession && this.client.getLocalStream(this.getSipSessionId(sipSession));
     const videoTrack = localStream ? localStream.getTracks().find(track => track.kind === 'video') : null;
     const hadVideo = !!videoTrack;
 
@@ -515,12 +504,12 @@ export default class WebRTCPhone extends Emitter implements Phone {
       sender.replaceTrack(screenTrack);
     }
 
-    this._onScreenSharing(screenShareStream, sipSession, callSession, hadVideo, constraints.desktop);
+    this._onScreenSharing(screenShareStream, sipSession as Inviter | Invitation, callSession, hadVideo, constraints.desktop);
 
     return screenShareStream;
   }
 
-  async stopScreenSharing(restoreLocalStream: boolean = true, callSession?: ?CallSession) {
+  async stopScreenSharing(restoreLocalStream = true, callSession?: CallSession | null | undefined): Promise<OutgoingInviteRequest | void> {
     if (!this.currentScreenShare) {
       return;
     }
@@ -528,57 +517,49 @@ export default class WebRTCPhone extends Emitter implements Phone {
     logger.info('WebRTC phone - stop screen sharing', {
       restoreLocalStream,
     });
-
-    let reinvited = false;
+    let reinvited: OutgoingInviteRequest | void;
 
     try {
       if (this.currentScreenShare.stream) {
-        this.currentScreenShare.stream.getTracks().forEach(track => track.stop());
+        this.currentScreenShare.stream.getTracks().forEach((track: MediaStreamTrack) => track.stop());
       }
 
       if (restoreLocalStream) {
         const targetCallSession = callSession || this.currentCallSession;
         const conference = this.isConference(targetCallSession);
-
         // When stopping screenshare and we had video before that, we have to re-upgrade
         // When upgrading directly to screenshare (eg: we don't have a videoLocalStream to replace)
         // We have to downgrade to audio.
         const screenshareStopped = this.currentScreenShare.hadVideo;
-        const constraints = { audio: false, video: screenshareStopped };
+        const constraints = {
+          audio: false,
+          video: screenshareStopped,
+        };
 
         // We have to remove the video sender to be able to re-upgrade to video in `sendReinvite` below
         this._downgradeToAudio(targetCallSession, false);
+
         // Wait for the track to be removed, unless the video sender won't have a null track in `_upgradeToVideo`.
         await new Promise(resolve => setTimeout(resolve, 500));
-
         reinvited = await this.sendReinvite(targetCallSession, constraints, conference);
       }
-    } catch (e) {
+    } catch (e: any) {
       console.warn(e);
     }
 
     const sipSession = this.currentSipSession;
-
-    this.eventEmitter.emit(
-      ON_SHARE_SCREEN_ENDED,
-      callSession ? this._createCallSession(sipSession, callSession, { screensharing: false }) : null,
-    );
-
+    this.eventEmitter.emit(ON_SHARE_SCREEN_ENDED, callSession && sipSession ? this._createCallSession(sipSession, callSession, {
+      screensharing: false,
+    }) : null);
     this.currentScreenShare = null;
-
     return reinvited;
   }
 
-  _onScreenSharing(screenStream: Object,
-    sipSession: Session,
-    callSession: ?CallSession,
-    hadVideo: boolean,
-    desktop?: ?boolean = false) {
+  _onScreenSharing(screenStream: MediaStream, sipSession: Invitation | Inviter, callSession: CallSession | null | undefined, hadVideo: boolean, desktop?: boolean | null | undefined) {
     const screenTrack = screenStream.getVideoTracks()[0];
     const sipSessionId = this.getSipSessionId(sipSession);
     const pc = this.client.getPeerConnection(sipSessionId);
-    const sender = pc && pc.getSenders && pc.getSenders().find(s => s && s.track && s.track.kind === 'video');
-
+    const sender = pc && pc.getSenders && pc.getSenders().find((s: any) => s && s.track && s.track.kind === 'video');
     logger.info('WebRTC phone - on screensharing', {
       hadVideo,
       id: this.getSipSessionId(sipSession),
@@ -592,11 +573,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
           id: this.getSipSessionId(sipSession),
           screenTrack,
         });
-
-        this.eventEmitter.emit(
-          ON_SHARE_SCREEN_ENDING,
-          this._createCallSession(sipSession, callSession),
-        );
+        this.eventEmitter.emit(ON_SHARE_SCREEN_ENDING, this._createCallSession(sipSession, callSession));
       };
     }
 
@@ -607,38 +584,41 @@ export default class WebRTCPhone extends Emitter implements Phone {
       sipSessionId,
       desktop,
     };
-
     this.client.setLocalMediaStream(this.getSipSessionId(sipSession), screenStream);
-
-    this.eventEmitter.emit(
-      ON_SHARE_SCREEN_STARTED,
-      this._createCallSession(sipSession, callSession, { screensharing: true }),
-      screenStream,
-    );
+    this.eventEmitter.emit(ON_SHARE_SCREEN_STARTED, this._createCallSession(sipSession, callSession, {
+      screensharing: true,
+    }), screenStream);
   }
 
-  _onCallAccepted(sipSession: Session, cameraEnabled: boolean): CallSession {
-    logger.info('WebRTC phone - on call accepted', { sipId: sipSession.id, cameraEnabled });
+  _onCallAccepted(sipSession: Inviter | Invitation, cameraEnabled: boolean): CallSession {
+    logger.info('WebRTC phone - on call accepted', {
+      sipId: sipSession.id,
+      cameraEnabled,
+    });
 
     const callSession = this._createAcceptedCallSession(sipSession, cameraEnabled);
+
     this.currentSipSession = sipSession;
     this.currentCallSession = callSession;
-
     this.eventEmitter.emit(ON_TERMINATE_SOUND, callSession, 'call accepted');
     const sipSessionId = this.getSipSessionId(sipSession);
+
     if (sipSessionId) {
       this.removeIncomingSessions(sipSessionId);
     }
 
     callSession.answerTime = new Date();
+
     this._updateCallSession(callSession);
-    this.eventEmitter.emit(ON_CALL_ACCEPTED, callSession, cameraEnabled);
 
+    this.eventEmitter.emit(ON_CALL_ACCEPTED, callSession, cameraEnabled);
     return callSession;
   }
 
   changeAudioDevice(id: string) {
-    logger.info('WebRTC phone - change audio device', { deviceId: id });
+    logger.info('WebRTC phone - change audio device', {
+      deviceId: id,
+    });
     this.audioOutputDeviceId = id;
     this.client.changeAudioOutputDevice(id);
   }
@@ -648,52 +628,63 @@ export default class WebRTCPhone extends Emitter implements Phone {
   }
 
   changeRingDevice(id: string) {
-    logger.info('WebRTC phone - changing ring device', { id });
-
+    logger.info('WebRTC phone - changing ring device', {
+      id,
+    });
     this.audioRingDeviceId = id;
   }
 
   // volume is a value between 0 and 1
   changeAudioVolume(volume: number) {
-    logger.info('WebRTC phone - changing audio volume', { volume });
-
+    logger.info('WebRTC phone - changing audio volume', {
+      volume,
+    });
     this.audioOutputVolume = volume;
     this.client.changeAudioOutputVolume(volume);
   }
 
   // volume is a value between 0 and 1
   changeRingVolume(volume: number) {
-    logger.info('WebRTC phone - changing ring volume', { volume });
-
+    logger.info('WebRTC phone - changing ring volume', {
+      volume,
+    });
     this.audioRingVolume = volume;
   }
 
-  changeAudioInputDevice(id: string, force: ?boolean) {
-    logger.info('WebRTC phone - changeAudio input device', { deviceId: id });
-
+  changeAudioInputDevice(id: string, force?: boolean) {
+    logger.info('WebRTC phone - changeAudio input device', {
+      deviceId: id,
+    });
     return this.client.changeAudioInputDevice(id, this.currentSipSession, force);
   }
 
-  changeVideoInputDevice(id: ?string) {
-    logger.info('WebRTC phone - change video input device', { deviceId: id });
-
+  async changeVideoInputDevice(id: string): Promise<void | MediaStream | null | undefined> {
+    logger.info('WebRTC phone - change video input device', {
+      deviceId: id,
+    });
     return this.client.changeVideoInputDevice(id, this.currentSipSession);
   }
 
-  changeSessionVideoInputDevice(id: ?string) {
-    logger.info('WebRTC phone - change session video input device', { deviceId: id });
-
-    return this.client.changeSessionVideoInputDevice(id, this.currentSipSession);
+  changeSessionVideoInputDevice(id: string | null | undefined) {
+    logger.info('WebRTC phone - change session video input device', {
+      deviceId: id,
+    });
+    return this.currentSipSession && this.client.changeSessionVideoInputDevice(id, this.currentSipSession);
   }
 
-  _onCallTerminated(sipSession: Session) {
-    logger.info('WebRTC phone - on call terminated', { sipId: sipSession.id });
-
+  _onCallTerminated(sipSession: Invitation | Inviter): boolean {
     const sipSessionId = this.getSipSessionId(sipSession);
+
+    logger.info('WebRTC phone - on call terminated', {
+      sipId: sipSession.id,
+      sipSessionId,
+      ids: Object.keys(this.callSessions),
+    });
+
     const callSession = this._createCallSession(sipSession);
+
     const isCurrentSession = this.isCurrentCallSipSession(callSession);
     const isCurrentIncomingCall = callSession.is(this.getIncomingCallSession());
-
     // If the terminated call was an incoming call, we have to re-trigger if it's was the first incoming call
     // Otherwise, we have to re-trigger an incoming call event if another call is incoming
     const shouldRetrigger = isCurrentSession ? this.incomingSessions.length : isCurrentIncomingCall;
@@ -711,7 +702,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
       this.removeIncomingSessions(sipSessionId);
     }
 
-    delete this.callSessions[callSession.getId()];
+    delete this.callSessions[sipSessionId];
 
     if (isCurrentSession) {
       this.currentSipSession = undefined;
@@ -719,14 +710,12 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }
 
     const hasIncomingCallSession = this.hasIncomingCallSession();
-
     // Re-trigger incoming call event for remaining incoming calls
     logger.info('WebRTC phone - check to re-trigger incoming call', {
       sipId: sipSession.id,
       shouldRetrigger,
       hasIncomingCallSession,
     });
-
     this.client.onCallEnded(sipSession);
 
     if (hasIncomingCallSession && shouldRetrigger) {
@@ -737,22 +726,19 @@ export default class WebRTCPhone extends Emitter implements Phone {
           if (!this.currentCallSession) {
             this.eventEmitter.emit(ON_PLAY_RING_SOUND, this.audioRingDeviceId, this.audioRingVolume, nextCallSession);
           } else {
-            this.eventEmitter.emit(ON_PLAY_INBOUND_CALL_SIGNAL_SOUND,
-              this.audioOutputDeviceId,
-              this.audioOutputVolume,
-              nextCallSession);
+            this.eventEmitter.emit(ON_PLAY_INBOUND_CALL_SIGNAL_SOUND, this.audioOutputDeviceId, this.audioOutputVolume, nextCallSession);
           }
         }
 
-        // $FlowFixMe
-        this.eventEmitter.emit(ON_CALL_INCOMING, nextCallSession, nextCallSession.cameraEnabled);
+        this.eventEmitter.emit(ON_CALL_INCOMING, nextCallSession, nextCallSession?.cameraEnabled);
       }, 100);
     }
 
     if (callSession.getId() in this.ignoredSessions) {
-      return;
+      return false;
     }
 
+    // @ts-ignore
     if (!sipSession.isCanceled) {
       setTimeout(() => {
         this.eventEmitter.emit(ON_PLAY_HANGUP_SOUND, this.audioOutputDeviceId, this.audioOutputVolume, callSession);
@@ -764,6 +750,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
   setActiveSipSession(callSession: CallSession) {
     const sipSessionId = this.findSipSession(callSession);
+
     if (!sipSessionId) {
       return;
     }
@@ -780,17 +767,20 @@ export default class WebRTCPhone extends Emitter implements Phone {
   // Maybe due to https://github.com/react-native-webrtc/react-native-webrtc/issues/401
   hasActiveRemoteVideoStream() {
     const sipSession = this.currentSipSession;
+
     if (!sipSession) {
       return false;
     }
 
-    const { peerConnection } = sipSession.sessionDescriptionHandler;
-    const remoteStream = peerConnection.getRemoteStreams().find(stream => !!stream.getVideoTracks().length);
-
+    const {
+      // @ts-ignore
+      peerConnection,
+    } = sipSession.sessionDescriptionHandler;
+    const remoteStream: MediaStream = peerConnection.getRemoteStreams().find((stream: MediaStream) => !!stream.getVideoTracks().length);
     return remoteStream && remoteStream.getVideoTracks().some(track => !track.muted);
   }
 
-  callCount() {
+  callCount(): number {
     return Object.keys(this.callSessions).length;
   }
 
@@ -811,33 +801,30 @@ export default class WebRTCPhone extends Emitter implements Phone {
   }
 
   // Deprecated
-  getLocalStreamForCall(callSession: CallSession): ?MediaStream {
+  getLocalStreamForCall(callSession: CallSession): MediaStream | null | undefined {
     logger.warn('WebRTCPhone.getLocalStreamForCall is deprecated, use WebRTCPhone.getLocalStream instead');
-
     return this.getLocalStream(callSession);
   }
 
   // Deprecated
-  getRemoteStreamForCall(callSession: CallSession): ?MediaStream {
+  getRemoteStreamForCall(callSession: CallSession): MediaStream | null | undefined {
     logger.warn('WebRTCPhone.getRemoteStreamForCall is deprecated, use WebRTCPhone.getRemoteStream instead');
-
     return this.getRemoteVideoStream(callSession);
   }
 
-  getRemoteStreamsForCall(callSession: CallSession): ?MediaStream {
+  getRemoteStreamsForCall(callSession: CallSession): MediaStream | null | undefined {
     logger.warn('WebRTCPhone.getRemoteStreamsForCall is deprecated, use WebRTCPhone.getRemoteStreams instead');
-
     return this.getRemoteStream(callSession);
   }
 
   accept(callSession: CallSession, cameraEnabled?: boolean): Promise<string | null> {
-    logger.info('WebRTC phone - accept call', { id: callSession ? callSession.getId() : 'n/a', cameraEnabled });
+    logger.info('WebRTC phone - accept call', {
+      id: callSession ? callSession.getId() : 'n/a',
+      cameraEnabled,
+    });
+
     if (this.currentSipSession) {
-      this.holdSipSession(
-        this.currentSipSession,
-        this.currentCallSession,
-        true,
-      );
+      this.holdSipSession(this.currentSipSession, this.currentCallSession, true);
     }
 
     if (!callSession) {
@@ -846,34 +833,33 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }
 
     const sipSessionId = this.getSipSessionIdFromCallSession(callSession);
+
     if (sipSessionId && !(sipSessionId in this.callSessions)) {
-      logger.warn('Call session already ended or not found, can\'t accept it.', { sipSessionId });
+      logger.warn('Call session already ended or not found, can\'t accept it.', {
+        sipSessionId,
+      });
       return Promise.resolve(null);
     }
 
     if (callSession.getId() in this.acceptedSessions) {
-      logger.warn('CallSession already accepted.', { id: callSession ? callSession.getId() : 'n/a' });
+      logger.warn('CallSession already accepted.', {
+        id: callSession ? callSession.getId() : 'n/a',
+      });
       return Promise.resolve(callSession.sipCallId);
     }
 
     this.shouldSendReinvite = false;
     callSession.answerTime = new Date();
+
     this._updateCallSession(callSession);
-    this.acceptedSessions[callSession.getId()] = true;
 
+    this.acceptedSessions[callSession.getId()] = true;
     this.eventEmitter.emit(ON_CALL_ANSWERED, callSession);
+    const sipSession = this.client.getSipSession(callSession.getId()) as Invitation;
 
-    const sipSession = this.client.getSipSession(callSession.getId());
     if (sipSession) {
-      if (sipSession.state === SessionState.Terminated || sipSession.state === SessionState.Terminating) {
-        logger.warn('Trying to answer a terminated sipSession.');
-
-        return Promise.resolve(null);
-      }
-
       logger.info('accept call, session found', { sipId: sipSession.id });
 
-      // $FlowFixMe
       return this.client.answer(sipSession, this.allowVideo ? cameraEnabled : false).then(() => {
         return callSession.sipCallId;
       }).catch(e => {
@@ -883,7 +869,16 @@ export default class WebRTCPhone extends Emitter implements Phone {
       });
     }
 
-    logger.warn('no CallSession found to accept.', { id: callSession ? callSession.getId() : 'n/a' });
+    const error = 'No CallSession found to accept.';
+
+    logger.warn(error, {
+      id: callSession ? callSession.getId() : 'n/a',
+      ids: this.client.getSipSessionIds(),
+    });
+
+    if (callSession) {
+      this.eventEmitter.emit(ON_CALL_ERROR, new Error(error), callSession);
+    }
 
     return Promise.resolve(null);
   }
@@ -893,80 +888,87 @@ export default class WebRTCPhone extends Emitter implements Phone {
   }
 
   async reject(callSession: CallSession): Promise<void> {
-    logger.info('reject WebRTC called', { id: callSession.getId() });
-
+    logger.info('reject WebRTC called', {
+      id: callSession.getId(),
+    });
     this.eventEmitter.emit(ON_TERMINATE_SOUND, callSession, 'call rejected locally');
+
     if (!callSession || callSession.getId() in this.rejectedSessions) {
       return;
     }
 
     this.shouldSendReinvite = false;
     this.rejectedSessions[callSession.getId()] = true;
-
     const sipSession = this.findSipSession(callSession);
-    if (sipSession) {
-      logger.info('WebRTC rejecting', { sipId: sipSession.id });
 
+    if (sipSession) {
+      logger.info('WebRTC rejecting', {
+        sipId: sipSession.id,
+      });
       this.client.hangup(sipSession);
     }
   }
 
   async ignore(callSession: CallSession): Promise<void> {
-    logger.info('WebRTC ignore', { id: callSession.getId() });
-
+    logger.info('WebRTC ignore', {
+      id: callSession.getId(),
+    });
     // kill the ring
     this.eventEmitter.emit(ON_TERMINATE_SOUND, callSession, 'ignoring call');
     this.ignoredSessions[callSession.getId()] = true;
     callSession.ignore();
   }
 
-  atxfer(callSession: CallSession): ?Object {
-    const sipSession = this.findSipSession(callSession);
+  atxfer(callSession: CallSession): Record<string, any> | null | undefined {
+    const sipSession = this.findSipSession(callSession) as Inviter;
 
     if (sipSession) {
-      logger.info('WebRTC atxfer', { sipId: sipSession.id });
-
+      logger.info('WebRTC atxfer', {
+        sipId: sipSession.id,
+      });
       return this.client.atxfer(sipSession);
     }
   }
 
-  hold(callSession: CallSession, withEvent: boolean = true): ?Promise<any> {
-    logger.info('WebRTC hold', { id: callSession.getId() });
-
+  hold(callSession: CallSession, withEvent = true): Promise<OutgoingInviteRequest | void> | null | undefined {
+    logger.info('WebRTC hold', {
+      id: callSession.getId(),
+    });
     const sipSession = this.findSipSession(callSession);
-
     return sipSession ? this.holdSipSession(sipSession, callSession, withEvent) : null;
   }
 
   // @Deprecated
-  unhold(callSession: CallSession, withEvent: boolean = true): ?Promise<any> {
+  unhold(callSession: CallSession, withEvent = true): Promise<MediaStream | void | null> {
     console.warn('Please note that `phone.unhold()` is being deprecated; `phone.resume()` is the preferred method');
-
     return this.resume(callSession, withEvent);
   }
 
-  resume(callSession?: CallSession, withEvent: boolean = true): Promise<any> {
-    logger.info('WebRTC resume called', { id: callSession ? callSession.getId() : null });
-
+  resume(callSession?: CallSession, withEvent = true): Promise<MediaStream | void | null> {
+    logger.info('WebRTC resume called', {
+      id: callSession ? callSession.getId() : null,
+    });
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return new Promise((resolve, reject) => reject(new Error('No session to resume')));
     }
 
-    logger.info('WebRTC resuming', { sipId: sipSession.id });
+    logger.info('WebRTC resuming', {
+      sipId: sipSession.id,
+    });
 
     // Hold current session if different from the current one (we don't want 2 sessions active at the same time).
     if (this.currentSipSession && this.currentSipSession.id !== sipSession.id) {
-      logger.info('WebRTC hold call after resume', { id: this.currentSipSession.id });
-      this.holdSipSession(
-        this.currentSipSession,
-        this.currentCallSession,
-        withEvent,
-      );
+      logger.info('WebRTC hold call after resume', {
+        id: this.currentSipSession.id,
+      });
+      this.holdSipSession(this.currentSipSession, this.currentCallSession, withEvent);
     }
 
     const promise = this.unholdSipSession(sipSession, callSession, withEvent);
     this.currentSipSession = sipSession;
+
     if (callSession) {
       this.currentCallSession = callSession;
     }
@@ -974,18 +976,17 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return promise;
   }
 
-  async holdSipSession(
-    sipSession: Session,
-    callSession: ?CallSession,
-    withEvent: boolean = true,
-  ): Promise<any> {
+  async holdSipSession(sipSession: Inviter | Invitation, callSession: CallSession | null | undefined, withEvent = true): Promise<OutgoingInviteRequest | void> {
     if (!sipSession) {
       return new Promise((resolve, reject) => reject(new Error('No session to hold')));
     }
+
     const sessionId = this.getSipSessionId(sipSession);
     const hasVideo = this.client.hasLocalVideo(sessionId);
-
-    logger.info('WebRTC hold sip session', { sipId: sipSession.id, hasVideo });
+    logger.info('WebRTC hold sip session', {
+      sipId: sipSession.id,
+      hasVideo,
+    });
 
     // Stop screenshare if needed
     if (this.currentScreenShare && this.currentScreenShare.sipSessionId === sessionId) {
@@ -999,8 +1000,8 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }
 
     const isConference = !!callSession && callSession.isConference();
-
     const promise = this.client.hold(sipSession, isConference, hasVideo);
+
     if (withEvent) {
       this.eventEmitter.emit(ON_CALL_HELD, this._createCallSession(sipSession, callSession));
     }
@@ -1008,21 +1009,20 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return promise;
   }
 
-  async unholdSipSession(
-    sipSession: Session,
-    callSession: ?CallSession,
-    withEvent: boolean = true,
-  ): Promise<any> {
+  async unholdSipSession(sipSession: Inviter | Invitation, callSession: CallSession | null | undefined, withEvent = true): Promise<MediaStream | void | null> {
     if (!sipSession) {
       return new Promise((resolve, reject) => reject(new Error('No session to unhold')));
     }
 
     const isConference = !!callSession && callSession.isConference();
-
     const sessionId = this.getSipSessionId(sipSession);
-    logger.info('WebRTC unhold sip session', { sessionId, isConference });
-
-    const { hasVideo } = this.client.getHeldSession(sessionId) || {};
+    logger.info('WebRTC unhold sip session', {
+      sessionId,
+      isConference,
+    });
+    const {
+      hasVideo,
+    } = this.client.getHeldSession(sessionId) || {};
     const wasScreensharing = this.lastScreenShare && this.lastScreenShare.sipSessionId === sessionId;
     const wasDesktop = this.lastScreenShare && this.lastScreenShare.desktop;
     const promise = this.client.unhold(sipSession, isConference);
@@ -1034,20 +1034,22 @@ export default class WebRTCPhone extends Emitter implements Phone {
         screen: wasScreensharing,
         desktop: wasDesktop,
       };
-
       await this.client.upgradeToVideo(sipSession, constraints, isConference);
     }
 
-    const onScreenSharing = stream => {
+    const onScreenSharing = (stream: MediaStream | null | undefined) => {
       const hadVideo = this.lastScreenShare && this.lastScreenShare.hadVideo;
+
       if (stream) {
         this._onScreenSharing(stream, sipSession, callSession, hadVideo);
       }
+
       this.lastScreenShare = null;
     };
 
     if (withEvent) {
       const updatedCallSession = this._createCallSession(sipSession, callSession);
+
       // Deprecated event
       this.eventEmitter.emit(ON_CALL_UNHELD, updatedCallSession);
       this.eventEmitter.emit(ON_CALL_RESUMED, updatedCallSession);
@@ -1055,6 +1057,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
     return promise.then(() => {
       const stream = callSession ? this.getLocalVideoStream(callSession) : null;
+
       if (wasScreensharing) {
         onScreenSharing(stream);
       }
@@ -1063,17 +1066,24 @@ export default class WebRTCPhone extends Emitter implements Phone {
     });
   }
 
-  mute(callSession: ?CallSession, withEvent: boolean = true): void {
-    logger.info('WebRTC mute called', { id: callSession ? callSession.getId() : null });
-
+  mute(callSession: CallSession | null | undefined, withEvent = true): void {
+    logger.info('WebRTC mute called', {
+      id: callSession ? callSession.getId() : null,
+    });
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return;
     }
 
-    logger.info('WebRTC muting', { sipId: sipSession.id });
+    logger.info('WebRTC muting', {
+      sipId: sipSession.id,
+    });
     this.client.mute(sipSession);
-    const newCallSession = this._createCallSession(sipSession, callSession, { muted: true });
+
+    const newCallSession = this._createCallSession(sipSession, callSession, {
+      muted: true,
+    });
 
     if (this.currentCallSession && newCallSession.is(this.currentCallSession)) {
       this.currentCallSession = newCallSession;
@@ -1084,17 +1094,24 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }
   }
 
-  unmute(callSession: ?CallSession, withEvent: boolean = true): void {
-    logger.info('WebRTC unmute called', { id: callSession ? callSession.getId() : null });
-
+  unmute(callSession: CallSession | null | undefined, withEvent = true): void {
+    logger.info('WebRTC unmute called', {
+      id: callSession ? callSession.getId() : null,
+    });
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return;
     }
 
-    logger.info('WebRTC unmuting', { sipId: sipSession.id });
+    logger.info('WebRTC unmuting', {
+      sipId: sipSession.id,
+    });
     this.client.unmute(sipSession);
-    const newCallSession = this._createCallSession(sipSession, callSession, { muted: false });
+
+    const newCallSession = this._createCallSession(sipSession, callSession, {
+      muted: false,
+    });
 
     if (this.currentCallSession && newCallSession.is(this.currentCallSession)) {
       this.currentCallSession = newCallSession;
@@ -1107,6 +1124,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
   isAudioMuted(callSession: CallSession): boolean {
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return true;
     }
@@ -1116,42 +1134,57 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
   turnCameraOn(callSession?: CallSession): void {
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return;
     }
-    logger.info('WebRTC turn camera on', { sipId: sipSession.id });
 
+    logger.info('WebRTC turn camera on', {
+      sipId: sipSession.id,
+    });
     this.client.toggleCameraOn(sipSession);
-
     this.eventEmitter.emit(ON_CAMERA_RESUMED, this._createCameraResumedCallSession(sipSession, callSession));
   }
 
   turnCameraOff(callSession?: CallSession): void {
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return;
     }
-    logger.info('WebRTC turn camera off', { sipId: sipSession.id });
 
+    logger.info('WebRTC turn camera off', {
+      sipId: sipSession.id,
+    });
     this.client.toggleCameraOff(sipSession);
     this.eventEmitter.emit(ON_CAMERA_DISABLED, this._createCameraDisabledCallSession(sipSession, callSession));
   }
 
-  sendKey(callSession: ?CallSession, tone: string): void {
+  sendKey(callSession: CallSession | null | undefined, tone: string): void {
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return;
     }
 
-    logger.info('WebRTC send key', { sipId: sipSession.id, tone });
+    logger.info('WebRTC send key', {
+      sipId: sipSession.id,
+      tone,
+    });
     this.client.sendDTMF(sipSession, tone);
   }
 
   // Should be async to match CTIPhone definition
   // @TODO: line is not used here
-  async makeCall(number: string, line: any, cameraEnabled?: boolean,
-    audioOnly: boolean = false, conference: boolean = false): Promise<?CallSession> {
-    logger.info('make WebRTC call', { number, lineId: line ? line.id : null, cameraEnabled, audioOnly, conference });
+  async makeCall(number: string, line: any, cameraEnabled?: boolean, audioOnly = false, conference = false): Promise<CallSession | null | undefined> {
+    logger.info('make WebRTC call', {
+      number,
+      lineId: line ? line.id : null,
+      cameraEnabled,
+      audioOnly,
+      conference,
+    });
+
     if (!number) {
       return Promise.resolve(null);
     }
@@ -1159,39 +1192,43 @@ export default class WebRTCPhone extends Emitter implements Phone {
     if (!this.client.isRegistered()) {
       await this.client.register();
     }
+
     if (this.currentSipSession) {
-      this.holdSipSession(
-        this.currentSipSession,
-        this.currentCallSession,
-        true,
-      ).catch(e => {
+      this.holdSipSession(this.currentSipSession, this.currentCallSession, true).catch(e => {
         logger.warn('Unable to hold current session when making another call', e);
       });
     }
 
-    let sipSession: Session;
+    let sipSession: Inviter | Invitation;
+
     try {
       sipSession = this.client.call(number, this.allowVideo ? cameraEnabled : false, audioOnly, conference);
+
       this._bindEvents(sipSession);
-    } catch (error) {
-      console.warn(error);
-      logger.warn('make WebRTC call, error', { message: error.message, stack: error.stack });
+    } catch (error: any) {
+      logger.warn('make WebRTC call, error', {
+        message: error.message,
+        stack: error.stack,
+      });
       return Promise.resolve(null);
     }
+
     const callSession = this._createOutgoingCallSession(sipSession, cameraEnabled || false);
+
     callSession.setIsConference(conference);
     callSession.creationTime = new Date();
+
     this._updateCallSession(callSession);
 
     this.eventEmitter.emit(ON_PLAY_PROGRESS_SOUND, this.audioOutputDeviceId, this.audioOutputVolume);
-
     this.currentSipSession = sipSession;
     this.currentCallSession = callSession;
-
     this.eventEmitter.emit(ON_CALL_OUTGOING, callSession);
 
     // If an invite promise exists, catch exceptions on it to trigger error like OverConstraintsError.
+    // @ts-ignore
     if (sipSession.invitePromise) {
+      // @ts-ignore
       sipSession.invitePromise.catch(error => {
         this.eventEmitter.emit(ON_CALL_ERROR, error, callSession);
       });
@@ -1200,21 +1237,23 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return Promise.resolve(callSession);
   }
 
-  transfer(callSession: ?CallSession, target: string): void {
+  transfer(callSession: CallSession | null | undefined, target: string): void {
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
       return;
     }
 
-    logger.info('WebRTC transfer', { sipId: sipSession.id, target });
-
+    logger.info('WebRTC transfer', {
+      sipId: sipSession.id,
+      target,
+    });
     this.client.transfer(sipSession, target);
   }
 
   async indirectTransfer(source: CallSession, destination: CallSession): Promise<boolean> {
     const sipSession = this.client.getSipSession(source.sipCallId);
     const sipSessionTarget = this.client.getSipSession(destination.sipCallId);
-
     logger.info('WebRTC indirect transfer', {
       sipId: sipSession ? sipSession.id : null,
       target: sipSessionTarget ? sipSessionTarget.id : null,
@@ -1236,7 +1275,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
         },
       };
 
-      return sipSessionTarget.refer(sipSession, options);
+      return sipSessionTarget.refer((sipSession as Session), options);
     });
   }
 
@@ -1246,60 +1285,63 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
   confirmCTIIndirectTransfer() {}
 
-  async hangup(callSession: ?CallSession): Promise<boolean> {
+  async hangup(callSession?: CallSession | null): Promise<boolean> {
     const sipSession = this.findSipSession(callSession);
+
     if (!sipSession) {
-      console.error('Call is unknown to the WebRTC phone', callSession ? callSession.sipCallId : null,
-        callSession ? callSession.callId : null);
+      console.error('Call is unknown to the WebRTC phone', callSession ? callSession.sipCallId : null, callSession ? callSession.callId : null);
       return false;
     }
-
-    logger.info('WebRTC hangup', { sipId: sipSession.id });
-
     const sipSessionId = this.getSipSessionId(sipSession);
 
+    logger.info('WebRTC hangup', {
+      sipId: sipSession.id,
+      sipSessionId,
+    });
     await this.client.hangup(sipSession);
+
     if (callSession) {
       // Removal of `this.callSessions` will be done in `_onCallTerminated`.
       this.endCurrentCall(callSession);
     } else if (sipSessionId) {
-      if (callSession) {
-        delete this.callSessions[callSession.getId()];
-      }
+      delete this.callSessions[sipSessionId];
     }
 
     this.shouldSendReinvite = false;
     return true;
   }
 
-  async getStats(callSession: ?CallSession): Promise<?Object> {
+  async getStats(callSession: CallSession | null | undefined): Promise<RTCStatsReport | null | undefined> {
     const sipSession = this.findSipSession(callSession);
-
     return sipSession ? this.client.getStats(sipSession) : null;
   }
 
-  startNetworkMonitoring(callSession: ?CallSession, interval: number = 1000) {
+  startNetworkMonitoring(callSession: CallSession | null | undefined, interval = 1000) {
     const sipSession = this.findSipSession(callSession);
-
     return sipSession ? this.client.startNetworkMonitoring(sipSession, interval) : null;
   }
 
-  stopNetworkMonitoring(callSession: ?CallSession) {
+  stopNetworkMonitoring(callSession: CallSession | null | undefined) {
     const sipSession = this.findSipSession(callSession);
-
     return sipSession ? this.client.stopNetworkMonitoring(sipSession) : null;
   }
 
-  forceCancel(sipSession: Session): void {
+  forceCancel(sipSession: Inviter): void {
+    // @ts-ignore
     if (!sipSession || !sipSession.outgoingInviteRequest) {
       return;
     }
-    sipSession.outgoingInviteRequest.cancel();
+
+    try {
+      // @ts-ignore
+      sipSession.outgoingInviteRequest.cancel();
+    } catch (e) {
+      logger.info('force cancel, error', e);
+    }
   }
 
   endCurrentCall(callSession: CallSession): void {
     const isCurrent = this.isCurrentCallSipSession(callSession);
-
     logger.info('Ending current call', {
       id: callSession ? callSession.getId() : null,
       isCurrent,
@@ -1315,7 +1357,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
   onConnectionMade(): void {}
 
-  isConference(callSession: ?CallSession): boolean {
+  isConference(callSession: CallSession | null | undefined): boolean {
     if (!callSession) {
       return false;
     }
@@ -1323,23 +1365,19 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return this.client && this.client.isConference(callSession.sipCallId);
   }
 
-  async close(force: boolean = false): Promise<void> {
+  async close(force = false): Promise<void> {
     logger.info('WebRTC close');
 
     try {
-      await Promise.race([
-        this.unregister(),
-        new Promise((resolve, reject) => setTimeout(() => reject(new Error('Unregister, timed out')), 3000)),
-      ]);
-    } catch (e) {
+      await Promise.race([this.unregister(), new Promise((resolve, reject) => setTimeout(() => reject(new Error('Unregister, timed out')), 3000))]);
+    } catch (e: any) {
       logger.error('WebRTC close, unregister error', e);
     }
 
     this.client.close(force);
     this.unbind();
-
     this.incomingSessions = [];
-    this.currentSipSession = null;
+    this.currentSipSession = undefined;
     this.currentCallSession = null;
     this.shouldSendReinvite = false;
     this.rejectedSessions = {};
@@ -1359,7 +1397,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     this.ringingEnabled = false;
   }
 
-  getCurrentCallSession(): ?CallSession {
+  getCurrentCallSession(): CallSession | null | undefined {
     if (!this.currentSipSession) {
       return null;
     }
@@ -1371,13 +1409,14 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return this.incomingSessions.length > 0;
   }
 
-  getIncomingCallSession(): ?CallSession {
+  getIncomingCallSession(): CallSession | null | undefined {
     if (!this.hasIncomingCallSession()) {
       return null;
     }
 
     const sessionId = this.incomingSessions[0];
     const sipSession = this.client.getSipSession(sessionId);
+
     if (!sipSession) {
       return null;
     }
@@ -1385,41 +1424,42 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return this._createCallSession(sipSession);
   }
 
-  sendMessage(sipSession: Session = null, body: string, contentType: string = 'text/plain') {
+  // eslint-disable-next-line @typescript-eslint/default-param-last
+  sendMessage(sipSession: Invitation | Inviter | null = null, body: string, contentType = 'text/plain'): void {
     return this.client.sendMessage(sipSession, body, contentType);
   }
 
-  getLocalStream(callSession: CallSession): ?MediaStream {
+  getLocalStream(callSession: CallSession): MediaStream | null | undefined {
     return callSession ? this.client.getLocalStream(callSession.sipCallId) : null;
   }
 
-  getLocalVideoStream(callSession: CallSession): ?MediaStream {
+  getLocalVideoStream(callSession: CallSession): MediaStream | null | undefined {
     return callSession ? this.client.getLocalVideoStream(callSession.sipCallId) : null;
   }
 
   // Deprecated
-  getLocalMediaStream(callSession: CallSession) {
+  getLocalMediaStream(callSession: CallSession): MediaStream | null | undefined {
     logger.warn('WebRTCPhone.getLocalMediaStream is deprecated, use WebRTCPhone.getLocalStream instead');
     return this.getLocalStream(callSession);
   }
 
-  hasLocalVideo(callSession: CallSession) {
-    return callSession ? this.client.hasLocalVideo(callSession.sipCallId) : null;
+  hasLocalVideo(callSession: CallSession): boolean {
+    return callSession ? this.client.hasLocalVideo(callSession.sipCallId) : false;
   }
 
-  hasALocalVideoTrack(callSession: CallSession) {
-    return callSession ? this.client.hasALocalVideoTrack(callSession.sipCallId) : null;
+  hasALocalVideoTrack(callSession: CallSession): boolean {
+    return callSession ? this.client.hasALocalVideoTrack(callSession.sipCallId) : false;
   }
 
-  getRemoteStream(callSession: CallSession): ?MediaStream {
+  getRemoteStream(callSession: CallSession): MediaStream | null | undefined {
     return callSession ? this.client.getRemoteStream(callSession.sipCallId) : null;
   }
 
-  getRemoteVideoStream(callSession: CallSession): ?MediaStream {
+  getRemoteVideoStream(callSession: CallSession): MediaStream | null | undefined {
     return callSession ? this.client.getRemoteVideoStream(callSession.sipCallId) : null;
   }
 
-  getRemoteVideoStreamFromPc(callSession: CallSession): ?MediaStream {
+  getRemoteVideoStreamFromPc(callSession: CallSession): MediaStream | null | undefined {
     return callSession ? this.client.getRemoteVideoStreamFromPc(callSession.sipCallId) : null;
   }
 
@@ -1427,24 +1467,29 @@ export default class WebRTCPhone extends Emitter implements Phone {
     return callSession ? this.client.hasRemoteVideo(callSession.sipCallId) : false;
   }
 
-  setMediaConstraints(media: MediaStreamConstraints) {
+  setMediaConstraints(media: MediaStreamConstraints): void {
     this.client.setMediaConstraints(media);
   }
 
-  isVideoRemotelyHeld(callSession: CallSession) {
-    return callSession ? this.client.isVideoRemotelyHeld(callSession.sipCallId) : null;
+  isVideoRemotelyHeld(callSession: CallSession): boolean {
+    return callSession ? this.client.isVideoRemotelyHeld(callSession.sipCallId) : false;
   }
 
   bindClientEvents() {
     this.client.unbind();
-
-    this.client.on(this.client.INVITE, (sipSession: Session, wantsToDoVideo: boolean) => {
+    this.client.on(this.client.INVITE, (sipSession: Invitation | Inviter, wantsToDoVideo: boolean) => {
       const autoAnswer = sipSession.request.getHeader('Answer-Mode') === 'Auto';
       const withVideo = this.allowVideo ? wantsToDoVideo : false;
-      logger.info('WebRTC invite received', { sipId: sipSession.id, withVideo, autoAnswer });
+      logger.info('WebRTC invite received', {
+        sipId: sipSession.id,
+        withVideo,
+        autoAnswer,
+      });
 
       const callSession = this._createIncomingCallSession(sipSession, withVideo, null, autoAnswer);
+
       this.incomingSessions.push(callSession.getId());
+
       this._bindEvents(sipSession);
 
       this.client.storeSipSession(sipSession);
@@ -1454,18 +1499,15 @@ export default class WebRTCPhone extends Emitter implements Phone {
           this.eventEmitter.emit(ON_PLAY_RING_SOUND, this.audioRingDeviceId, this.audioRingVolume, callSession);
         }
       } else {
-        this.eventEmitter.emit(ON_PLAY_INBOUND_CALL_SIGNAL_SOUND,
-          this.audioOutputDeviceId,
-          this.audioOutputVolume,
-          callSession);
+        this.eventEmitter.emit(ON_PLAY_INBOUND_CALL_SIGNAL_SOUND, this.audioOutputDeviceId, this.audioOutputVolume, callSession);
       }
 
       callSession.creationTime = new Date();
+
       this._updateCallSession(callSession);
 
       this.eventEmitter.emit(ON_CALL_INCOMING, callSession, wantsToDoVideo);
     });
-
     this.client.on(this.client.ON_REINVITE, (...args) => {
       logger.info('WebRTC on reinvite', {
         sessionId: args[0].id,
@@ -1473,9 +1515,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
         updatedCalleeName: args[2],
         updatedNumber: args[3],
       });
-
       const sipSession = args[0];
-
       // Give some time for the stream to be mounted.
       // if `_createCallSession` is called too soon `hasVideo` will return false because the stream doesn't exists yet
       setTimeout(() => {
@@ -1485,15 +1525,18 @@ export default class WebRTCPhone extends Emitter implements Phone {
         this.eventEmitter.emit.apply(this.eventEmitter, [this.client.ON_REINVITE, ...args]);
       }, 2000);
     });
-
-    this.client.on(this.client.ACCEPTED, (sipSession: Session) => {
+    this.client.on(this.client.ACCEPTED, (sipSession: Inviter | Invitation) => {
       const sessionId = this.getSipSessionId(sipSession);
-      const hasSession = sessionId in this.callSessions;
-
-      logger.info('WebRTC call accepted', { sipId: sessionId, hasSession });
+      const hasSession = (sessionId in this.callSessions);
+      logger.info('WebRTC call accepted', {
+        sipId: sessionId,
+        hasSession,
+      });
 
       if (!hasSession) {
-        logger.warn('Call accepted ignored, session is no longer present in the WebRtcPhone', { sessionId });
+        logger.warn('Call accepted ignored, session is no longer present in the WebRtcPhone', {
+          sessionId,
+        });
         return;
       }
 
@@ -1504,36 +1547,38 @@ export default class WebRTCPhone extends Emitter implements Phone {
       }
     });
     this.client.on('ended', () => {});
-
     this.client.on(this.client.ON_ERROR, e => {
       logger.error('WebRTC error', e);
       this.eventEmitter.emit(ON_CALL_ERROR, e);
     });
-
     this.client.on(this.client.REJECTED, session => {
       logger.info('WebRTC call rejected', session.id);
+
       const callSession = this._createCallSession(session);
+
+      // `_createCallSession` add the CallSession in `this.callSessions`.
+      // so we have to remove it or `callCount` will always return 1 even if the call was rejected
+      delete this.callSessions[this.getSipSessionId(session)];
+
       callSession.endTime = new Date();
-      this._updateCallSession(callSession);
 
       this.eventEmitter.emit(ON_CALL_REJECTED, callSession);
     });
-
     this.client.on(this.client.UNREGISTERED, () => {
       logger.info('WebRTC unregistered');
       this.eventEmitter.emit(ON_UNREGISTERED);
     });
-
     this.client.on(this.client.ON_DISCONNECTED, () => {
       logger.info('WebRTC disconnected');
       this.eventEmitter.emit(ON_DISCONNECTED);
     });
     this.client.on(this.client.ON_EARLY_MEDIA, session => {
       logger.info('WebRTC early media');
+
       const callSession = this._createCallSession(session);
+
       this.eventEmitter.emit(ON_EARLY_MEDIA, callSession);
     });
-
     this.client.on(this.client.REGISTERED, () => {
       logger.info('WebRTC registered', {
         shouldSendReinvite: this.shouldSendReinvite,
@@ -1545,31 +1590,30 @@ export default class WebRTCPhone extends Emitter implements Phone {
 
       // If the phone registered with a current callSession (eg: when switching network):
       // send a reinvite to renegociate ICE with new IP
-      if (this.shouldSendReinvite && this.currentSipSession
-        && this.currentSipSession.state === SessionState.Established) {
+      if (this.shouldSendReinvite && this.currentSipSession && this.currentSipSession.state === SessionState.Established) {
         this.shouldSendReinvite = false;
-        const pc = this.currentSipSession.sessionDescriptionHandler.peerConnection;
+        // @ts-ignore
+        const pc = this.currentSipSession?.sessionDescriptionHandler?.peerConnection;
         const isConference = pc ? pc.sfu : false;
         const hasVideo = this.currentCallSession && this.currentCallSession.cameraEnabled;
 
         try {
           // Send reinvite with iceRestart
           this.sendReinvite(this.currentCallSession, null, isConference, !hasVideo, true);
-        } catch (e) {
-          logger.error('WebRTC reinvite after register, error', { message: e.message, stack: e.stack });
+        } catch (e: any) {
+          logger.error('WebRTC reinvite after register, error', {
+            message: e.message,
+            stack: e.stack,
+          });
         }
       }
     });
-
     this.client.on(this.client.CONNECTED, () => {
       logger.info('WebRTC client connected');
-
       this.stopHeartbeat();
     });
-
     this.client.on(this.client.DISCONNECTED, () => {
       logger.info('WebRTC client disconnected');
-
       this.eventEmitter.emit(ON_UNREGISTERED);
 
       // Do not trigger heartbeat if already running
@@ -1580,71 +1624,62 @@ export default class WebRTCPhone extends Emitter implements Phone {
       // Tell to send reinvite when reconnecting
       this.shouldSendReinvite = true;
     });
-
     this.client.on(this.client.ON_TRACK, (session, event) => {
       this.eventEmitter.emit(ON_TRACK, session, event);
     });
-
     this.client.on('onVideoInputChange', stream => {
       this.eventEmitter.emit(ON_VIDEO_INPUT_CHANGE, stream);
     });
-
     this.client.on(this.client.MESSAGE, (message: Message) => {
       this._onMessage(message);
+
       this.eventEmitter.emit(ON_MESSAGE, message);
     });
-
     this.client.on(this.client.ON_NETWORK_STATS, (session, stats, previousStats) => {
       const callSession = this.getCallSession(this.getSipSessionId(session));
-
       this.eventEmitter.emit(ON_NETWORK_STATS, callSession, stats, previousStats);
     });
-
     // Used when upgrading directly in screenshare mode
-    this.client.on(this.client.ON_SCREEN_SHARING_REINVITE, (sipSession: Session, response: any, desktop: boolean) => {
+    this.client.on(this.client.ON_SCREEN_SHARING_REINVITE, (sipSession: Inviter | Invitation, response: any, desktop: boolean) => {
       const sipSessionId = this.getSipSessionId(sipSession);
       const localStream = this.client.getLocalStream(sipSessionId);
       const callSession = this.callSessions[sipSessionId];
-
       logger.info('Updrading directly in screensharing mode', {
         sipSessionId,
-        tracks: localStream ? localStream.getTracks() : null,
+        tracks: localStream?.getTracks() || null,
       });
 
-      this._onScreenSharing(localStream, sipSession, callSession, false, desktop);
+      this._onScreenSharing(localStream as MediaStream, sipSession, callSession, false, desktop);
     });
   }
 
   // Find a corresponding sipSession from a CallSession
-  findSipSession(callSession: ?CallSession): ?Session {
+  findSipSession(callSession: CallSession | null | undefined): Invitation | Inviter | null | undefined {
     const keys = this.client.getSipSessionIds();
     const keyIndex = keys.findIndex(sessionId => callSession && callSession.isId(sessionId));
 
     if (keyIndex === -1) {
-      const currentSipSessionId = this.currentSipSession
-        ? this.getSipSessionId(this.currentSipSession)
-        : this.client.getSipSessionIds()[0];
+      const currentSipSessionId = this.currentSipSession ? this.getSipSessionId(this.currentSipSession) : this.client.getSipSessionIds()[0];
       return currentSipSessionId ? this.client.getSipSession(currentSipSessionId) : null;
     }
 
     return this.client.getSipSession(keys[keyIndex]);
   }
 
-  getCallSession(sipSessionId: string): ?CallSession {
+  getCallSession(sipSessionId: string): CallSession | null | undefined {
     return this.callSessions[sipSessionId];
   }
 
-  getSipSessionId(sipSession: Session) {
+  getSipSessionId(sipSession: Inviter | Invitation): string {
     return this.client.getSipSessionId(sipSession);
   }
 
-  getSipSessionIdFromCallSession(callSession: CallSession) {
+  getSipSessionIdFromCallSession(callSession: CallSession): string | null {
     const sipSession = this.findSipSession(callSession);
-
     return sipSession ? this.getSipSessionId(sipSession) : null;
   }
 
-  _updateCallSession(callSession: CallSession) {
+  _updateCallSession(callSession: CallSession): void {
     const sipSessionId = this.getSipSessionIdFromCallSession(callSession);
 
     if (sipSessionId) {
@@ -1652,7 +1687,8 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }
   }
 
-  _onMessage(message: Message) {
+  _onMessage(message: Message): void {
+    // @ts-ignore
     if (!message || message.method !== 'MESSAGE') {
       return;
     }
@@ -1660,19 +1696,24 @@ export default class WebRTCPhone extends Emitter implements Phone {
     let body;
 
     try {
+      // @ts-ignore
       body = JSON.parse(message.body);
-    } catch (e) {
+    } catch (e: any) {
       return;
     }
 
-    const { type, content } = body;
+    const {
+      type,
+      content,
+    } = body;
 
     switch (type) {
       case MESSAGE_TYPE_CHAT:
         this.eventEmitter.emit(ON_CHAT, content);
         break;
 
-      case MESSAGE_TYPE_SIGNAL: {
+      case MESSAGE_TYPE_SIGNAL:
+      {
         this.eventEmitter.emit(ON_SIGNAL, content);
         break;
       }
@@ -1681,12 +1722,7 @@ export default class WebRTCPhone extends Emitter implements Phone {
     }
   }
 
-  _createIncomingCallSession(
-    sipSession: Session,
-    cameraEnabled: boolean,
-    fromSession?: ?CallSession,
-    autoAnswer: boolean = false,
-  ): CallSession {
+  _createIncomingCallSession(sipSession: Invitation | Inviter, cameraEnabled: boolean, fromSession?: CallSession | null | undefined, autoAnswer = false): CallSession {
     return this._createCallSession(sipSession, fromSession, {
       incoming: true,
       ringing: true,
@@ -1695,82 +1731,80 @@ export default class WebRTCPhone extends Emitter implements Phone {
     });
   }
 
-  _createOutgoingCallSession(
-    sipSession: Session,
-    cameraEnabled: boolean,
-    fromSession?: CallSession,
-  ): CallSession {
-    return this._createCallSession(sipSession, fromSession, { incoming: false, ringing: true, cameraEnabled });
+  _createOutgoingCallSession(sipSession: Invitation | Inviter, cameraEnabled: boolean, fromSession?: CallSession): CallSession {
+    return this._createCallSession(sipSession, fromSession, {
+      incoming: false,
+      ringing: true,
+      cameraEnabled,
+    });
   }
 
-  _createAcceptedCallSession(
-    sipSession: Session,
-    cameraEnabled?: boolean,
-    fromSession?: CallSession,
-  ): CallSession {
+  _createAcceptedCallSession(sipSession: Invitation | Inviter, cameraEnabled?: boolean, fromSession?: CallSession): CallSession {
     return this._createCallSession(sipSession, fromSession, {
       cameraEnabled: cameraEnabled !== undefined ? cameraEnabled : false,
     });
   }
 
-  _createMutedCallSession(sipSession: Session, fromSession?: CallSession): CallSession {
+  _createMutedCallSession(sipSession: Invitation | Inviter, fromSession?: CallSession): CallSession {
     return this._createCallSession(sipSession, fromSession, {
       muted: true,
     });
   }
 
-  _createUnmutedCallSession(sipSession: Session, fromSession?: CallSession): CallSession {
+  _createUnmutedCallSession(sipSession: Invitation | Inviter, fromSession?: CallSession): CallSession {
     return this._createCallSession(sipSession, fromSession, {
       muted: false,
     });
   }
 
-  _createCameraResumedCallSession(sipSession: Session, fromSession?: CallSession): CallSession {
+  _createCameraResumedCallSession(sipSession: Invitation | Inviter, fromSession?: CallSession): CallSession {
     return this._createCallSession(sipSession, fromSession, {
       videoMuted: false,
     });
   }
 
-  _createCameraDisabledCallSession(sipSession: Session, fromSession?: CallSession): CallSession {
+  _createCameraDisabledCallSession(sipSession: Invitation | Inviter, fromSession?: CallSession): CallSession {
     return this._createCallSession(sipSession, fromSession, {
       videoMuted: true,
     });
   }
 
-  _createCallSession(sipSession: Session, fromSession?: ?CallSession, extra: Object = {}): CallSession {
+  _createCallSession(sipSession: Invitation | Inviter, fromSession?: CallSession | null | undefined, extra: Record<string, any> = {}): CallSession {
     // eslint-disable-next-line
     const identity = sipSession ? sipSession.remoteIdentity || sipSession.assertedIdentity : null;
+    // @ts-ignore
     const number = identity ? identity.uri._normal.user : null;
-    const { state } = sipSession || {};
+    const {
+      state,
+    } = sipSession || {};
     const sessionId = this.getSipSessionId(sipSession);
     fromSession = fromSession || this.callSessions[sessionId];
-
     const callSession = new CallSession({
       callId: fromSession && fromSession.callId,
       sipCallId: sessionId,
       sipStatus: state,
       displayName: identity ? identity.displayName || number : number,
+      // @ts-ignore: @HEADSUP: startTime should be a number, not a date
       startTime: fromSession ? fromSession.startTime : new Date(),
       creationTime: fromSession ? fromSession.creationTime : null,
       answerTime: fromSession ? fromSession.answerTime : null,
       endTime: fromSession ? fromSession.endTime : null,
       answered: state === SessionState.Established,
       paused: this.client.isCallHeld(sipSession),
-      isCaller: fromSession ? fromSession.isCaller : ('incoming' in extra ? !extra.incoming : false),
+      isCaller: fromSession ? fromSession.isCaller : 'incoming' in extra ? !extra.incoming : false,
       cameraEnabled: fromSession ? fromSession.isCameraEnabled() : this.client.hasVideo(sessionId),
       number,
       ringing: false,
       muted: fromSession ? fromSession.isMuted() : this.client.isAudioMuted(sipSession),
       videoMuted: fromSession ? fromSession.isVideoMuted() : false,
       recording: fromSession ? fromSession.isRecording() : false,
-      recordingPaused: false, // @TODO
+      recordingPaused: false,
       sipSession,
       conference: !!fromSession && fromSession.isConference(),
       ...extra,
     });
-
-    this.callSessions[callSession.getId()] = callSession;
-
+    this.callSessions[sessionId] = callSession;
     return callSession;
   }
+
 }