@zelloptt/react-native-zello-sdk 2.0.1 → 3.0.0

package/lib/module/sdk/index.js

@@ -1,30 +1,20 @@
 "use strict";
 
-var _Zello;
-function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
-function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
-function _possibleConstructorReturn(t, e) { if (e && ("object" == typeof e || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
-function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function () { return !!t; })(); }
-function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
-function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
-function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 // noinspection JSUnusedGlobalSymbols
 
-import { NativeEventEmitter, NativeModules } from 'react-native';
+import { DeviceEventEmitter, NativeModules } from 'react-native';
 import { bridgeCallToSdkCall, bridgeChannelUserToSdkChannelUser, bridgeConsoleSettingsToSdkConsoleSettings, isAndroid } from "../utils/index.js";
-import { ZelloAccountStatus, ZelloAlertMessage, ZelloConnectionError, ZelloConnectionState, ZelloContactType, ZelloImageMessage, ZelloIncomingVoiceMessage, ZelloLocationMessage, ZelloOutgoingEmergency, ZelloOutgoingVoiceMessage, ZelloOutgoingVoiceMessageError, ZelloOutgoingVoiceMessageState, ZelloRecentEntry, ZelloTextMessage } from "../types/index.js";
+import { ZelloAccountStatus, ZelloAlertMessage, ZelloConnectionError, ZelloConnectionState, ZelloContactType, ZelloHistoryVoiceMessage, ZelloImageMessage, ZelloIncomingVoiceMessage, ZelloLocationMessage, ZelloOutgoingEmergency, ZelloOutgoingVoiceMessage, ZelloOutgoingVoiceMessageError, ZelloOutgoingVoiceMessageState, ZelloRecentEntry, ZelloTextMessage } from "../types/index.js";
 import EventEmitter from 'react-native/Libraries/vendor/emitter/EventEmitter';
 import { compareNameAscending, sortedArrayFind } from "../utils/algorithms/index.js";
 import { bridgeContactToSdkContact, bridgeHistoryMessageToSdkHistoryMessage, bridgeIncomingEmergencyToSdkIncomingEmergency } from "../utils/index.js";
 import { ZelloEvent } from "../events/index.js";
+import NativeZelloSdk from "../specs/NativeZelloSdk.js";
+
+// `ZelloIOSSdkModule` is the iOS RCTEventEmitter that owns the Zello delegate
+// (see `getSdk`). All method calls go through the unified `NativeZelloSdk`
+// TurboModule, which on Android also owns the delegate.
 const {
-  ZelloAndroidSdkModule,
   ZelloIOSSdkModule
 } = NativeModules;
 
@@ -32,1010 +22,838 @@ const {
  * Zello SDK.
  * This class is a singleton, and can be accessed via {@link Zello.getInstance}.
  */
-export let Zello = /*#__PURE__*/function (_EventEmitter) {
-  function Zello() {
-    var _this;
-    _classCallCheck(this, Zello);
-    _this = _callSuper(this, Zello);
-    /**
-     * The current connection state of the SDK.
-     */
-    _defineProperty(_this, "state", ZelloConnectionState.Disconnected);
-    /**
-     * The currently selected contact.
-     */
-    _defineProperty(_this, "selectedContact", void 0);
-    /**
-     * The list of {@link ZelloUser} in the contact list. Sorted by name, ascending.
-     */
-    _defineProperty(_this, "users", []);
-    /**
-     * The list of {@link ZelloChannel} in the contact list. Sorted by name, ascending.
-     */
-    _defineProperty(_this, "channels", []);
-    /**
-     * The list of {@link ZelloGroupConversation} in the contact list. Sorted by name, ascending.
-     */
-    _defineProperty(_this, "groupConversations", []);
-    /**
-     * The current account status. undefined when {@link state} is not {@link ZelloConnectionState.Connected}.
-     */
-    _defineProperty(_this, "accountStatus", void 0);
-    /**
-     * The current incoming voice message.
-     */
-    _defineProperty(_this, "incomingVoiceMessage", void 0);
-    /**
-     * The current outgoing voice message.
-     */
-    _defineProperty(_this, "outgoingVoiceMessage", void 0);
-    /**
-     * The configured emergency channel.
-     */
-    _defineProperty(_this, "emergencyChannel", void 0);
-    /**
-     * The list of incoming emergencies. There can be multiple emergencies on the emergency channel at once.
-     * Sorted by start timestamp, ascending.
-     */
-    _defineProperty(_this, "incomingEmergencies", []);
-    /**
-     * The current outgoing emergency.
-     */
-    _defineProperty(_this, "outgoingEmergency", void 0);
-    /**
-     * The list of recent entries. Sorted by timestamp, descending.
-     */
-    _defineProperty(_this, "recents", []);
-    /**
-     * The currently playing history voice message.
-     */
-    _defineProperty(_this, "historyVoiceMessage", void 0);
-    /**
-     * The console settings for the network.
-     * This is only expected to be valid when {@link state} is {@link ZelloConnectionState.Connected}.
-     */
-    _defineProperty(_this, "consoleSettings", void 0);
-    _defineProperty(_this, "eventListener", void 0);
+export class Zello extends EventEmitter {
+  static getInstance() {
+    if (!Zello.instance) {
+      Zello.instance = new Zello();
+    }
+    return Zello.instance;
+  }
+
+  /**
+   * The current connection state of the SDK.
+   */
+  state = ZelloConnectionState.Disconnected;
+
+  /**
+   * The currently selected contact.
+   */
+
+  /**
+   * The list of {@link ZelloUser} in the contact list. Sorted by name, ascending.
+   */
+  users = [];
+  /**
+   * The list of {@link ZelloChannel} in the contact list. Sorted by name, ascending.
+   */
+  channels = [];
+  /**
+   * The list of {@link ZelloGroupConversation} in the contact list. Sorted by name, ascending.
+   */
+  groupConversations = [];
+
+  /**
+   * The current account status. undefined when {@link state} is not {@link ZelloConnectionState.Connected}.
+   */
+
+  /**
+   * The current incoming voice message.
+   */
+
+  /**
+   * The current outgoing voice message.
+   */
+
+  /**
+   * The configured emergency channel.
+   */
+
+  /**
+   * The list of incoming emergencies. There can be multiple emergencies on the emergency channel at once.
+   * Sorted by start timestamp, ascending.
+   */
+  incomingEmergencies = [];
+  /**
+   * The current outgoing emergency.
+   */
+
+  /**
+   * The list of recent entries. Sorted by timestamp, descending.
+   */
+  recents = [];
+
+  /**
+   * The currently playing history voice message.
+   */
+
+  /**
+   * The console settings for the network.
+   * This is only expected to be valid when {@link state} is {@link ZelloConnectionState.Connected}.
+   */
+
+  constructor() {
+    super();
+    // Accessing the native module instantiates it, which registers the SDK
+    // delegate that drives events. The events themselves arrive on the global
+    // DeviceEventEmitter 'zellosdk' channel (bridgeless-safe on both platforms).
     const sdk = Zello.getSdk();
     if (sdk) {
-      let eventEmitter;
-      if (isAndroid) {
-        eventEmitter = new NativeEventEmitter();
-      } else {
-        eventEmitter = new NativeEventEmitter(sdk);
-      }
-      _this.setupEventListener(eventEmitter);
+      this.setupEventListener();
     }
-    return _this;
   }
 
   /**
    * Sets configuration variables for the SDK.
    * @param config The configuration to set.
    */
-  _inherits(Zello, _EventEmitter);
-  return _createClass(Zello, [{
-    key: "configure",
-    value: function configure(config) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.configure(config.android.enableOfflineMessagePushNotifications, config.android.enableForegroundService);
-      } else {
-        ZelloIOSSdkModule.configure(config.ios.isDebugBuild, config.ios.appGroup);
-      }
-    }
+  configure(config) {
+    NativeZelloSdk.configure(config);
+  }
 
-    /**
-     * Destroys the SDK instance and cleans up resources.
-     * Call this when you are done using the SDK instance for good (application quit).
-     */
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      this.removeAllListeners();
-      this.eventListener?.remove();
-    }
+  /**
+   * Destroys the SDK instance and cleans up resources.
+   * Call this when you are done using the SDK instance for good (application quit).
+   */
+  destroy() {
+    this.removeAllListeners();
+    this.eventListener?.remove();
+  }
 
-    /**
-     * Signs into to the Zello Work network using the provided credentials.
-     * This will typically trigger the {@link ZelloEvent.CONNECT_STARTED} event, followed by either {@link ZelloEvent.CONNECT_SUCCEEDED} or {@link ZelloEvent.CONNECT_FAILED}.
-     * However, if the state is incorrect, {@link ZelloEvent.CONNECT_FAILED} will be triggered immediately.
-     * @param credentials The credentials to use for signing in.
-     */
-  }, {
-    key: "connect",
-    value: function connect(credentials) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.connect(credentials.network, credentials.username, credentials.password);
-      } else {
-        ZelloIOSSdkModule.connect(credentials.network, credentials.username, credentials.password);
-      }
-    }
+  /**
+   * Signs into to the Zello Work network using the provided credentials.
+   * This will typically trigger the {@link ZelloEvent.CONNECT_STARTED} event, followed by either {@link ZelloEvent.CONNECT_SUCCEEDED} or {@link ZelloEvent.CONNECT_FAILED}.
+   * However, if the state is incorrect, {@link ZelloEvent.CONNECT_FAILED} will be triggered immediately.
+   * @param credentials The credentials to use for signing in.
+   */
+  connect(credentials) {
+    NativeZelloSdk.connect(credentials.network, credentials.username, credentials.password);
+  }
 
-    /**
-     * Signs out of the Zello Work network.
-     * This will trigger the {@link ZelloEvent.DISCONNECTED} event.
-     */
-  }, {
-    key: "disconnect",
-    value: function disconnect() {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.disconnect();
-      } else {
-        ZelloIOSSdkModule.disconnect();
-      }
-    }
+  /**
+   * Signs out of the Zello Work network.
+   * This will trigger the {@link ZelloEvent.DISCONNECTED} event.
+   */
+  disconnect() {
+    NativeZelloSdk.disconnect();
+  }
 
-    /**
-     * Returns the user with the given name. Case-insensitive.
-     * @param name The name of the user to search for.
-     * @return The user with the given name, or null if no user with that name exists.
-     */
-  }, {
-    key: "getUser",
-    value: function getUser(name) {
-      return sortedArrayFind(this.users, name, compareNameAscending);
-    }
+  /**
+   * Returns the user with the given name. Case-insensitive.
+   * @param name The name of the user to search for.
+   * @return The user with the given name, or null if no user with that name exists.
+   */
+  getUser(name) {
+    return sortedArrayFind(this.users, name, compareNameAscending);
+  }
 
-    /**
-     * Returns the channel with the given name. Case-insensitive.
-     * @param name The name of the channel to search for.
-     * @return The channel with the given name, or null if no channel with that name exists.
-     */
-  }, {
-    key: "getChannel",
-    value: function getChannel(name) {
-      return sortedArrayFind(this.channels, name, compareNameAscending);
-    }
+  /**
+   * Returns the channel with the given name. Case-insensitive.
+   * @param name The name of the channel to search for.
+   * @return The channel with the given name, or null if no channel with that name exists.
+   */
+  getChannel(name) {
+    return sortedArrayFind(this.channels, name, compareNameAscending);
+  }
 
-    /**
-     * Returns the group conversation with the given name. Case-insensitive.
-     * @param name The name of the group conversation to search for.
-     * @return The group conversation with the given name, or null if no group conversation with that name exists.
-     */
-  }, {
-    key: "getGroupConversation",
-    value: function getGroupConversation(name) {
-      return sortedArrayFind(this.groupConversations, name, compareNameAscending);
-    }
+  /**
+   * Returns the group conversation with the given name. Case-insensitive.
+   * @param name The name of the group conversation to search for.
+   * @return The group conversation with the given name, or null if no group conversation with that name exists.
+   */
+  getGroupConversation(name) {
+    return sortedArrayFind(this.groupConversations, name, compareNameAscending);
+  }
 
-    /**
-     * Sets the selected contact.
-     * While optional, this is typically used for tracking the contact that the user is currently interacting with.
-     * This will trigger the {@link ZelloEvent.SELECTED_CONTACT_CHANGED} event.
-     * @param contact The contact to set as selected.
-     */
-  }, {
-    key: "setSelectedContact",
-    value: function setSelectedContact(contact) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.setSelectedContact(contact.name, contact.type);
-      } else {
-        ZelloIOSSdkModule.selectContact(contact.name, contact.type);
-      }
-    }
+  /**
+   * Sets the selected contact.
+   * While optional, this is typically used for tracking the contact that the user is currently interacting with.
+   * This will trigger the {@link ZelloEvent.SELECTED_CONTACT_CHANGED} event.
+   * @param contact The contact to set as selected.
+   */
+  setSelectedContact(contact) {
+    NativeZelloSdk.selectContact(contact.name, contact.type);
+  }
 
