@wazo/sdk 0.40.9 → 0.41.1

package/dist/wazo-sdk.js

@@ -304,560 +304,6 @@
       extendBuiltins: extendBuiltins,
   };
 
-  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-  function getDefaultExportFromCjs (x) {
-  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-  }
-
-  var events$2 = {exports: {}};
-
-  var R = typeof Reflect === 'object' ? Reflect : null;
-  var ReflectApply = R && typeof R.apply === 'function'
-    ? R.apply
-    : function ReflectApply(target, receiver, args) {
-      return Function.prototype.apply.call(target, receiver, args);
-    };
-
-  var ReflectOwnKeys;
-  if (R && typeof R.ownKeys === 'function') {
-    ReflectOwnKeys = R.ownKeys;
-  } else if (Object.getOwnPropertySymbols) {
-    ReflectOwnKeys = function ReflectOwnKeys(target) {
-      return Object.getOwnPropertyNames(target)
-        .concat(Object.getOwnPropertySymbols(target));
-    };
-  } else {
-    ReflectOwnKeys = function ReflectOwnKeys(target) {
-      return Object.getOwnPropertyNames(target);
-    };
-  }
-
-  function ProcessEmitWarning(warning) {
-    if (console && console.warn) console.warn(warning);
-  }
-
-  var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
-    return value !== value;
-  };
-
-  function EventEmitter$1() {
-    EventEmitter$1.init.call(this);
-  }
-  events$2.exports = EventEmitter$1;
-  events$2.exports.once = once;
-
-  // Backwards-compat with node 0.10.x
-  EventEmitter$1.EventEmitter = EventEmitter$1;
-
-  EventEmitter$1.prototype._events = undefined;
-  EventEmitter$1.prototype._eventsCount = 0;
-  EventEmitter$1.prototype._maxListeners = undefined;
-
-  // By default EventEmitters will print a warning if more than 10 listeners are
-  // added to it. This is a useful default which helps finding memory leaks.
-  var defaultMaxListeners = 10;
-
-  function checkListener(listener) {
-    if (typeof listener !== 'function') {
-      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
-    }
-  }
-
-  Object.defineProperty(EventEmitter$1, 'defaultMaxListeners', {
-    enumerable: true,
-    get: function() {
-      return defaultMaxListeners;
-    },
-    set: function(arg) {
-      if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
-      }
-      defaultMaxListeners = arg;
-    }
-  });
-
-  EventEmitter$1.init = function() {
-
-    if (this._events === undefined ||
-        this._events === Object.getPrototypeOf(this)._events) {
-      this._events = Object.create(null);
-      this._eventsCount = 0;
-    }
-
-    this._maxListeners = this._maxListeners || undefined;
-  };
-
-  // Obviously not all Emitters should be limited to 10. This function allows
-  // that to be increased. Set to zero for unlimited.
-  EventEmitter$1.prototype.setMaxListeners = function setMaxListeners(n) {
-    if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
-    }
-    this._maxListeners = n;
-    return this;
-  };
-
-  function _getMaxListeners(that) {
-    if (that._maxListeners === undefined)
-      return EventEmitter$1.defaultMaxListeners;
-    return that._maxListeners;
-  }
-
-  EventEmitter$1.prototype.getMaxListeners = function getMaxListeners() {
-    return _getMaxListeners(this);
-  };
-
-  EventEmitter$1.prototype.emit = function emit(type) {
-    var args = [];
-    for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-    var doError = (type === 'error');
-
-    var events = this._events;
-    if (events !== undefined)
-      doError = (doError && events.error === undefined);
-    else if (!doError)
-      return false;
-
-    // If there is no 'error' event listener then throw.
-    if (doError) {
-      var er;
-      if (args.length > 0)
-        er = args[0];
-      if (er instanceof Error) {
-        // Note: The comments on the `throw` lines are intentional, they show
-        // up in Node's output if this results in an unhandled exception.
-        throw er; // Unhandled 'error' event
-      }
-      // At least give some kind of context to the user
-      var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
-      err.context = er;
-      throw err; // Unhandled 'error' event
-    }
-
-    var handler = events[type];
-
-    if (handler === undefined)
-      return false;
-
-    if (typeof handler === 'function') {
-      ReflectApply(handler, this, args);
-    } else {
-      var len = handler.length;
-      var listeners = arrayClone(handler, len);
-      for (var i = 0; i < len; ++i)
-        ReflectApply(listeners[i], this, args);
-    }
-
-    return true;
-  };
-
-  function _addListener(target, type, listener, prepend) {
-    var m;
-    var events;
-    var existing;
-
-    checkListener(listener);
-
-    events = target._events;
-    if (events === undefined) {
-      events = target._events = Object.create(null);
-      target._eventsCount = 0;
-    } else {
-      // To avoid recursion in the case that type === "newListener"! Before
-      // adding it to the listeners, first emit "newListener".
-      if (events.newListener !== undefined) {
-        target.emit('newListener', type,
-                    listener.listener ? listener.listener : listener);
-
-        // Re-assign `events` because a newListener handler could have caused the
-        // this._events to be assigned to a new object
-        events = target._events;
-      }
-      existing = events[type];
-    }
-
-    if (existing === undefined) {
-      // Optimize the case of one listener. Don't need the extra array object.
-      existing = events[type] = listener;
-      ++target._eventsCount;
-    } else {
-      if (typeof existing === 'function') {
-        // Adding the second element, need to change to array.
-        existing = events[type] =
-          prepend ? [listener, existing] : [existing, listener];
-        // If we've already got an array, just append.
-      } else if (prepend) {
-        existing.unshift(listener);
-      } else {
-        existing.push(listener);
-      }
-
-      // Check for listener leak
-      m = _getMaxListeners(target);
-      if (m > 0 && existing.length > m && !existing.warned) {
-        existing.warned = true;
-        // No error code for this since it is a Warning
-        // eslint-disable-next-line no-restricted-syntax
-        var w = new Error('Possible EventEmitter memory leak detected. ' +
-                            existing.length + ' ' + String(type) + ' listeners ' +
-                            'added. Use emitter.setMaxListeners() to ' +
-                            'increase limit');
-        w.name = 'MaxListenersExceededWarning';
-        w.emitter = target;
-        w.type = type;
-        w.count = existing.length;
-        ProcessEmitWarning(w);
-      }
-    }
-
-    return target;
-  }
-
-  EventEmitter$1.prototype.addListener = function addListener(type, listener) {
-    return _addListener(this, type, listener, false);
-  };
-
-  EventEmitter$1.prototype.on = EventEmitter$1.prototype.addListener;
-
-  EventEmitter$1.prototype.prependListener =
-      function prependListener(type, listener) {
-        return _addListener(this, type, listener, true);
-      };
-
-  function onceWrapper() {
-    if (!this.fired) {
-      this.target.removeListener(this.type, this.wrapFn);
-      this.fired = true;
-      if (arguments.length === 0)
-        return this.listener.call(this.target);
-      return this.listener.apply(this.target, arguments);
-    }
-  }
-
-  function _onceWrap(target, type, listener) {
-    var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
-    var wrapped = onceWrapper.bind(state);
-    wrapped.listener = listener;
-    state.wrapFn = wrapped;
-    return wrapped;
-  }
-
-  EventEmitter$1.prototype.once = function once(type, listener) {
-    checkListener(listener);
-    this.on(type, _onceWrap(this, type, listener));
-    return this;
-  };
-
-  EventEmitter$1.prototype.prependOnceListener =
-      function prependOnceListener(type, listener) {
-        checkListener(listener);
-        this.prependListener(type, _onceWrap(this, type, listener));
-        return this;
-      };
-
-  // Emits a 'removeListener' event if and only if the listener was removed.
-  EventEmitter$1.prototype.removeListener =
-      function removeListener(type, listener) {
-        var list, events, position, i, originalListener;
-
-        checkListener(listener);
-
-        events = this._events;
-        if (events === undefined)
-          return this;
-
-        list = events[type];
-        if (list === undefined)
-          return this;
-
-        if (list === listener || list.listener === listener) {
-          if (--this._eventsCount === 0)
-            this._events = Object.create(null);
-          else {
-            delete events[type];
-            if (events.removeListener)
-              this.emit('removeListener', type, list.listener || listener);
-          }
-        } else if (typeof list !== 'function') {
-          position = -1;
-
-          for (i = list.length - 1; i >= 0; i--) {
-            if (list[i] === listener || list[i].listener === listener) {
-              originalListener = list[i].listener;
-              position = i;
-              break;
-            }
-          }
-
-          if (position < 0)
-            return this;
-
-          if (position === 0)
-            list.shift();
-          else {
-            spliceOne(list, position);
-          }
-
-          if (list.length === 1)
-            events[type] = list[0];
-
-          if (events.removeListener !== undefined)
-            this.emit('removeListener', type, originalListener || listener);
-        }
-
-        return this;
-      };
-
-  EventEmitter$1.prototype.off = EventEmitter$1.prototype.removeListener;
-
-  EventEmitter$1.prototype.removeAllListeners =
-      function removeAllListeners(type) {
-        var listeners, events, i;
-
-        events = this._events;
-        if (events === undefined)
-          return this;
-
-        // not listening for removeListener, no need to emit
-        if (events.removeListener === undefined) {
-          if (arguments.length === 0) {
-            this._events = Object.create(null);
-            this._eventsCount = 0;
-          } else if (events[type] !== undefined) {
-            if (--this._eventsCount === 0)
-              this._events = Object.create(null);
-            else
-              delete events[type];
-          }
-          return this;
-        }
-
-        // emit removeListener for all listeners on all events
-        if (arguments.length === 0) {
-          var keys = Object.keys(events);
-          var key;
-          for (i = 0; i < keys.length; ++i) {
-            key = keys[i];
-            if (key === 'removeListener') continue;
-            this.removeAllListeners(key);
-          }
-          this.removeAllListeners('removeListener');
-          this._events = Object.create(null);
-          this._eventsCount = 0;
-          return this;
-        }
-
-        listeners = events[type];
-
-        if (typeof listeners === 'function') {
-          this.removeListener(type, listeners);
-        } else if (listeners !== undefined) {
-          // LIFO order
-          for (i = listeners.length - 1; i >= 0; i--) {
-            this.removeListener(type, listeners[i]);
-          }
-        }
-
-        return this;
-      };
-
-  function _listeners(target, type, unwrap) {
-    var events = target._events;
-
-    if (events === undefined)
-      return [];
-
-    var evlistener = events[type];
-    if (evlistener === undefined)
-      return [];
-
-    if (typeof evlistener === 'function')
-      return unwrap ? [evlistener.listener || evlistener] : [evlistener];
-
-    return unwrap ?
-      unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-  }
-
-  EventEmitter$1.prototype.listeners = function listeners(type) {
-    return _listeners(this, type, true);
-  };
-
-  EventEmitter$1.prototype.rawListeners = function rawListeners(type) {
-    return _listeners(this, type, false);
-  };
-
-  EventEmitter$1.listenerCount = function(emitter, type) {
-    if (typeof emitter.listenerCount === 'function') {
-      return emitter.listenerCount(type);
-    } else {
-      return listenerCount.call(emitter, type);
-    }
-  };
-
-  EventEmitter$1.prototype.listenerCount = listenerCount;
-  function listenerCount(type) {
-    var events = this._events;
-
-    if (events !== undefined) {
-      var evlistener = events[type];
-
-      if (typeof evlistener === 'function') {
-        return 1;
-      } else if (evlistener !== undefined) {
-        return evlistener.length;
-      }
-    }
-
-    return 0;
-  }
-
-  EventEmitter$1.prototype.eventNames = function eventNames() {
-    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
-  };
-
-  function arrayClone(arr, n) {
-    var copy = new Array(n);
-    for (var i = 0; i < n; ++i)
-      copy[i] = arr[i];
-    return copy;
-  }
-
-  function spliceOne(list, index) {
-    for (; index + 1 < list.length; index++)
-      list[index] = list[index + 1];
-    list.pop();
-  }
-
-  function unwrapListeners(arr) {
-    var ret = new Array(arr.length);
-    for (var i = 0; i < ret.length; ++i) {
-      ret[i] = arr[i].listener || arr[i];
-    }
-    return ret;
-  }
-
-  function once(emitter, name) {
-    return new Promise(function (resolve, reject) {
-      function errorListener(err) {
-        emitter.removeListener(name, resolver);
-        reject(err);
-      }
-
-      function resolver() {
-        if (typeof emitter.removeListener === 'function') {
-          emitter.removeListener('error', errorListener);
-        }
-        resolve([].slice.call(arguments));
-      }
-      eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-      if (name !== 'error') {
-        addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
-      }
-    });
-  }
-
-  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-    if (typeof emitter.on === 'function') {
-      eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
-    }
-  }
-
-  function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-    if (typeof emitter.on === 'function') {
-      if (flags.once) {
-        emitter.once(name, listener);
-      } else {
-        emitter.on(name, listener);
-      }
-    } else if (typeof emitter.addEventListener === 'function') {
-      // EventTarget does not have `error` event semantics like Node
-      // EventEmitters, we do not listen for `error` events here.
-      emitter.addEventListener(name, function wrapListener(arg) {
-        // IE does not have builtin `{ once: true }` support so we
-        // have to do it manually.
-        if (flags.once) {
-          emitter.removeEventListener(name, wrapListener);
-        }
-        listener(arg);
-      });
-    } else {
-      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
-    }
-  }
-
-  var eventsExports = events$2.exports;
-  var EventEmitter$2 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
-
-  const { EventEmitter } = eventsExports;
-
-  class AbortSignal {
-    constructor() {
-      this.eventEmitter = new EventEmitter();
-      this.onabort = null;
-      this.aborted = false;
-      this.reason = undefined;
-    }
-    toString() {
-      return "[object AbortSignal]";
-    }
-    get [Symbol.toStringTag]() {
-      return "AbortSignal";
-    }
-    removeEventListener(name, handler) {
-      this.eventEmitter.removeListener(name, handler);
-    }
-    addEventListener(name, handler) {
-      this.eventEmitter.on(name, handler);
-    }
-    dispatchEvent(type) {
-      const event = { type, target: this };
-      const handlerName = `on${type}`;
-
-      if (typeof this[handlerName] === "function") this[handlerName](event);
-
-      this.eventEmitter.emit(type, event);
-    }
-    throwIfAborted() {
-      if (this.aborted) {
-        throw this.reason;
-      }
-    }
-    static abort(reason) {
-      const controller = new AbortController$1();
-      controller.abort();
-      return controller.signal;
-    }
-    static timeout(time) {
-      const controller = new AbortController$1();
-      setTimeout(() => controller.abort(new Error("TimeoutError")), time);
-      return controller.signal;
-    }
-  }
-  let AbortController$1 = class AbortController {
-    constructor() {
-      this.signal = new AbortSignal();
-    }
-    abort(reason) {
-      if (this.signal.aborted) return;
-
-      this.signal.aborted = true;
-
-      if (reason) this.signal.reason = reason;
-      else this.signal.reason = new Error("AbortError");
-
-      this.signal.dispatchEvent("abort");
-    }
-    toString() {
-      return "[object AbortController]";
-    }
-    get [Symbol.toStringTag]() {
-      return "AbortController";
-    }
-  };
-
-  var nodeAbortController = { AbortController: AbortController$1, AbortSignal };
-
   class BadResponse extends Error {
       static fromResponse(error, status) {
           return new BadResponse(error.message || JSON.stringify(error), status, error.timestamp, error.error_id, error.details, error);
@@ -889,8 +335,11 @@
       }
   }
 