-    /**
-     * Sets the user's online account status.
-     * This will trigger the {@link ZelloEvent.ACCOUNT_STATUS_CHANGED} event.
-     * @param status The account status to set.
-     */
-  }, {
-    key: "setAccountStatus",
-    value: function setAccountStatus(status) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.setAccountStatus(status);
-      } else {
-        ZelloIOSSdkModule.setAccountStatus(status);
-      }
-    }
+  /**
+   * Sets the user's online account status.
+   * This will trigger the {@link ZelloEvent.ACCOUNT_STATUS_CHANGED} event.
+   * @param status The account status to set.
+   */
+  setAccountStatus(status) {
+    NativeZelloSdk.setAccountStatus(status);
+  }
 
-    /**
-     * Connects to the given channel.
-     * Once connected, the user will be able to send and receive messages from the channel.
-     * This will trigger the {@link ZelloEvent.CONTACT_LIST_UPDATED} event.
-     * @param channel The channel to connect to.
-     */
-  }, {
-    key: "connectChannel",
-    value: function connectChannel(channel) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.connectChannel(channel.name);
-      } else {
-        if (channel.type === ZelloContactType.GroupConversation) {
-          ZelloIOSSdkModule.connectGroupConversation(channel.name);
-        } else {
-          ZelloIOSSdkModule.connectChannel(channel.name);
-        }
-      }
+  /**
+   * Connects to the given channel.
+   * Once connected, the user will be able to send and receive messages from the channel.
+   * This will trigger the {@link ZelloEvent.CONTACT_LIST_UPDATED} event.
+   * @param channel The channel to connect to.
+   */
+  connectChannel(channel) {
+    if (channel.type === ZelloContactType.GroupConversation) {
+      NativeZelloSdk.connectGroupConversation(channel.name);
+    } else {
+      NativeZelloSdk.connectChannel(channel.name);
     }
+  }
 
-    /**
-     * Disconnects from the given channel.
-     * Once disconnected, the user will no longer be able to send or receive messages from the channel.
-     * This will trigger the {@link ZelloEvent.CONTACT_LIST_UPDATED} event.
-     * @param channel The channel to disconnect from.
-     */
-  }, {
-    key: "disconnectChannel",
-    value: function disconnectChannel(channel) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.disconnectChannel(channel.name);
-      } else {
-        if (channel.type === ZelloContactType.GroupConversation) {
-          ZelloIOSSdkModule.disconnectGroupConversation(channel.name);
-        } else {
-          ZelloIOSSdkModule.disconnectChannel(channel.name);
-        }
-      }
+  /**
+   * Disconnects from the given channel.
+   * Once disconnected, the user will no longer be able to send or receive messages from the channel.
+   * This will trigger the {@link ZelloEvent.CONTACT_LIST_UPDATED} event.
+   * @param channel The channel to disconnect from.
+   */
+  disconnectChannel(channel) {
+    if (channel.type === ZelloContactType.GroupConversation) {
+      NativeZelloSdk.disconnectGroupConversation(channel.name);
+    } else {
+      NativeZelloSdk.disconnectChannel(channel.name);
     }
+  }
 
-    /**
-     * Starts a voice message with the given contact.
-     * This will trigger the {@link ZelloEvent.OUTGOING_VOICE_MESSAGE_CONNECTING} event, followed by the {@link ZelloEvent.OUTGOING_VOICE_MESSAGE_STARTED} event.
-     * If there is an error, the {@link ZelloEvent.OUTGOING_VOICE_MESSAGE_STOPPED} event will be triggered.
-     * @param contact The contact to start the voice message with.
-     */
-  }, {
-    key: "startVoiceMessage",
-    value: function startVoiceMessage(contact) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.startVoiceMessage(contact.name, contact.type);
-      } else {
-        ZelloIOSSdkModule.startVoiceMessage(contact.name, contact.type);
-      }
-    }
+  /**
+   * Starts a voice message with the given contact.
+   * This will trigger the {@link ZelloEvent.OUTGOING_VOICE_MESSAGE_CONNECTING} event, followed by the {@link ZelloEvent.OUTGOING_VOICE_MESSAGE_STARTED} event.
+   * If there is an error, the {@link ZelloEvent.OUTGOING_VOICE_MESSAGE_STOPPED} event will be triggered.
+   * @param contact The contact to start the voice message with.
+   */
+  startVoiceMessage(contact) {
+    NativeZelloSdk.startVoiceMessage(contact.name, contact.type);
+  }
 
-    /**
-     * Stops the current outgoing voice message.
-     * This will trigger the {@link ZelloEvent.OUTGOING_VOICE_MESSAGE_STOPPED} event.
-     */
-  }, {
-    key: "stopVoiceMessage",
-    value: function stopVoiceMessage() {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.stopVoiceMessage();
-      } else {
-        ZelloIOSSdkModule.stopVoiceMessage();
-      }
-    }
+  /**
+   * Stops the current outgoing voice message.
+   * This will trigger the {@link ZelloEvent.OUTGOING_VOICE_MESSAGE_STOPPED} event.
+   */
+  stopVoiceMessage() {
+    NativeZelloSdk.stopVoiceMessage();
+  }
 
-    /**
-     * Sends the image message data to the given contact.
-     * This will trigger the {@link ZelloEvent.OUTGOING_IMAGE_MESSAGE_SENT} or {@link ZelloEvent.OUTGOING_IMAGE_MESSAGE_SEND_FAILED} event.
-     * @param contact The contact to send the image to.
-     * @param data The image data to send.
-     */
-  }, {
-    key: "sendImage",
-    value: function sendImage(contact, data) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.sendImage(contact.name, contact.type, data);
-      } else {
-        ZelloIOSSdkModule.sendImage(contact.name, contact.type, data);
-      }
-    }
+  /**
+   * Sends the image message data to the given contact.
+   * This will trigger the {@link ZelloEvent.OUTGOING_IMAGE_MESSAGE_SENT} or {@link ZelloEvent.OUTGOING_IMAGE_MESSAGE_SEND_FAILED} event.
+   * @param contact The contact to send the image to.
+   * @param data The image data to send.
+   */
+  sendImage(contact, data) {
+    NativeZelloSdk.sendImage(contact.name, contact.type, data);
+  }
 
-    /**
-     * Sends the alert message to the given contact.
-     * This will trigger the {@link ZelloEvent.OUTGOING_ALERT_MESSAGE_SENT} or {@link ZelloEvent.OUTGOING_ALERT_MESSAGE_SEND_FAILED} event.
-     * @param contact The contact to send the alert to.
-     */
-  }, {
-    key: "sendLocation",
-    value: function sendLocation(contact) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.sendLocation(contact.name, contact.type);
-      } else {
-        ZelloIOSSdkModule.sendLocation(contact.name, contact.type);
-      }
-    }
+  /**
+   * Sends the alert message to the given contact.
+   * This will trigger the {@link ZelloEvent.OUTGOING_ALERT_MESSAGE_SENT} or {@link ZelloEvent.OUTGOING_ALERT_MESSAGE_SEND_FAILED} event.
+   * @param contact The contact to send the alert to.
+   */
+  sendLocation(contact) {
+    NativeZelloSdk.sendLocation(contact.name, contact.type);
+  }
 
-    /**
-     * Sends the text message to the given contact.
-     * This will trigger the {@link ZelloEvent.OUTGOING_TEXT_MESSAGE_SENT} or {@link ZelloEvent.OUTGOING_TEXT_MESSAGE_SEND_FAILED} event.
-     * @param contact The contact to send the text to.
-     * @param text The text to send.
-     */
-  }, {
-    key: "sendText",
-    value: function sendText(contact, text) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.sendText(contact.name, contact.type, text);
-      } else {
-        ZelloIOSSdkModule.sendText(contact.name, contact.type, text);
-      }
-    }
+  /**
+   * Sends the text message to the given contact.
+   * This will trigger the {@link ZelloEvent.OUTGOING_TEXT_MESSAGE_SENT} or {@link ZelloEvent.OUTGOING_TEXT_MESSAGE_SEND_FAILED} event.
+   * @param contact The contact to send the text to.
+   * @param text The text to send.
+   */
+  sendText(contact, text) {
+    NativeZelloSdk.sendText(contact.name, contact.type, text);
+  }
 
-    /**
-     * Sends the alert message to the given contact.
-     * This will trigger the {@link ZelloEvent.OUTGOING_ALERT_MESSAGE_SENT} or {@link ZelloEvent.OUTGOING_ALERT_MESSAGE_SEND_FAILED} event.
-     * @param contact The contact to send the alert to.
-     * @param text The text to send.
-     * @param level Optional; The alert level to send. Only applicable for channels.
-     */
-  }, {
-    key: "sendAlert",
-    value: function sendAlert(contact, text, level) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.sendAlert(contact.name, contact.type, text, level);
-      } else {
-        ZelloIOSSdkModule.sendAlert(contact.name, contact.type, text, level);
-      }
-    }
+  /**
+   * Sends the alert message to the given contact.
+   * This will trigger the {@link ZelloEvent.OUTGOING_ALERT_MESSAGE_SENT} or {@link ZelloEvent.OUTGOING_ALERT_MESSAGE_SEND_FAILED} event.
+   * @param contact The contact to send the alert to.
+   * @param text The text to send.
+   * @param level Optional; The alert level to send. Only applicable for channels.
+   */
+  sendAlert(contact, text, level) {
+    NativeZelloSdk.sendAlert(contact.name, contact.type, text, level ?? '');
+  }
 
-    /**
-     * Submits a problem report to Zello.
-     * Additionally, please contact us to provide more information on what happened.
-     */
-  }, {
-    key: "submitProblemReport",
-    value: function submitProblemReport() {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.submitProblemReport();
-      } else {
-        ZelloIOSSdkModule.submitProblemReport();
-      }
-    }
+  /**
+   * Submits a problem report to Zello.
+   * Additionally, please contact us to provide more information on what happened.
+   */
+  submitProblemReport() {
+    NativeZelloSdk.submitProblemReport();
+  }
 
-    /**
-     * Mutes the given contact. When muted, incoming messages from this contact will not play live, but will still appear in the history.
-     * This will trigger the {@link ZelloEvent.CONTACT_LIST_UPDATED} event.
-     * @param contact The contact to mute.
-     */
-  }, {
-    key: "muteContact",
-    value: function muteContact(contact) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.muteContact(contact.name, contact.type);
-      } else {
-        ZelloIOSSdkModule.muteContact(contact.name, contact.type);
-      }
-    }
+  /**
+   * Mutes the given contact. When muted, incoming messages from this contact will not play live, but will still appear in the history.
+   * This will trigger the {@link ZelloEvent.CONTACT_LIST_UPDATED} event.
+   * @param contact The contact to mute.
+   */
+  muteContact(contact) {
+    NativeZelloSdk.muteContact(contact.name, contact.type);
+  }
 
-    /**
-     * Unmutes a previously muted contact. When unmuted, incoming messages from this contact will play live.
-     * This will trigger the {@link ZelloEvent.CONTACT_LIST_UPDATED} event.
-     * @param contact The contact to unmute.
-     */
-  }, {
-    key: "unmuteContact",
-    value: function unmuteContact(contact) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.unmuteContact(contact.name, contact.type);
-      } else {
-        ZelloIOSSdkModule.unmuteContact(contact.name, contact.type);
-      }
-    }
+  /**
+   * Unmutes a previously muted contact. When unmuted, incoming messages from this contact will play live.
+   * This will trigger the {@link ZelloEvent.CONTACT_LIST_UPDATED} event.
+   * @param contact The contact to unmute.
+   */
+  unmuteContact(contact) {
+    NativeZelloSdk.unmuteContact(contact.name, contact.type);
+  }
 