-  /* global navigator */
-  const isMobile = () => typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+  var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+  function getDefaultExportFromCjs (x) {
+  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+  }
 
   function commonjsRequire(path) {
   	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
@@ -6580,6 +6029,9 @@
   var momentExports = moment$1.exports;
   var moment = /*@__PURE__*/getDefaultExportFromCjs(momentExports);
 
+  /* global navigator */
+  const isMobile = () => typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
+
   const camelToUnderscore = (key) => {
       if (typeof key !== 'string') {
           throw new Error('Input is not a string');
@@ -6879,7 +6331,7 @@
           const isSecure = +port === 443;
           const url = `http${isSecure ? 's' : ''}://${host}${isSecure ? '' : `:${port}`}/${tag}`;
           const body = Array.isArray(payload) ? `[${payload.map(this._boundParseLoggerBody).join(',')}]` : this._parseLoggerBody(payload);
-          realFetch()(url, {
+          fetch(url, {
               method: 'POST',
               headers: {
                   Accept: 'application/json',
@@ -6922,36 +6374,9 @@
   }
   var IssueReporter$1 = new IssueReporter();
 
-  /* global window */
-  /* eslint-disable global-require */
-  /* eslint-disable import/no-dynamic-require */
   const methods = ['head', 'get', 'post', 'put', 'delete', 'options'];
   const logger$c = IssueReporter$1 ? IssueReporter$1.loggerFor('api') : console;
   const REQUEST_TIMEOUT_MS = 300 * 1000; // 300s like the Chrome engine default value.
-  // Use a function here to be able to mock it in tests
-  const realFetch = () => {
-      if (typeof fetch !== 'undefined') {
-          return fetch;
-      }
-      if (typeof document !== 'undefined' && window.fetch) {
-          // Browser
-          return window.fetch;
-      }
-      if (isMobile()) {
-          // React native
-          return fetch;
-      }
-      // nodejs
-      // this package is disabled for react-native in package.json because it requires nodejs modules
-      // Used to trick the optimizer to avoid requiring `node-fetch/lib/index` directly
-      // It causes to require it on browsers when delivered by a nodejs engine (cf: vitejs).
-      try {
-          return require(Math.random() >= 0 ? 'node-fetch/lib/index' : '');
-      }
-      catch (e) {
-          return fetch;
-      }
-  };
   class ApiRequester {
       server;
       agent;
@@ -7033,7 +6458,7 @@
           const hasEmptyResponse = method === 'delete' || isHead;
           const newParse = hasEmptyResponse && parse === ApiRequester.defaultParser ? ApiRequester.successResponseParser : parse;
           const fetchOptions = { ...(this.fetchOptions || {}) };
-          const controller = typeof AbortController !== 'undefined' ? new AbortController() : new nodeAbortController.AbortController();
+          const controller = new AbortController();
           const extraHeaders = fetchOptions.headers || {};
           delete fetchOptions.headers;
           const options = {
@@ -7054,7 +6479,7 @@
               await this.refreshTokenPromise;
           }
           const start = new Date();
-          const requestPromise = realFetch()(url, options).then((response) => {
+          const requestPromise = fetch(url, options).then((response) => {
               const contentType = response.headers.get('content-type') || '';
               const isJson = contentType.indexOf('application/json') !== -1;
               IssueReporter$1.logRequest(url, options, response, start);
@@ -9334,10 +8759,489 @@ BwIDAQAB
       }
   }
 
+  var events$2 = {exports: {}};
+
+  var R = typeof Reflect === 'object' ? Reflect : null;
+  var ReflectApply = R && typeof R.apply === 'function'
+    ? R.apply
+    : function ReflectApply(target, receiver, args) {
+      return Function.prototype.apply.call(target, receiver, args);
+    };
+
+  var ReflectOwnKeys;
+  if (R && typeof R.ownKeys === 'function') {
+    ReflectOwnKeys = R.ownKeys;
+  } else if (Object.getOwnPropertySymbols) {
+    ReflectOwnKeys = function ReflectOwnKeys(target) {
+      return Object.getOwnPropertyNames(target)
+        .concat(Object.getOwnPropertySymbols(target));
+    };
+  } else {
+    ReflectOwnKeys = function ReflectOwnKeys(target) {
+      return Object.getOwnPropertyNames(target);
+    };
+  }
+
+  function ProcessEmitWarning(warning) {
+    if (console && console.warn) console.warn(warning);
+  }
+
+  var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+    return value !== value;
+  };
+
+  function EventEmitter() {
+    EventEmitter.init.call(this);
+  }
+  events$2.exports = EventEmitter;
+  events$2.exports.once = once;
+
+  // Backwards-compat with node 0.10.x
+  EventEmitter.EventEmitter = EventEmitter;
+
+  EventEmitter.prototype._events = undefined;
+  EventEmitter.prototype._eventsCount = 0;
+  EventEmitter.prototype._maxListeners = undefined;
+
+  // By default EventEmitters will print a warning if more than 10 listeners are
+  // added to it. This is a useful default which helps finding memory leaks.
+  var defaultMaxListeners = 10;
+
+  function checkListener(listener) {
+    if (typeof listener !== 'function') {
+      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+    }
+  }
+
+  Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+    enumerable: true,
+    get: function() {
+      return defaultMaxListeners;
+    },
+    set: function(arg) {
+      if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+      }
+      defaultMaxListeners = arg;
+    }
+  });
+
+  EventEmitter.init = function() {
+
+    if (this._events === undefined ||
+        this._events === Object.getPrototypeOf(this)._events) {
+      this._events = Object.create(null);
+      this._eventsCount = 0;
+    }
+
+    this._maxListeners = this._maxListeners || undefined;
+  };
+
+  // Obviously not all Emitters should be limited to 10. This function allows
+  // that to be increased. Set to zero for unlimited.
+  EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+    if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+    }
+    this._maxListeners = n;
+    return this;
+  };
+
+  function _getMaxListeners(that) {
+    if (that._maxListeners === undefined)
+      return EventEmitter.defaultMaxListeners;
+    return that._maxListeners;
+  }
+
+  EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+    return _getMaxListeners(this);
+  };
+
+  EventEmitter.prototype.emit = function emit(type) {
+    var args = [];
+    for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+    var doError = (type === 'error');
+
+    var events = this._events;
+    if (events !== undefined)
+      doError = (doError && events.error === undefined);
+    else if (!doError)
+      return false;
+
+    // If there is no 'error' event listener then throw.
+    if (doError) {
+      var er;
+      if (args.length > 0)
+        er = args[0];
+      if (er instanceof Error) {
+        // Note: The comments on the `throw` lines are intentional, they show
+        // up in Node's output if this results in an unhandled exception.
+        throw er; // Unhandled 'error' event
+      }
+      // At least give some kind of context to the user
+      var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+      err.context = er;
+      throw err; // Unhandled 'error' event
+    }
+
+    var handler = events[type];
+
+    if (handler === undefined)
+      return false;
+
+    if (typeof handler === 'function') {
+      ReflectApply(handler, this, args);
+    } else {
+      var len = handler.length;
+      var listeners = arrayClone(handler, len);
+      for (var i = 0; i < len; ++i)
+        ReflectApply(listeners[i], this, args);
+    }
+
+    return true;
+  };
+
+  function _addListener(target, type, listener, prepend) {
+    var m;
+    var events;
+    var existing;
+
+    checkListener(listener);
+
+    events = target._events;
+    if (events === undefined) {
+      events = target._events = Object.create(null);
+      target._eventsCount = 0;
+    } else {
+      // To avoid recursion in the case that type === "newListener"! Before
+      // adding it to the listeners, first emit "newListener".
+      if (events.newListener !== undefined) {
+        target.emit('newListener', type,
+                    listener.listener ? listener.listener : listener);
+
+        // Re-assign `events` because a newListener handler could have caused the
+        // this._events to be assigned to a new object
+        events = target._events;
+      }
+      existing = events[type];
+    }
+
+    if (existing === undefined) {
+      // Optimize the case of one listener. Don't need the extra array object.
+      existing = events[type] = listener;
+      ++target._eventsCount;
+    } else {
+      if (typeof existing === 'function') {
+        // Adding the second element, need to change to array.
+        existing = events[type] =
+          prepend ? [listener, existing] : [existing, listener];
+        // If we've already got an array, just append.
+      } else if (prepend) {
+        existing.unshift(listener);
+      } else {
+        existing.push(listener);
+      }
+
+      // Check for listener leak
+      m = _getMaxListeners(target);
+      if (m > 0 && existing.length > m && !existing.warned) {
+        existing.warned = true;
+        // No error code for this since it is a Warning
+        // eslint-disable-next-line no-restricted-syntax
+        var w = new Error('Possible EventEmitter memory leak detected. ' +
+                            existing.length + ' ' + String(type) + ' listeners ' +
+                            'added. Use emitter.setMaxListeners() to ' +
+                            'increase limit');
+        w.name = 'MaxListenersExceededWarning';
+        w.emitter = target;
+        w.type = type;
+        w.count = existing.length;
+        ProcessEmitWarning(w);
+      }
+    }
+
+    return target;
+  }
+
+  EventEmitter.prototype.addListener = function addListener(type, listener) {
+    return _addListener(this, type, listener, false);
+  };
+
+  EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+  EventEmitter.prototype.prependListener =
+      function prependListener(type, listener) {
+        return _addListener(this, type, listener, true);
+      };
+
+  function onceWrapper() {
+    if (!this.fired) {
+      this.target.removeListener(this.type, this.wrapFn);
+      this.fired = true;
+      if (arguments.length === 0)
+        return this.listener.call(this.target);
+      return this.listener.apply(this.target, arguments);
+    }
+  }
+
+  function _onceWrap(target, type, listener) {
+    var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+    var wrapped = onceWrapper.bind(state);
+    wrapped.listener = listener;
+    state.wrapFn = wrapped;
+    return wrapped;
+  }
+
+  EventEmitter.prototype.once = function once(type, listener) {
+    checkListener(listener);
+    this.on(type, _onceWrap(this, type, listener));
+    return this;
+  };
+
+  EventEmitter.prototype.prependOnceListener =
+      function prependOnceListener(type, listener) {
+        checkListener(listener);
+        this.prependListener(type, _onceWrap(this, type, listener));
+        return this;
+      };
+
+  // Emits a 'removeListener' event if and only if the listener was removed.
+  EventEmitter.prototype.removeListener =
+      function removeListener(type, listener) {
+        var list, events, position, i, originalListener;
+
+        checkListener(listener);
+
+        events = this._events;
+        if (events === undefined)
+          return this;
+
+        list = events[type];
+        if (list === undefined)
+          return this;
+
+        if (list === listener || list.listener === listener) {
+          if (--this._eventsCount === 0)
+            this._events = Object.create(null);
+          else {
+            delete events[type];
+            if (events.removeListener)
+              this.emit('removeListener', type, list.listener || listener);
+          }
+        } else if (typeof list !== 'function') {
+          position = -1;
+
+          for (i = list.length - 1; i >= 0; i--) {
+            if (list[i] === listener || list[i].listener === listener) {
+              originalListener = list[i].listener;
+              position = i;
+              break;
+            }
+          }
+
+          if (position < 0)
+            return this;
+
+          if (position === 0)
+            list.shift();
+          else {
+            spliceOne(list, position);
+          }
+
+          if (list.length === 1)
+            events[type] = list[0];
+
+          if (events.removeListener !== undefined)
+            this.emit('removeListener', type, originalListener || listener);
+        }
+
+        return this;
+      };
+
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+  EventEmitter.prototype.removeAllListeners =
+      function removeAllListeners(type) {
+        var listeners, events, i;
+
+        events = this._events;
+        if (events === undefined)
+          return this;
+
+        // not listening for removeListener, no need to emit
+        if (events.removeListener === undefined) {
+          if (arguments.length === 0) {
+            this._events = Object.create(null);
+            this._eventsCount = 0;
+          } else if (events[type] !== undefined) {
+            if (--this._eventsCount === 0)
+              this._events = Object.create(null);
+            else
+              delete events[type];
+          }
+          return this;
+        }
+
+        // emit removeListener for all listeners on all events
+        if (arguments.length === 0) {
+          var keys = Object.keys(events);
+          var key;
+          for (i = 0; i < keys.length; ++i) {
+            key = keys[i];
+            if (key === 'removeListener') continue;
+            this.removeAllListeners(key);
+          }
+          this.removeAllListeners('removeListener');
+          this._events = Object.create(null);
+          this._eventsCount = 0;
+          return this;
+        }
+
+        listeners = events[type];
+
+        if (typeof listeners === 'function') {
+          this.removeListener(type, listeners);
+        } else if (listeners !== undefined) {
+          // LIFO order
+          for (i = listeners.length - 1; i >= 0; i--) {
+            this.removeListener(type, listeners[i]);
+          }
+        }
+
+        return this;
+      };
+
+  function _listeners(target, type, unwrap) {
+    var events = target._events;
+
+    if (events === undefined)
+      return [];
+
+    var evlistener = events[type];
+    if (evlistener === undefined)
+      return [];
+
+    if (typeof evlistener === 'function')
+      return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+    return unwrap ?
+      unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+  }
+
+  EventEmitter.prototype.listeners = function listeners(type) {
+    return _listeners(this, type, true);
+  };
+
+  EventEmitter.prototype.rawListeners = function rawListeners(type) {
+    return _listeners(this, type, false);
+  };
+
+  EventEmitter.listenerCount = function(emitter, type) {
+    if (typeof emitter.listenerCount === 'function') {
+      return emitter.listenerCount(type);
+    } else {
+      return listenerCount.call(emitter, type);
+    }
+  };
+
+  EventEmitter.prototype.listenerCount = listenerCount;
+  function listenerCount(type) {
+    var events = this._events;
+
+    if (events !== undefined) {
+      var evlistener = events[type];
+
+      if (typeof evlistener === 'function') {
+        return 1;
+      } else if (evlistener !== undefined) {
+        return evlistener.length;
+      }
+    }
+
+    return 0;
+  }
+
+  EventEmitter.prototype.eventNames = function eventNames() {
+    return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+  };
+
+  function arrayClone(arr, n) {
+    var copy = new Array(n);
+    for (var i = 0; i < n; ++i)
+      copy[i] = arr[i];
+    return copy;
+  }
+
+  function spliceOne(list, index) {
+    for (; index + 1 < list.length; index++)
+      list[index] = list[index + 1];
+    list.pop();
+  }
+
+  function unwrapListeners(arr) {
+    var ret = new Array(arr.length);
+    for (var i = 0; i < ret.length; ++i) {
+      ret[i] = arr[i].listener || arr[i];
+    }
+    return ret;
+  }
+
+  function once(emitter, name) {
+    return new Promise(function (resolve, reject) {
+      function errorListener(err) {
+        emitter.removeListener(name, resolver);
+        reject(err);
+      }
+
+      function resolver() {
+        if (typeof emitter.removeListener === 'function') {
+          emitter.removeListener('error', errorListener);
+        }
+        resolve([].slice.call(arguments));
+      }
+      eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+      if (name !== 'error') {
+        addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+      }
+    });
+  }
+
+  function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+    if (typeof emitter.on === 'function') {
+      eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+    }
+  }
+
+  function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+    if (typeof emitter.on === 'function') {
+      if (flags.once) {
+        emitter.once(name, listener);
+      } else {
+        emitter.on(name, listener);
+      }
+    } else if (typeof emitter.addEventListener === 'function') {
+      // EventTarget does not have `error` event semantics like Node
+      // EventEmitters, we do not listen for `error` events here.
+      emitter.addEventListener(name, function wrapListener(arg) {
+        // IE does not have builtin `{ once: true }` support so we
+        // have to do it manually.
+        if (flags.once) {
+          emitter.removeEventListener(name, wrapListener);
+        }
+        listener(arg);
+      });
+    } else {
+      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+    }
+  }
+
+  var eventsExports = events$2.exports;
+  var EventEmitter$1 = /*@__PURE__*/getDefaultExportFromCjs(eventsExports);
+
   class Emitter {
       eventEmitter;
       constructor() {
-          this.eventEmitter = new EventEmitter$2();
+          this.eventEmitter = new EventEmitter$1();
       }
       on(event, callback) {
           this.eventEmitter.on(event, callback);
@@ -10920,6 +10824,7 @@ BwIDAQAB
       BACKEND_WAZO;
       BACKEND_LDAP;
       usingEdgeServer;
+      onSetUsingEdgeServer;
       constructor() {
           this.expiration = DETAULT_EXPIRATION;
           this.authenticated = false;
@@ -11008,10 +10913,14 @@ BwIDAQAB
           const rawSession = await getApiClient().auth.refreshToken(refreshToken, '', this.expiration, this.mobile);
           return this._onAuthenticated(rawSession);
       }
-      async validateToken(token, refreshToken) {
+      async validateToken(token, refreshToken, headerUserUuid) {
           if (!token) {
               return;
           }
+          if (this.usingEdgeServer && typeof headerUserUuid === 'string') {
+              logger$9.info('using edge server, setting user UUID header', { headerUserUuid });
+              this.setHttpUserUuidHeader(headerUserUuid);
+          }
           if (refreshToken) {
               setRefreshToken(refreshToken);
           }
@@ -11056,6 +10965,10 @@ BwIDAQAB
       setOnHostFromHeaders(callback) {
           this.onHostFromHeadersCallback = callback;
       }
+      setOnSetUsingEdgeServer(callback) {
+          logger$9.info('setting onSetUsingEdgeServer callback', { callback: typeof callback === 'function' });
+          this.onSetUsingEdgeServer = callback;
+      }
       setOnRefreshToken(callback) {
           this.onRefreshTokenCallback = callback;
       }
@@ -11171,6 +11084,10 @@ BwIDAQAB
               this.usingEdgeServer = false;
               logger$9.info('Setting usingEdgeServer to FALSE', { justification: e });
           }
+          if (typeof this.onSetUsingEdgeServer === 'function') {
+              logger$9.info('calling onSetUsingEdgeServer', { usingEdgeServer: this.usingEdgeServer });
+              this.onSetUsingEdgeServer(this.usingEdgeServer);
+          }
       }
       async _onAuthenticated(rawSession) {
           if (this.authenticated && this.session) {
@@ -11226,6 +11143,7 @@ BwIDAQAB
   if (!global.wazoAuthInstance) {
       global.wazoAuthInstance = new Auth();
   }
+  // @ts-ignore: Circular definition of import alias 'default'.
   var Auth$1 = global.wazoAuthInstance;
 
   class AdHocAPIConference {
@@ -28592,13 +28510,14 @@ BwIDAQAB
       }
       // Should be async to match CTIPhone definition
       // @TODO: line is not used here
-      async makeCall(number, line, cameraEnabled, audioOnly = false, conference = false) {
+      async makeCall(number, line, cameraEnabled, audioOnly = false, conference = false, options = {}) {
           logger$8.info('make WebRTC call', {
               number,
               lineId: line ? line.id : null,
               cameraEnabled,
               audioOnly,
               conference,
+              options,
           });
           if (!number) {
               return Promise.resolve(null);
@@ -28613,7 +28532,7 @@ BwIDAQAB
           }
           let sipSession;
           try {
-              sipSession = this.client.call(number, this.allowVideo ? cameraEnabled : false, audioOnly, conference);
+              sipSession = this.client.call(number, this.allowVideo ? cameraEnabled : false, audioOnly, conference, options);
               this._bindEvents(sipSession);
           }
           catch (error) {
@@ -28848,6 +28767,9 @@ BwIDAQAB
               this.incomingSessions.push(callSession.getId());
               this._bindEvents(sipSession);
               this.client.storeSipSession(sipSession);
+              callSession.creationTime = new Date();
+              this._updateCallSession(callSession);
+              this.eventEmitter.emit(ON_CALL_INCOMING, callSession, wantsToDoVideo);
               if (!this.currentSipSession) {
                   if (this.ringingEnabled) {
                       this.eventEmitter.emit(ON_PLAY_RING_SOUND, this.audioRingDeviceId, this.audioRingVolume, callSession);
@@ -28856,9 +28778,6 @@ BwIDAQAB
               else {
                   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$8.info('WebRTC on reinvite', {
@@ -34447,7 +34366,7 @@ BwIDAQAB
       // eslint-disable-next-line @typescript-eslint/default-param-last
       constructor(logger, mediaStreamFactory, sessionDescriptionHandlerConfiguration, isWeb, session) {
           super(logger, mediaStreamFactory, sessionDescriptionHandlerConfiguration);
-          this.eventEmitter = new EventEmitter$2();
+          this.eventEmitter = new EventEmitter$1();
           this.isWeb = isWeb;
           this.session = session;
       }
@@ -35336,13 +35255,14 @@ BwIDAQAB
               });
           });
       }
-      call(number, enableVideo, audioOnly = false, conference = false) {
+      call(number, enableVideo, audioOnly = false, conference = false, options = {}) {
           logger$7.info('sdk webrtc creating call', {
               clientId: this.clientId,
               number,
               enableVideo,
               audioOnly,
               conference,
+              options,
           });
           const inviterOptions = {
               sessionDescriptionHandlerOptionsReInvite: {
@@ -35350,6 +35270,7 @@ BwIDAQAB
                   audioOnly,
               },
               earlyMedia: true,
+              options,
           };
           if (audioOnly) {
               inviterOptions.sessionDescriptionHandlerModifiersReInvite = [stripVideo];
@@ -37495,6 +37416,7 @@ BwIDAQAB
   if (!global.wazoTelephonyInstance) {
       global.wazoTelephonyInstance = new Phone();
   }
+  // @ts-ignore: Circular definition of import alias 'default'.
   var Phone$1 = global.wazoTelephonyInstance;
 
   /*! *****************************************************************************
@@ -38609,6 +38531,7 @@ BwIDAQAB
   if (!global.wazoWebsocketInstance) {
       global.wazoWebsocketInstance = new Websocket();
   }
+  // @ts-ignore: Circular definition of import alias 'default'.
   var Websocket$1 = global.wazoWebsocketInstance;
 
   const logger$3 = IssueReporter$1.loggerFor('room');
@@ -39047,6 +38970,7 @@ BwIDAQAB
           });
           if (!room) {
               await Wazo$1.Phone.connect({
+                  // @ts-ignore: Property 'audio' is missing
                   media: constraints,
               });
               const withCamera = constraints && !!constraints.video;
@@ -39108,7 +39032,7 @@ BwIDAQAB
       async disconnect() {
           logger$2.info('disconnection to room called');
           await Wazo$1.Phone.hangup(this.callSession);
-          this.callSession = null;
+          this.callSession = undefined;
           this.eventEmitter.emit(this.ON_DISCONNECTED, this);
           this.connected = false;
           this.unbind();
@@ -39805,17 +39729,19 @@ BwIDAQAB
   if (!global.wazoDirectoryInstance) {
       global.wazoDirectoryInstance = new Directory();
   }
+  // @ts-ignore: Circular definition of import alias 'default'.
   var Directory$1 = global.wazoDirectoryInstance;
 
   class Configuration {
       async getCurrentUser() {
-          const session = Auth$1.getSession();
-          return getApiClient().confd.getUser(session ? session.uuid : '');
+          const session = Wazo$1.Auth.getSession();
+          return getApiClient().confd.getUser(`${session ? session.uuid : ''}`);
       }
   }
   if (!global.wazoConfigurationInstance) {
       global.wazoConfigurationInstance = new Configuration();
   }
+  // @ts-ignore: Circular definition of import alias 'default'.
   var Configuration$1 = global.wazoConfigurationInstance;
 
   /* global navigator */
@@ -40525,6 +40451,7 @@ BwIDAQAB
       }
   }
 
+  /* eslint-disable import/no-named-as-default */
   /* global window */
   const Wazo = {
       Auth: Auth$1,
@@ -41962,6 +41889,7 @@ BwIDAQAB
   exports.SOCKET_EVENTS = SOCKET_EVENTS$1;
   exports.ServerError = ServerError;
   exports.Session = Session$1;
+  exports.SessionDescriptionHandler = WazoSessionDescriptionHandler;
   exports.SipLine = SipLine;
   exports.SwitchboardCall = SwitchboardCall;
   exports.Voicemail = Voicemail;