-    /**
-     * Starts an outgoing emergency to the emergency channel.
-     * Upon starting, the user's location will be sent, an alert message will be sent, and a 10-second-long voice message will start recording.
-     * This will trigger the {@link ZelloEvent.OUTGOING_EMERGENCY_STARTED} event.
-     */
-  }, {
-    key: "startEmergency",
-    value: function startEmergency() {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.startEmergency();
-      } else {
-        ZelloIOSSdkModule.startEmergency();
-      }
-    }
+  /**
+   * Starts an outgoing emergency to the emergency channel.
+   * Upon starting, the user's location will be sent, an alert message will be sent, and a 10-second-long voice message will start recording.
+   * This will trigger the {@link ZelloEvent.OUTGOING_EMERGENCY_STARTED} event.
+   */
+  startEmergency() {
+    NativeZelloSdk.startEmergency();
+  }
 
-    /**
-     * Stops the outgoing emergency.
-     * This will trigger the {@link ZelloEvent.OUTGOING_EMERGENCY_STOPPED} event.
-     */
-  }, {
-    key: "stopEmergency",
-    value: function stopEmergency() {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.stopEmergency();
-      } else {
-        ZelloIOSSdkModule.stopEmergency();
-      }
-    }
+  /**
+   * Stops the outgoing emergency.
+   * This will trigger the {@link ZelloEvent.OUTGOING_EMERGENCY_STOPPED} event.
+   */
+  stopEmergency() {
+    NativeZelloSdk.stopEmergency();
+  }
 
-    /**
-     * Returns the history messages for the given contact.
-     * @param contact The contact to get the history for.
-     * @param size Optional; The number of history items to retrieve. Defaults to 50.
-     * @return The history items for the given contact.
-     */
-  }, {
-    key: "getHistory",
-    value: function getHistory(contact, size) {
-      const defaultHistorySize = 50;
-      return new Promise(resolve => {
-        const callback = history => {
-          if (!history) {
-            resolve([]);
-            return;
-          }
-          const messages = history.map(message => bridgeHistoryMessageToSdkHistoryMessage(message)).filter(item => item !== undefined);
-          resolve(messages);
-        };
-        if (isAndroid) {
-          ZelloAndroidSdkModule.getHistory(contact.name, contact.type, size ?? defaultHistorySize, callback);
-        } else {
-          ZelloIOSSdkModule.getHistory(contact.name, contact.type, size ?? defaultHistorySize, callback);
-        }
-      });
-    }
+  /**
+   * Stops an incoming emergency started by another user on the emergency channel.
+   *
+   * This requires the emergency channel's {@link ZelloChannelOptions.allowEmergencyEndOthers | allowEmergencyEndOthers} option
+   * to be true; otherwise this method has no effect.
+   *
+   * On success, this will trigger the {@link ZelloEvent.INCOMING_EMERGENCY_STOPPED} event for the emergency.
+   * @param incomingEmergency The incoming emergency to stop. Must be one of the entries currently in {@link incomingEmergencies}.
+   */
+  stopIncomingEmergency(incomingEmergency) {
+    NativeZelloSdk.stopIncomingEmergency(incomingEmergency.emergencyId);
+  }
 
-    /**
-     * Plays the given history message.
-     * This will trigger the {@link ZelloEvent.HISTORY_PLAYBACK_STARTED} event.
-     * @param message The history message to play.
-     */
-  }, {
-    key: "playHistoryMessage",
-    value: function playHistoryMessage(message) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.playHistoryMessage(message.historyId, message.contact.name, message.contact.type);
-      } else {
-        ZelloIOSSdkModule.playHistoryMessage(message.historyId, message.contact.name, message.contact.type);
-      }
+  /**
+   * Returns the history messages for the given contact.
+   * @param contact The contact to get the history for.
+   * @param size Optional; The number of history items to retrieve. Defaults to 50.
+   * @return The history items for the given contact.
+   */
+  async getHistory(contact, size) {
+    const defaultHistorySize = 50;
+    const history = await NativeZelloSdk.getHistory(contact.name, contact.type, size ?? defaultHistorySize);
+    if (!history) {
+      return [];
     }
+    return history.map(message => bridgeHistoryMessageToSdkHistoryMessage(message)).filter(item => item !== undefined);
+  }
 
-    /**
-     * Stops the current history message playback.
-     * This will trigger the {@link ZelloEvent.HISTORY_PLAYBACK_STOPPED} event.
-     */
-  }, {
-    key: "stopHistoryMessagePlayback",
-    value: function stopHistoryMessagePlayback() {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.stopHistoryMessagePlayback();
-      } else {
-        ZelloIOSSdkModule.stopHistoryMessagePlayback();
-      }
-    }
+  /**
+   * Plays the given history message.
+   * This will trigger the {@link ZelloEvent.HISTORY_PLAYBACK_STARTED} event.
+   * @param message The history message to play.
+   */
+  playHistoryMessage(message) {
+    NativeZelloSdk.playHistoryMessage(message.historyId, message.contact.name, message.contact.type);
+  }
 
-    /**
-     * Returns the image data for the given history image message.
-     * @param message The history image message to get the image data for.
-     * @return The image data for the given history image message.
-     */
-  }, {
-    key: "getImageDataForHistoryImageMessage",
-    value: function getImageDataForHistoryImageMessage(message) {
-      return new Promise(resolve => {
-        if (isAndroid) {
-          ZelloAndroidSdkModule.getImageDataForHistoryImageMessage(message.historyId, message.contact.name, message.contact.type, data => resolve(data));
-        } else {
-          ZelloIOSSdkModule.getHistoryImageData(message.historyId, message.contact.name, message.contact.type, data => resolve(data));
-        }
-      });
-    }
+  /**
+   * Stops the current history message playback.
+   * This will trigger the {@link ZelloEvent.HISTORY_PLAYBACK_STOPPED} event.
+   */
+  stopHistoryMessagePlayback() {
+    NativeZelloSdk.stopHistoryMessagePlayback();
+  }
 
-    /**
-     * Ends the dispatch call for the given dispatch channel.
-     * This will trigger the {@link ZelloEvent.DISPATCH_CALL_ENDED} event.
-     *
-     * If {@link consoleSettings | ZelloConsoleSettings.allowNonDispatchersToEndCalls} is false, this method will do nothing.
-     *
-     * @param channel The dispatch channel to end the call for.
-     */
-  }, {
-    key: "endDispatchCall",
-    value: function endDispatchCall(channel) {
-      if (isAndroid) {
-        ZelloAndroidSdkModule.endDispatchCall(channel.name);
-      } else {
-        ZelloIOSSdkModule.endDispatchCall(channel.name);
-      }
-    }
+  /**
+   * Returns the image data for the given history image message.
+   * @param message The history image message to get the image data for.
+   * @return The image data for the given history image message.
+   */
+  getImageDataForHistoryImageMessage(message) {
+    return NativeZelloSdk.getHistoryImageData(message.historyId, message.contact.name, message.contact.type);
+  }
 
-    /**
-     * Creates a new group conversation with the given users.
-     * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_CREATED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
-     * @param users The users to create the group conversation with.
-     * @param displayName Optional; The display name of the group conversation. The conversation can be renamed later by using {@link renameGroupConversation}.
-     */
-  }, {
-    key: "createGroupConversation",
-    value: function createGroupConversation(users, displayName) {
-      if (!this.consoleSettings?.allowGroupConversations) {
-        return;
-      }
-      if (isAndroid) {
-        ZelloAndroidSdkModule.createGroupConversation(users.map(user => user.name), displayName);
-      } else {
-        ZelloIOSSdkModule.createGroupConversation(users.map(user => user.name), displayName);
-      }
+  /**
+   * Ends the dispatch call for the given dispatch channel.
+   * This will trigger the {@link ZelloEvent.DISPATCH_CALL_ENDED} event.
+   *
+   * If {@link consoleSettings | ZelloConsoleSettings.allowNonDispatchersToEndCalls} is false, this method will do nothing.
+   *
+   * @param channel The dispatch channel to end the call for.
+   */
+  endDispatchCall(channel) {
+    NativeZelloSdk.endDispatchCall(channel.name);
+  }
+
+  /**
+   * Creates a new group conversation with the given users.
+   * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_CREATED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
+   * @param users The users to create the group conversation with.
+   * @param displayName Optional; The display name of the group conversation. The conversation can be renamed later by using {@link renameGroupConversation}.
+   */
+  createGroupConversation(users, displayName) {
+    if (!this.consoleSettings?.allowGroupConversations) {
+      return;
     }
+    NativeZelloSdk.createGroupConversation(users.map(user => user.name), displayName ?? '');
+  }
 
-    /**
-     * Adds users to the given group conversation.
-     * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_USERS_ADDED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
-     * @param groupConversation The group conversation to add users to.
-     * @param users The users to add to the group conversation.
-     */
-  }, {
-    key: "addUsersToGroupConversation",
-    value: function addUsersToGroupConversation(groupConversation, users) {
-      if (!this.consoleSettings?.allowGroupConversations) {
-        return;
-      }
-      if (isAndroid) {
-        ZelloAndroidSdkModule.addUsersToGroupConversation(groupConversation.name, users.map(user => user.name));
-      } else {
-        ZelloIOSSdkModule.addUsersToGroupConversation(groupConversation.name, users.map(user => user.name));
-      }
+  /**
+   * Adds users to the given group conversation.
+   * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_USERS_ADDED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
+   * @param groupConversation The group conversation to add users to.
+   * @param users The users to add to the group conversation.
+   */
+  addUsersToGroupConversation(groupConversation, users) {
+    if (!this.consoleSettings?.allowGroupConversations) {
+      return;
     }
+    NativeZelloSdk.addUsersToGroupConversation(groupConversation.name, users.map(user => user.name));
+  }
 
-    /**
-     * Removes the user from the group conversation.
-     * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_LEFT} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
-     * @param groupConversation The group conversation to leave.
-     */
-  }, {
-    key: "leaveGroupConversation",
-    value: function leaveGroupConversation(groupConversation) {
-      if (!this.consoleSettings?.allowGroupConversations) {
-        return;
-      }
-      if (isAndroid) {
-        ZelloAndroidSdkModule.leaveGroupConversation(groupConversation.name);
-      } else {
-        ZelloIOSSdkModule.leaveGroupConversation(groupConversation.name);
-      }
+  /**
+   * Removes the user from the group conversation.
+   * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_LEFT} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
+   * @param groupConversation The group conversation to leave.
+   */
+  leaveGroupConversation(groupConversation) {
+    if (!this.consoleSettings?.allowGroupConversations) {
+      return;
     }
+    NativeZelloSdk.leaveGroupConversation(groupConversation.name);
+  }
 
-    /**
-     * Renames the group conversation.
-     * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_RENAMED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
-     * @param groupConversation The group conversation to rename.
-     * @param name The new name for the group conversation.
-     */
-  }, {
-    key: "renameGroupConversation",
-    value: function renameGroupConversation(groupConversation, name) {
-      if (!this.consoleSettings?.allowGroupConversations) {
-        return;
-      }
-      if (isAndroid) {
-        ZelloAndroidSdkModule.renameGroupConversation(groupConversation.name, name);
-      } else {
-        ZelloIOSSdkModule.renameGroupConversation(groupConversation.name, name);
-      }
+  /**
+   * Renames the group conversation.
+   * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_RENAMED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
+   * @param groupConversation The group conversation to rename.
+   * @param name The new name for the group conversation.
+   */
+  renameGroupConversation(groupConversation, name) {
+    if (!this.consoleSettings?.allowGroupConversations) {
+      return;
     }
-  }, {
-    key: "setupEventListener",
-    value: function setupEventListener(eventEmitter) {
-      this.eventListener = eventEmitter.addListener('zellosdk', event => {
-        const eventName = event.eventName;
-        switch (eventName) {
-          case 'onConnectFailed':
-            {
-              this.state = ZelloConnectionState.Disconnected;
-              const error = event.error?.toLowerCase() ?? ZelloConnectionError.Unknown;
-              this.emit(ZelloEvent.CONNECT_FAILED, this.state, error);
-              break;
-            }
-          case 'onConnectStarted':
-            {
-              this.state = ZelloConnectionState.Connecting;
-              this.emit(ZelloEvent.CONNECT_STARTED, this.state);
-              break;
-            }
-          case 'onConnectSucceeded':
-            {
-              this.state = ZelloConnectionState.Connected;
-              this.emit(ZelloEvent.CONNECT_SUCCEEDED, this.state);
-              break;
+    NativeZelloSdk.renameGroupConversation(groupConversation.name, name);
+  }
+  setupEventListener() {
+    this.eventListener = DeviceEventEmitter.addListener('zellosdk', event => {
+      const eventName = event.eventName;
+      switch (eventName) {
+        case 'onConnectFailed':
+          {
+            this.state = ZelloConnectionState.Disconnected;
+            const error = event.error?.toLowerCase() ?? ZelloConnectionError.Unknown;
+            this.emit(ZelloEvent.CONNECT_FAILED, this.state, error);
+            break;
+          }
+        case 'onConnectStarted':
+          {
+            this.state = ZelloConnectionState.Connecting;
+            this.emit(ZelloEvent.CONNECT_STARTED, this.state);
+            break;
+          }
+        case 'onConnectSucceeded':
+          {
+            this.state = ZelloConnectionState.Connected;
+            this.emit(ZelloEvent.CONNECT_SUCCEEDED, this.state);
+            break;
+          }
+        case 'onDisconnected':
+          {
+            this.state = ZelloConnectionState.Disconnected;
+            this.emit(ZelloEvent.DISCONNECTED, this.state);
+            break;
+          }
+        case 'onWillReconnect':
+          {
+            this.state = ZelloConnectionState.Reconnecting;
+            this.emit(ZelloEvent.RECONNECTING, this.state);
+            break;
+          }
+        case 'onContactListUpdated':
+          {
+            this.clearContactList();
+            this.users = event.users.map(user => bridgeContactToSdkContact(user));
+            this.users.sort(compareNameAscending);
+            this.channels = event.channels.map(channel => bridgeContactToSdkContact(channel));
+            this.channels.sort(compareNameAscending);
+            this.groupConversations = event.groupConversations.map(groupConversation => bridgeContactToSdkContact(groupConversation));
+            this.groupConversations.sort(compareNameAscending);
+            if (event.emergencyChannel) {
+              this.emergencyChannel = bridgeContactToSdkContact(event.emergencyChannel);
+            }
+            this.emit(ZelloEvent.CONTACT_LIST_UPDATED, this.users, this.channels, this.groupConversations);
+            break;
+          }
+        case 'onSelectedContactChanged':
+          {
+            this.selectedContact = event.contact ? bridgeContactToSdkContact(event.contact) : undefined;
+            this.emit(ZelloEvent.SELECTED_CONTACT_CHANGED, this.selectedContact);
+            break;
+          }
+        case 'onAccountStatusChanged':
+          {
+            const statusValue = event.status?.toLowerCase();
+            if (!statusValue || Object.values(ZelloAccountStatus).includes(statusValue)) {
+              this.accountStatus = statusValue;
+              this.emit(ZelloEvent.ACCOUNT_STATUS_CHANGED, this.accountStatus);
             }
-          case 'onDisconnected':
-            {
-              this.state = ZelloConnectionState.Disconnected;
-              this.emit(ZelloEvent.DISCONNECTED, this.state);
+            break;
+          }
+        case 'onIncomingVoiceMessageStarted':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onWillReconnect':
-            {
-              this.state = ZelloConnectionState.Reconnecting;
-              this.emit(ZelloEvent.RECONNECTING, this.state);
+            this.incomingVoiceMessage = new ZelloIncomingVoiceMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), parseInt(event.timestamp, 10), event.isTranslation === true);
+            this.emit(ZelloEvent.INCOMING_VOICE_MESSAGE_STARTED, this.incomingVoiceMessage);
+            break;
+          }
+        case 'onIncomingVoiceMessageStopped':
+          {
+            this.incomingVoiceMessage = undefined;
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onContactListUpdated':
-            {
-              this.clearContactList();
-              this.users = event.users.map(user => bridgeContactToSdkContact(user));
-              this.users.sort(compareNameAscending);
-              this.channels = event.channels.map(channel => bridgeContactToSdkContact(channel));
-              this.channels.sort(compareNameAscending);
-              this.groupConversations = event.groupConversations.map(groupConversation => bridgeContactToSdkContact(groupConversation));
-              this.groupConversations.sort(compareNameAscending);
-              if (event.emergencyChannel) {
-                this.emergencyChannel = bridgeContactToSdkContact(event.emergencyChannel);
-              }
-              this.emit(ZelloEvent.CONTACT_LIST_UPDATED, this.users, this.channels, this.groupConversations);
+            this.emit(ZelloEvent.INCOMING_VOICE_MESSAGE_STOPPED, new ZelloIncomingVoiceMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), parseInt(event.timestamp, 10), event.isTranslation === true));
+            break;
+          }
+        case 'onOutgoingVoiceMessageConnecting':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onSelectedContactChanged':
-            {
-              this.selectedContact = event.contact ? bridgeContactToSdkContact(event.contact) : undefined;
-              this.emit(ZelloEvent.SELECTED_CONTACT_CHANGED, this.selectedContact);
+            this.outgoingVoiceMessage = new ZelloOutgoingVoiceMessage(contact, parseInt(event.timestamp, 10), ZelloOutgoingVoiceMessageState.Connecting);
+            this.emit(ZelloEvent.OUTGOING_VOICE_MESSAGE_CONNECTING, this.outgoingVoiceMessage);
+            break;
+          }
+        case 'onOutgoingVoiceMessageStarted':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onAccountStatusChanged':
-            {
-              const statusValue = event.status?.toLowerCase();
-              if (!statusValue || Object.values(ZelloAccountStatus).includes(statusValue)) {
-                this.accountStatus = statusValue;
-                this.emit(ZelloEvent.ACCOUNT_STATUS_CHANGED, this.accountStatus);
-              }
+            this.outgoingVoiceMessage = new ZelloOutgoingVoiceMessage(contact, parseInt(event.timestamp, 10), ZelloOutgoingVoiceMessageState.Sending);
+            this.emit(ZelloEvent.OUTGOING_VOICE_MESSAGE_STARTED, this.outgoingVoiceMessage);
+            break;
+          }
+        case 'onOutgoingVoiceMessageStopped':
+          {
+            this.outgoingVoiceMessage = undefined;
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onIncomingVoiceMessageStarted':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.incomingVoiceMessage = new ZelloIncomingVoiceMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), parseInt(event.timestamp, 10));
-              this.emit(ZelloEvent.INCOMING_VOICE_MESSAGE_STARTED, this.incomingVoiceMessage);
-              break;
+            const isError = event.error != null; // This checks for both null and undefined
+            let error;
+            if (isError) {
+              error = event.error?.toLowerCase() ?? ZelloOutgoingVoiceMessageError.Unknown;
             }
-          case 'onIncomingVoiceMessageStopped':
-            {
-              this.incomingVoiceMessage = undefined;
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.INCOMING_VOICE_MESSAGE_STOPPED, new ZelloIncomingVoiceMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), parseInt(event.timestamp, 10)));
+            this.emit(ZelloEvent.OUTGOING_VOICE_MESSAGE_STOPPED, new ZelloOutgoingVoiceMessage(contact, parseInt(event.timestamp, 10), isError ? ZelloOutgoingVoiceMessageState.Failed : ZelloOutgoingVoiceMessageState.Sent), error);
+            break;
+          }
+        case 'onIncomingImageMessage':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingVoiceMessageConnecting':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.outgoingVoiceMessage = new ZelloOutgoingVoiceMessage(contact, parseInt(event.timestamp, 10), ZelloOutgoingVoiceMessageState.Connecting);
-              this.emit(ZelloEvent.OUTGOING_VOICE_MESSAGE_CONNECTING, this.outgoingVoiceMessage);
+            this.emit(ZelloEvent.INCOMING_IMAGE_MESSAGE_RECEIVED, new ZelloImageMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), true, parseInt(event.timestamp, 10), event.thumbnail, event.image));
+            break;
+          }
+        case 'onOutgoingImageMessageSent':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingVoiceMessageStarted':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.outgoingVoiceMessage = new ZelloOutgoingVoiceMessage(contact, parseInt(event.timestamp, 10), ZelloOutgoingVoiceMessageState.Sending);
-              this.emit(ZelloEvent.OUTGOING_VOICE_MESSAGE_STARTED, this.outgoingVoiceMessage);
+            this.emit(ZelloEvent.OUTGOING_IMAGE_MESSAGE_SENT, new ZelloImageMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.thumbnail, event.image));
+            break;
+          }
+        case 'onOutgoingImageMessageSendFailed':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingVoiceMessageStopped':
-            {
-              this.outgoingVoiceMessage = undefined;
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              const isError = event.error != null; // This checks for both null and undefined
-              let error;
-              if (isError) {
-                error = event.error?.toLowerCase() ?? ZelloOutgoingVoiceMessageError.Unknown;
-              }
-              this.emit(ZelloEvent.OUTGOING_VOICE_MESSAGE_STOPPED, new ZelloOutgoingVoiceMessage(contact, parseInt(event.timestamp, 10), isError ? ZelloOutgoingVoiceMessageState.Failed : ZelloOutgoingVoiceMessageState.Sent), error);
+            this.emit(ZelloEvent.OUTGOING_IMAGE_MESSAGE_SEND_FAILED, new ZelloImageMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.thumbnail, event.image));
+            break;
+          }
+        case 'onIncomingAlertMessage':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onIncomingImageMessage':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.INCOMING_IMAGE_MESSAGE_RECEIVED, new ZelloImageMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), true, parseInt(event.timestamp, 10), event.thumbnail, event.image));
+            this.emit(ZelloEvent.INCOMING_ALERT_MESSAGE_RECEIVED, new ZelloAlertMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), true, parseInt(event.timestamp, 10), event.text));
+            break;
+          }
+        case 'onOutgoingAlertMessageSent':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingImageMessageSent':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.OUTGOING_IMAGE_MESSAGE_SENT, new ZelloImageMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.thumbnail, event.image));
+            this.emit(ZelloEvent.OUTGOING_ALERT_MESSAGE_SENT, new ZelloAlertMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.text));
+            break;
+          }
+        case 'onOutgoingAlertMessageSendFailed':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingImageMessageSendFailed':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.OUTGOING_IMAGE_MESSAGE_SEND_FAILED, new ZelloImageMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.thumbnail, event.image));
+            this.emit(ZelloEvent.OUTGOING_ALERT_MESSAGE_SEND_FAILED, new ZelloAlertMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.text));
+            break;
+          }
+        case 'onIncomingTextMessage':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onIncomingAlertMessage':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.INCOMING_ALERT_MESSAGE_RECEIVED, new ZelloAlertMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), true, parseInt(event.timestamp, 10), event.text));
+            this.emit(ZelloEvent.INCOMING_TEXT_MESSAGE_RECEIVED, new ZelloTextMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), true, parseInt(event.timestamp, 10), event.text));
+            break;
+          }
+        case 'onOutgoingTextMessageSent':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingAlertMessageSent':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.OUTGOING_ALERT_MESSAGE_SENT, new ZelloAlertMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.text));
+            this.emit(ZelloEvent.OUTGOING_TEXT_MESSAGE_SENT, new ZelloTextMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.text));
+            break;
+          }
+        case 'onOutgoingTextMessageSendFailed':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingAlertMessageSendFailed':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.OUTGOING_ALERT_MESSAGE_SEND_FAILED, new ZelloAlertMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.text));
+            this.emit(ZelloEvent.OUTGOING_TEXT_MESSAGE_SEND_FAILED, new ZelloTextMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.text));
+            break;
+          }
+        case 'onIncomingLocationMessage':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onIncomingTextMessage':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.INCOMING_TEXT_MESSAGE_RECEIVED, new ZelloTextMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), true, parseInt(event.timestamp, 10), event.text));
+            this.emit(ZelloEvent.INCOMING_LOCATION_MESSAGE_RECEIVED, new ZelloLocationMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), true, parseInt(event.timestamp, 10), event.latitude, event.longitude, event.accuracy, event.address));
+            break;
+          }
+        case 'onOutgoingLocationMessageSent':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingTextMessageSent':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.OUTGOING_TEXT_MESSAGE_SENT, new ZelloTextMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.text));
+            this.emit(ZelloEvent.OUTGOING_LOCATION_MESSAGE_SENT, new ZelloLocationMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.latitude, event.longitude, event.accuracy, event.address));
+            break;
+          }
+        case 'onOutgoingLocationMessageSendFailed':
+          {
+            const contact = bridgeContactToSdkContact(event.contact);
+            if (!contact) {
               break;
             }
-          case 'onOutgoingTextMessageSendFailed':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
+            this.emit(ZelloEvent.OUTGOING_LOCATION_MESSAGE_SEND_FAILED, new ZelloLocationMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.latitude, event.longitude, event.accuracy, event.address));
+            break;
+          }
+        case 'onIncomingEmergencyStarted':
+          {
+            this.incomingEmergencies = [];
+            event.emergencies.forEach(emergency => {
+              const incomingEmergency = bridgeIncomingEmergencyToSdkIncomingEmergency(emergency);
+              if (incomingEmergency) {
+                this.incomingEmergencies.push(incomingEmergency);
               }
-              this.emit(ZelloEvent.OUTGOING_TEXT_MESSAGE_SEND_FAILED, new ZelloTextMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.text));
-              break;
-            }
-          case 'onIncomingLocationMessage':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
+            });
+            this.incomingEmergencies.sort((a, b) => a.startTimestamp - b.startTimestamp);
+            this.emit(ZelloEvent.INCOMING_EMERGENCY_STARTED, bridgeIncomingEmergencyToSdkIncomingEmergency(event.emergency), this.incomingEmergencies);
+            break;
+          }
+        case 'onIncomingEmergencyStopped':
+          {
+            this.incomingEmergencies = [];
+            event.emergencies.forEach(emergency => {
+              const incomingEmergency = bridgeIncomingEmergencyToSdkIncomingEmergency(emergency);
+              if (incomingEmergency) {
+                this.incomingEmergencies.push(incomingEmergency);
               }
-              this.emit(ZelloEvent.INCOMING_LOCATION_MESSAGE_RECEIVED, new ZelloLocationMessage(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), true, parseInt(event.timestamp, 10), event.latitude, event.longitude, event.accuracy, event.address));
+            });
+            this.emit(ZelloEvent.INCOMING_EMERGENCY_STOPPED, bridgeIncomingEmergencyToSdkIncomingEmergency(event.emergency));
+            break;
+          }
+        case 'onOutgoingEmergencyStarted':
+          {
+            const channel = bridgeContactToSdkContact(event.channel);
+            if (!channel) {
               break;
             }
-          case 'onOutgoingLocationMessageSent':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
-              if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.OUTGOING_LOCATION_MESSAGE_SENT, new ZelloLocationMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.latitude, event.longitude, event.accuracy, event.address));
+            this.outgoingEmergency = new ZelloOutgoingEmergency(channel, parseInt(event.startTimestamp, 10), undefined);
+            this.emit(ZelloEvent.OUTGOING_EMERGENCY_STARTED, this.outgoingEmergency);
+            break;
+          }
+        case 'onOutgoingEmergencyStopped':
+          {
+            const channel = bridgeContactToSdkContact(event.channel);
+            if (!channel) {
               break;
             }
-          case 'onOutgoingLocationMessageSendFailed':
-            {
-              const contact = bridgeContactToSdkContact(event.contact);
+            this.outgoingEmergency = undefined;
+            this.emit(ZelloEvent.OUTGOING_EMERGENCY_STOPPED, new ZelloOutgoingEmergency(channel, parseInt(event.startTimestamp, 10), event.endTimestamp));
+            break;
+          }
+        case 'onRecentsUpdated':
+          {
+            this.recents = event.recents.map(recent => {
+              const contact = bridgeContactToSdkContact(recent.contact);
               if (!contact) {
-                break;
-              }
-              this.emit(ZelloEvent.OUTGOING_LOCATION_MESSAGE_SEND_FAILED, new ZelloLocationMessage(contact, undefined, false, parseInt(event.timestamp, 10), event.latitude, event.longitude, event.accuracy, event.address));
-              break;
-            }
-          case 'onIncomingEmergencyStarted':
-            {
-              this.incomingEmergencies = [];
-              event.emergencies.forEach(emergency => {
-                const incomingEmergency = bridgeIncomingEmergencyToSdkIncomingEmergency(emergency);
-                if (incomingEmergency) {
-                  this.incomingEmergencies.push(incomingEmergency);
-                }
-              });
-              this.incomingEmergencies.sort((a, b) => a.startTimestamp - b.startTimestamp);
-              this.emit(ZelloEvent.INCOMING_EMERGENCY_STARTED, bridgeIncomingEmergencyToSdkIncomingEmergency(event.emergency), this.incomingEmergencies);
-              break;
-            }
-          case 'onIncomingEmergencyStopped':
-            {
-              this.incomingEmergencies = [];
-              event.emergencies.forEach(emergency => {
-                const incomingEmergency = bridgeIncomingEmergencyToSdkIncomingEmergency(emergency);
-                if (incomingEmergency) {
-                  this.incomingEmergencies.push(incomingEmergency);
-                }
-              });
-              this.emit(ZelloEvent.INCOMING_EMERGENCY_STOPPED, bridgeIncomingEmergencyToSdkIncomingEmergency(event.emergency));
-              break;
-            }
-          case 'onOutgoingEmergencyStarted':
-            {
-              const channel = bridgeContactToSdkContact(event.channel);
-              if (!channel) {
-                break;
+                return undefined;
               }
-              this.outgoingEmergency = new ZelloOutgoingEmergency(channel, parseInt(event.startTimestamp, 10), undefined);
-              this.emit(ZelloEvent.OUTGOING_EMERGENCY_STARTED, this.outgoingEmergency);
-              break;
-            }
-          case 'onOutgoingEmergencyStopped':
-            {
-              const channel = bridgeContactToSdkContact(event.channel);
-              if (!channel) {
-                break;
-              }
-              this.outgoingEmergency = undefined;
-              this.emit(ZelloEvent.OUTGOING_EMERGENCY_STOPPED, new ZelloOutgoingEmergency(channel, parseInt(event.startTimestamp, 10), event.endTimestamp));
-              break;
-            }
-          case 'onRecentsUpdated':
-            {
-              this.recents = event.recents.map(recent => {
-                const contact = bridgeContactToSdkContact(recent.contact);
-                if (!contact) {
-                  return undefined;
-                }
-                return new ZelloRecentEntry(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), parseInt(recent.timestamp, 10), recent.type.toLowerCase(), recent.incoming);
-              }).filter(recent => recent !== undefined);
-              this.emit(ZelloEvent.RECENTS_UPDATED, this.recents);
-              break;
-            }
-          case 'onHistoryUpdated':
-            {
-              this.emit(ZelloEvent.HISTORY_UPDATED);
-              break;
-            }
-          case 'onHistoryPlaybackStarted':
-            {
-              this.historyVoiceMessage = bridgeHistoryMessageToSdkHistoryMessage(event);
-              this.emit(ZelloEvent.HISTORY_PLAYBACK_STARTED, this.historyVoiceMessage);
-              break;
-            }
-          case 'onHistoryPlaybackStopped':
-            {
-              this.historyVoiceMessage = undefined;
-              this.emit(ZelloEvent.HISTORY_PLAYBACK_STOPPED, this.historyVoiceMessage);
+              return new ZelloRecentEntry(contact, bridgeChannelUserToSdkChannelUser(event.channelUser), parseInt(recent.timestamp, 10), recent.type.toLowerCase(), recent.incoming);
+            }).filter(recent => recent !== undefined);
+            this.emit(ZelloEvent.RECENTS_UPDATED, this.recents);
+            break;
+          }
+        case 'onHistoryUpdated':
+          {
+            this.emit(ZelloEvent.HISTORY_UPDATED);
+            break;
+          }
+        case 'onHistoryPlaybackStarted':
+          {
+            this.historyVoiceMessage = bridgeHistoryMessageToSdkHistoryMessage(event);
+            this.emit(ZelloEvent.HISTORY_PLAYBACK_STARTED, this.historyVoiceMessage);
+            break;
+          }
+        case 'onHistoryPlaybackStopped':
+          {
+            this.historyVoiceMessage = undefined;
+            this.emit(ZelloEvent.HISTORY_PLAYBACK_STOPPED, this.historyVoiceMessage);
+            break;
+          }
+        case 'onHistoryVoiceMessageTranscriptionAvailable':
+          {
+            const message = bridgeHistoryMessageToSdkHistoryMessage(event);
+            if (!(message instanceof ZelloHistoryVoiceMessage)) {
               break;
             }
-          case 'onConsoleSettingsChanged':
-            {
-              this.consoleSettings = bridgeConsoleSettingsToSdkConsoleSettings(event);
-              this.emit(ZelloEvent.CONSOLE_SETTINGS_CHANGED, this.consoleSettings);
+            this.emit(ZelloEvent.HISTORY_VOICE_MESSAGE_TRANSCRIPTION_AVAILABLE, message);
+            break;
+          }
+        case 'onConsoleSettingsChanged':
+          {
+            this.consoleSettings = bridgeConsoleSettingsToSdkConsoleSettings(event);
+            this.emit(ZelloEvent.CONSOLE_SETTINGS_CHANGED, this.consoleSettings);
+            break;
+          }
+        case 'onDispatchCallTransferred':
+        case 'onDispatchCallEnded':
+        case 'onDispatchCallActive':
+        case 'onDispatchCallPending':
+          {
+            this.processDispatchCallEvent(event);
+            break;
+          }
+        case 'onGroupConversationLeft':
+          {
+            const groupConversation = bridgeContactToSdkContact(event.conversation);
+            if (!groupConversation) {
               break;
             }
-          case 'onDispatchCallTransferred':
-          case 'onDispatchCallEnded':
-          case 'onDispatchCallActive':
-          case 'onDispatchCallPending':
-            {
-              this.processDispatchCallEvent(event);
+            this.emit(ZelloEvent.GROUP_CONVERSATION_LEFT, groupConversation);
+            break;
+          }
+        case 'onGroupConversationInvite':
+          {
+            const groupConversation = bridgeContactToSdkContact(event.conversation);
+            if (!groupConversation) {
               break;
             }
-          case 'onGroupConversationLeft':
-            {
-              const groupConversation = bridgeContactToSdkContact(event.conversation);
-              if (!groupConversation) {
-                break;
-              }
-              this.emit(ZelloEvent.GROUP_CONVERSATION_LEFT, groupConversation);
+            this.emit(ZelloEvent.GROUP_CONVERSATION_INVITE, groupConversation);
+            break;
+          }
+        case 'onGroupConversationCreated':
+          {
+            const groupConversation = bridgeContactToSdkContact(event.conversation);
+            if (!groupConversation) {
               break;
             }
-          case 'onGroupConversationInvite':
-            {
-              const groupConversation = bridgeContactToSdkContact(event.conversation);
-              if (!groupConversation) {
-                break;
-              }
-              this.emit(ZelloEvent.GROUP_CONVERSATION_INVITE, groupConversation);
+            this.emit(ZelloEvent.GROUP_CONVERSATION_CREATED, groupConversation);
+            break;
+          }
+        case 'onGroupConversationRenamed':
+          {
+            const groupConversation = bridgeContactToSdkContact(event.conversation);
+            if (!groupConversation) {
               break;
             }
-          case 'onGroupConversationCreated':
-            {
-              const groupConversation = bridgeContactToSdkContact(event.conversation);
-              if (!groupConversation) {
-                break;
-              }
-              this.emit(ZelloEvent.GROUP_CONVERSATION_CREATED, groupConversation);
+            this.emit(ZelloEvent.GROUP_CONVERSATION_RENAMED, groupConversation);
+            break;
+          }
+        case 'onGroupConversationUsersAdded':
+          {
+            const groupConversation = bridgeContactToSdkContact(event.conversation);
+            if (!groupConversation) {
               break;
             }
-          case 'onGroupConversationRenamed':
-            {
-              const groupConversation = bridgeContactToSdkContact(event.conversation);
-              if (!groupConversation) {
-                break;
-              }
-              this.emit(ZelloEvent.GROUP_CONVERSATION_RENAMED, groupConversation);
-              break;
+            const users = event.users.map(user => bridgeChannelUserToSdkChannelUser(user));
+            if (!users || users.length === 0) {
+              return;
             }
-          case 'onGroupConversationUsersAdded':
-            {
-              const groupConversation = bridgeContactToSdkContact(event.conversation);
-              if (!groupConversation) {
-                break;
-              }
-              const users = event.users.map(user => bridgeChannelUserToSdkChannelUser(user));
-              if (!users || users.length === 0) {
-                return;
-              }
-              this.emit(ZelloEvent.GROUP_CONVERSATION_USERS_ADDED, groupConversation, users);
+            this.emit(ZelloEvent.GROUP_CONVERSATION_USERS_ADDED, groupConversation, users);
+            break;
+          }
+        case 'onGroupConversationUsersLeft':
+          {
+            const groupConversation = bridgeContactToSdkContact(event.conversation);
+            if (!groupConversation) {
               break;
             }
-          case 'onGroupConversationUsersLeft':
-            {
-              const groupConversation = bridgeContactToSdkContact(event.conversation);
-              if (!groupConversation) {
-                break;
-              }
-              const users = event.users.map(user => bridgeChannelUserToSdkChannelUser(user));
-              if (!users || users.length === 0) {
-                return;
-              }
-              this.emit(ZelloEvent.GROUP_CONVERSATION_USERS_LEFT, groupConversation, users);
-              break;
+            const users = event.users.map(user => bridgeChannelUserToSdkChannelUser(user));
+            if (!users || users.length === 0) {
+              return;
             }
-          default:
+            this.emit(ZelloEvent.GROUP_CONVERSATION_USERS_LEFT, groupConversation, users);
             break;
-        }
-      });
-    }
-  }, {
-    key: "processDispatchCallEvent",
-    value: function processDispatchCallEvent(event) {
-      const channel = bridgeContactToSdkContact(event.channel);
-      const call = bridgeCallToSdkCall(event.call);
-      if (!channel || !call) {
-        return;
-      }
-      switch (event.name) {
-        case 'onDispatchCallTransferred':
-          this.emit(ZelloEvent.DISPATCH_CALL_TRANSFERRED, channel, call);
-          break;
-        case 'onDispatchCallEnded':
-          this.emit(ZelloEvent.DISPATCH_CALL_ENDED, channel, call);
-          break;
-        case 'onDispatchCallActive':
-          this.emit(ZelloEvent.DISPATCH_CALL_ACTIVE, channel, call);
-          break;
-        case 'onDispatchCallPending':
-          this.emit(ZelloEvent.DISPATCH_CALL_PENDING, channel, call);
-          break;
+          }
         default:
           break;
       }
+    });
+  }
+  processDispatchCallEvent(event) {
+    const channel = bridgeContactToSdkContact(event.channel);
+    const call = bridgeCallToSdkCall(event.call);
+    if (!channel || !call) {
+      return;
+    }
+    switch (event.name) {
+      case 'onDispatchCallTransferred':
+        this.emit(ZelloEvent.DISPATCH_CALL_TRANSFERRED, channel, call);
+        break;
+      case 'onDispatchCallEnded':
+        this.emit(ZelloEvent.DISPATCH_CALL_ENDED, channel, call);
+        break;
+      case 'onDispatchCallActive':
+        this.emit(ZelloEvent.DISPATCH_CALL_ACTIVE, channel, call);
+        break;
+      case 'onDispatchCallPending':
+        this.emit(ZelloEvent.DISPATCH_CALL_PENDING, channel, call);
+        break;
+      default:
+        break;
     }
-  }, {
-    key: "clearContactList",
-    value: function clearContactList() {
-      this.users = [];
-      this.channels = [];
-      this.groupConversations = [];
-    }
-  }], [{
-    key: "getInstance",
-    value: function getInstance() {
-      if (!Zello.instance) {
-        Zello.instance = new Zello();
-      }
-      return Zello.instance;
-    }
-  }, {
-    key: "getSdk",
-    value: function getSdk() {
-      if (isAndroid) {
-        return ZelloAndroidSdkModule;
-      }
-      return ZelloIOSSdkModule;
-    }
-  }]);
-}(EventEmitter);
-_Zello = Zello;
-_defineProperty(Zello, "instance", void 0);
+  }
+  clearContactList() {
+    this.users = [];
+    this.channels = [];
+    this.groupConversations = [];
+  }
+  static getSdk() {
+    // On Android the TurboModule owns the Zello delegate and is already created
+    // by importing the spec; on iOS the ZelloIOSSdkModule RCTEventEmitter owns
+    // it and is instantiated on access. Either way this only needs to be truthy
+    // so the DeviceEventEmitter listener gets registered.
+    return isAndroid ? NativeZelloSdk : ZelloIOSSdkModule;
+  }
+}
 //# sourceMappingURL=index.js.map