oro-sdk-apis 1.0.0

package/dist/oro-sdk-apis.cjs.development.js

@@ -0,0 +1,3019 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var createAuthRefreshInterceptor = _interopDefault(require('axios-auth-refresh'));
+var axios = _interopDefault(require('axios'));
+var _ = require('buffer/');
+var hash_js = require('hash.js');
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+
+  _setPrototypeOf(subClass, superClass);
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+
+  return _construct.apply(null, arguments);
+}
+
+function _isNativeFunction(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+
+      _cache.set(Class, Wrapper);
+    }
+
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+
+  return _wrapNativeSuper(Class);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function createCommonjsModule(fn, module) {
+	return module = { exports: {} }, fn(module, module.exports), module.exports;
+}
+
+var runtime_1 = createCommonjsModule(function (module) {
+/**
+ * Copyright (c) 2014-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var runtime = (function (exports) {
+
+  var Op = Object.prototype;
+  var hasOwn = Op.hasOwnProperty;
+  var undefined$1; // More compressible than void 0.
+  var $Symbol = typeof Symbol === "function" ? Symbol : {};
+  var iteratorSymbol = $Symbol.iterator || "@@iterator";
+  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
+  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
+
+  function define(obj, key, value) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+    return obj[key];
+  }
+  try {
+    // IE 8 has a broken Object.defineProperty that only works on DOM objects.
+    define({}, "");
+  } catch (err) {
+    define = function(obj, key, value) {
+      return obj[key] = value;
+    };
+  }
+
+  function wrap(innerFn, outerFn, self, tryLocsList) {
+    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
+    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
+    var generator = Object.create(protoGenerator.prototype);
+    var context = new Context(tryLocsList || []);
+
+    // The ._invoke method unifies the implementations of the .next,
+    // .throw, and .return methods.
+    generator._invoke = makeInvokeMethod(innerFn, self, context);
+
+    return generator;
+  }
+  exports.wrap = wrap;
+
+  // Try/catch helper to minimize deoptimizations. Returns a completion
+  // record like context.tryEntries[i].completion. This interface could
+  // have been (and was previously) designed to take a closure to be
+  // invoked without arguments, but in all the cases we care about we
+  // already have an existing method we want to call, so there's no need
+  // to create a new function object. We can even get away with assuming
+  // the method takes exactly one argument, since that happens to be true
+  // in every case, so we don't have to touch the arguments object. The
+  // only additional allocation required is the completion record, which
+  // has a stable shape and so hopefully should be cheap to allocate.
+  function tryCatch(fn, obj, arg) {
+    try {
+      return { type: "normal", arg: fn.call(obj, arg) };
+    } catch (err) {
+      return { type: "throw", arg: err };
+    }
+  }
+
+  var GenStateSuspendedStart = "suspendedStart";
+  var GenStateSuspendedYield = "suspendedYield";
+  var GenStateExecuting = "executing";
+  var GenStateCompleted = "completed";
+
+  // Returning this object from the innerFn has the same effect as
+  // breaking out of the dispatch switch statement.
+  var ContinueSentinel = {};
+
+  // Dummy constructor functions that we use as the .constructor and
+  // .constructor.prototype properties for functions that return Generator
+  // objects. For full spec compliance, you may wish to configure your
+  // minifier not to mangle the names of these two functions.
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+
+  // This is a polyfill for %IteratorPrototype% for environments that
+  // don't natively support it.
+  var IteratorPrototype = {};
+  define(IteratorPrototype, iteratorSymbol, function () {
+    return this;
+  });
+
+  var getProto = Object.getPrototypeOf;
+  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
+  if (NativeIteratorPrototype &&
+      NativeIteratorPrototype !== Op &&
+      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
+    // This environment has a native %IteratorPrototype%; use it instead
+    // of the polyfill.
+    IteratorPrototype = NativeIteratorPrototype;
+  }
+
+  var Gp = GeneratorFunctionPrototype.prototype =
+    Generator.prototype = Object.create(IteratorPrototype);
+  GeneratorFunction.prototype = GeneratorFunctionPrototype;
+  define(Gp, "constructor", GeneratorFunctionPrototype);
+  define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
+  GeneratorFunction.displayName = define(
+    GeneratorFunctionPrototype,
+    toStringTagSymbol,
+    "GeneratorFunction"
+  );
+
+  // Helper for defining the .next, .throw, and .return methods of the
+  // Iterator interface in terms of a single ._invoke method.
+  function defineIteratorMethods(prototype) {
+    ["next", "throw", "return"].forEach(function(method) {
+      define(prototype, method, function(arg) {
+        return this._invoke(method, arg);
+      });
+    });
+  }
+
+  exports.isGeneratorFunction = function(genFun) {
+    var ctor = typeof genFun === "function" && genFun.constructor;
+    return ctor
+      ? ctor === GeneratorFunction ||
+        // For the native GeneratorFunction constructor, the best we can
+        // do is to check its .name property.
+        (ctor.displayName || ctor.name) === "GeneratorFunction"
+      : false;
+  };
+
+  exports.mark = function(genFun) {
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
+    } else {
+      genFun.__proto__ = GeneratorFunctionPrototype;
+      define(genFun, toStringTagSymbol, "GeneratorFunction");
+    }
+    genFun.prototype = Object.create(Gp);
+    return genFun;
+  };
+
+  // Within the body of any async function, `await x` is transformed to
+  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
+  // `hasOwn.call(value, "__await")` to determine if the yielded value is
+  // meant to be awaited.
+  exports.awrap = function(arg) {
+    return { __await: arg };
+  };
+
+  function AsyncIterator(generator, PromiseImpl) {
+    function invoke(method, arg, resolve, reject) {
+      var record = tryCatch(generator[method], generator, arg);
+      if (record.type === "throw") {
+        reject(record.arg);
+      } else {
+        var result = record.arg;
+        var value = result.value;
+        if (value &&
+            typeof value === "object" &&
+            hasOwn.call(value, "__await")) {
+          return PromiseImpl.resolve(value.__await).then(function(value) {
+            invoke("next", value, resolve, reject);
+          }, function(err) {
+            invoke("throw", err, resolve, reject);
+          });
+        }
+
+        return PromiseImpl.resolve(value).then(function(unwrapped) {
+          // When a yielded Promise is resolved, its final value becomes
+          // the .value of the Promise<{value,done}> result for the
+          // current iteration.
+          result.value = unwrapped;
+          resolve(result);
+        }, function(error) {
+          // If a rejected Promise was yielded, throw the rejection back
+          // into the async generator function so it can be handled there.
+          return invoke("throw", error, resolve, reject);
+        });
+      }
+    }
+
+    var previousPromise;
+
+    function enqueue(method, arg) {
+      function callInvokeWithMethodAndArg() {
+        return new PromiseImpl(function(resolve, reject) {
+          invoke(method, arg, resolve, reject);
+        });
+      }
+
+      return previousPromise =
+        // If enqueue has been called before, then we want to wait until
+        // all previous Promises have been resolved before calling invoke,
+        // so that results are always delivered in the correct order. If
+        // enqueue has not been called before, then it is important to
+        // call invoke immediately, without waiting on a callback to fire,
+        // so that the async generator function has the opportunity to do
+        // any necessary setup in a predictable way. This predictability
+        // is why the Promise constructor synchronously invokes its
+        // executor callback, and why async functions synchronously
+        // execute code before the first await. Since we implement simple
+        // async functions in terms of async generators, it is especially
+        // important to get this right, even though it requires care.
+        previousPromise ? previousPromise.then(
+          callInvokeWithMethodAndArg,
+          // Avoid propagating failures to Promises returned by later
+          // invocations of the iterator.
+          callInvokeWithMethodAndArg
+        ) : callInvokeWithMethodAndArg();
+    }
+
+    // Define the unified helper method that is used to implement .next,
+    // .throw, and .return (see defineIteratorMethods).
+    this._invoke = enqueue;
+  }
+
+  defineIteratorMethods(AsyncIterator.prototype);
+  define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
+    return this;
+  });
+  exports.AsyncIterator = AsyncIterator;
+
+  // Note that simple async functions are implemented on top of
+  // AsyncIterator objects; they just return a Promise for the value of
+  // the final result produced by the iterator.
+  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
+    if (PromiseImpl === void 0) PromiseImpl = Promise;
+
+    var iter = new AsyncIterator(
+      wrap(innerFn, outerFn, self, tryLocsList),
+      PromiseImpl
+    );
+
+    return exports.isGeneratorFunction(outerFn)
+      ? iter // If outerFn is a generator, return the full iterator.
+      : iter.next().then(function(result) {
+          return result.done ? result.value : iter.next();
+        });
+  };
+
+  function makeInvokeMethod(innerFn, self, context) {
+    var state = GenStateSuspendedStart;
+
+    return function invoke(method, arg) {
+      if (state === GenStateExecuting) {
+        throw new Error("Generator is already running");
+      }
+
+      if (state === GenStateCompleted) {
+        if (method === "throw") {
+          throw arg;
+        }
+
+        // Be forgiving, per 25.3.3.3.3 of the spec:
+        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
+        return doneResult();
+      }
+
+      context.method = method;
+      context.arg = arg;
+
+      while (true) {
+        var delegate = context.delegate;
+        if (delegate) {
+          var delegateResult = maybeInvokeDelegate(delegate, context);
+          if (delegateResult) {
+            if (delegateResult === ContinueSentinel) continue;
+            return delegateResult;
+          }
+        }
+
+        if (context.method === "next") {
+          // Setting context._sent for legacy support of Babel's
+          // function.sent implementation.
+          context.sent = context._sent = context.arg;
+
+        } else if (context.method === "throw") {
+          if (state === GenStateSuspendedStart) {
+            state = GenStateCompleted;
+            throw context.arg;
+          }
+
+          context.dispatchException(context.arg);
+
+        } else if (context.method === "return") {
+          context.abrupt("return", context.arg);
+        }
+
+        state = GenStateExecuting;
+
+        var record = tryCatch(innerFn, self, context);
+        if (record.type === "normal") {
+          // If an exception is thrown from innerFn, we leave state ===
+          // GenStateExecuting and loop back for another invocation.
+          state = context.done
+            ? GenStateCompleted
+            : GenStateSuspendedYield;
+
+          if (record.arg === ContinueSentinel) {
+            continue;
+          }
+
+          return {
+            value: record.arg,
+            done: context.done
+          };
+
+        } else if (record.type === "throw") {
+          state = GenStateCompleted;
+          // Dispatch the exception by looping back around to the
+          // context.dispatchException(context.arg) call above.
+          context.method = "throw";
+          context.arg = record.arg;
+        }
+      }
+    };
+  }
+
+  // Call delegate.iterator[context.method](context.arg) and handle the
+  // result, either by returning a { value, done } result from the
+  // delegate iterator, or by modifying context.method and context.arg,
+  // setting context.delegate to null, and returning the ContinueSentinel.
+  function maybeInvokeDelegate(delegate, context) {
+    var method = delegate.iterator[context.method];
+    if (method === undefined$1) {
+      // A .throw or .return when the delegate iterator has no .throw
+      // method always terminates the yield* loop.
+      context.delegate = null;
+
+      if (context.method === "throw") {
+        // Note: ["return"] must be used for ES3 parsing compatibility.
+        if (delegate.iterator["return"]) {
+          // If the delegate iterator has a return method, give it a
+          // chance to clean up.
+          context.method = "return";
+          context.arg = undefined$1;
+          maybeInvokeDelegate(delegate, context);
+
+          if (context.method === "throw") {
+            // If maybeInvokeDelegate(context) changed context.method from
+            // "return" to "throw", let that override the TypeError below.
+            return ContinueSentinel;
+          }
+        }
+
+        context.method = "throw";
+        context.arg = new TypeError(
+          "The iterator does not provide a 'throw' method");
+      }
+
+      return ContinueSentinel;
+    }
+
+    var record = tryCatch(method, delegate.iterator, context.arg);
+
+    if (record.type === "throw") {
+      context.method = "throw";
+      context.arg = record.arg;
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    var info = record.arg;
+
+    if (! info) {
+      context.method = "throw";
+      context.arg = new TypeError("iterator result is not an object");
+      context.delegate = null;
+      return ContinueSentinel;
+    }
+
+    if (info.done) {
+      // Assign the result of the finished delegate to the temporary
+      // variable specified by delegate.resultName (see delegateYield).
+      context[delegate.resultName] = info.value;
+
+      // Resume execution at the desired location (see delegateYield).
+      context.next = delegate.nextLoc;
+
+      // If context.method was "throw" but the delegate handled the
+      // exception, let the outer generator proceed normally. If
+      // context.method was "next", forget context.arg since it has been
+      // "consumed" by the delegate iterator. If context.method was
+      // "return", allow the original .return call to continue in the
+      // outer generator.
+      if (context.method !== "return") {
+        context.method = "next";
+        context.arg = undefined$1;
+      }
+
+    } else {
+      // Re-yield the result returned by the delegate method.
+      return info;
+    }
+
+    // The delegate iterator is finished, so forget it and continue with
+    // the outer generator.
+    context.delegate = null;
+    return ContinueSentinel;
+  }
+
+  // Define Generator.prototype.{next,throw,return} in terms of the
+  // unified ._invoke helper method.
+  defineIteratorMethods(Gp);
+
+  define(Gp, toStringTagSymbol, "Generator");
+
+  // A Generator should always return itself as the iterator object when the
+  // @@iterator function is called on it. Some browsers' implementations of the
+  // iterator prototype chain incorrectly implement this, causing the Generator
+  // object to not be returned from this call. This ensures that doesn't happen.
+  // See https://github.com/facebook/regenerator/issues/274 for more details.
+  define(Gp, iteratorSymbol, function() {
+    return this;
+  });
+
+  define(Gp, "toString", function() {
+    return "[object Generator]";
+  });
+
+  function pushTryEntry(locs) {
+    var entry = { tryLoc: locs[0] };
+
+    if (1 in locs) {
+      entry.catchLoc = locs[1];
+    }
+
+    if (2 in locs) {
+      entry.finallyLoc = locs[2];
+      entry.afterLoc = locs[3];
+    }
+
+    this.tryEntries.push(entry);
+  }
+
+  function resetTryEntry(entry) {
+    var record = entry.completion || {};
+    record.type = "normal";
+    delete record.arg;
+    entry.completion = record;
+  }
+
+  function Context(tryLocsList) {
+    // The root entry object (effectively a try statement without a catch
+    // or a finally block) gives us a place to store values thrown from
+    // locations where there is no enclosing try statement.
+    this.tryEntries = [{ tryLoc: "root" }];
+    tryLocsList.forEach(pushTryEntry, this);
+    this.reset(true);
+  }
+
+  exports.keys = function(object) {
+    var keys = [];
+    for (var key in object) {
+      keys.push(key);
+    }
+    keys.reverse();
+
+    // Rather than returning an object with a next method, we keep
+    // things simple and return the next function itself.
+    return function next() {
+      while (keys.length) {
+        var key = keys.pop();
+        if (key in object) {
+          next.value = key;
+          next.done = false;
+          return next;
+        }
+      }
+
+      // To avoid creating an additional object, we just hang the .value
+      // and .done properties off the next function object itself. This
+      // also ensures that the minifier will not anonymize the function.
+      next.done = true;
+      return next;
+    };
+  };
+
+  function values(iterable) {
+    if (iterable) {
+      var iteratorMethod = iterable[iteratorSymbol];
+      if (iteratorMethod) {
+        return iteratorMethod.call(iterable);
+      }
+
+      if (typeof iterable.next === "function") {
+        return iterable;
+      }
+
+      if (!isNaN(iterable.length)) {
+        var i = -1, next = function next() {
+          while (++i < iterable.length) {
+            if (hasOwn.call(iterable, i)) {
+              next.value = iterable[i];
+              next.done = false;
+              return next;
+            }
+          }
+
+          next.value = undefined$1;
+          next.done = true;
+
+          return next;
+        };
+
+        return next.next = next;
+      }
+    }
+
+    // Return an iterator with no values.
+    return { next: doneResult };
+  }
+  exports.values = values;
+
+  function doneResult() {
+    return { value: undefined$1, done: true };
+  }
+
+  Context.prototype = {
+    constructor: Context,
+
+    reset: function(skipTempReset) {
+      this.prev = 0;
+      this.next = 0;
+      // Resetting context._sent for legacy support of Babel's
+      // function.sent implementation.
+      this.sent = this._sent = undefined$1;
+      this.done = false;
+      this.delegate = null;
+
+      this.method = "next";
+      this.arg = undefined$1;
+
+      this.tryEntries.forEach(resetTryEntry);
+
+      if (!skipTempReset) {
+        for (var name in this) {
+          // Not sure about the optimal order of these conditions:
+          if (name.charAt(0) === "t" &&
+              hasOwn.call(this, name) &&
+              !isNaN(+name.slice(1))) {
+            this[name] = undefined$1;
+          }
+        }
+      }
+    },
+
+    stop: function() {
+      this.done = true;
+
+      var rootEntry = this.tryEntries[0];
+      var rootRecord = rootEntry.completion;
+      if (rootRecord.type === "throw") {
+        throw rootRecord.arg;
+      }
+
+      return this.rval;
+    },
+
+    dispatchException: function(exception) {
+      if (this.done) {
+        throw exception;
+      }
+
+      var context = this;
+      function handle(loc, caught) {
+        record.type = "throw";
+        record.arg = exception;
+        context.next = loc;
+
+        if (caught) {
+          // If the dispatched exception was caught by a catch block,
+          // then let that catch block handle the exception normally.
+          context.method = "next";
+          context.arg = undefined$1;
+        }
+
+        return !! caught;
+      }
+
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        var record = entry.completion;
+
+        if (entry.tryLoc === "root") {
+          // Exception thrown outside of any try block that could handle
+          // it, so set the completion value of the entire function to
+          // throw the exception.
+          return handle("end");
+        }
+
+        if (entry.tryLoc <= this.prev) {
+          var hasCatch = hasOwn.call(entry, "catchLoc");
+          var hasFinally = hasOwn.call(entry, "finallyLoc");
+
+          if (hasCatch && hasFinally) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            } else if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+
+          } else if (hasCatch) {
+            if (this.prev < entry.catchLoc) {
+              return handle(entry.catchLoc, true);
+            }
+
+          } else if (hasFinally) {
+            if (this.prev < entry.finallyLoc) {
+              return handle(entry.finallyLoc);
+            }
+
+          } else {
+            throw new Error("try statement without catch or finally");
+          }
+        }
+      }
+    },
+
+    abrupt: function(type, arg) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc <= this.prev &&
+            hasOwn.call(entry, "finallyLoc") &&
+            this.prev < entry.finallyLoc) {
+          var finallyEntry = entry;
+          break;
+        }
+      }
+
+      if (finallyEntry &&
+          (type === "break" ||
+           type === "continue") &&
+          finallyEntry.tryLoc <= arg &&
+          arg <= finallyEntry.finallyLoc) {
+        // Ignore the finally entry if control is not jumping to a
+        // location outside the try/catch block.
+        finallyEntry = null;
+      }
+
+      var record = finallyEntry ? finallyEntry.completion : {};
+      record.type = type;
+      record.arg = arg;
+
+      if (finallyEntry) {
+        this.method = "next";
+        this.next = finallyEntry.finallyLoc;
+        return ContinueSentinel;
+      }
+
+      return this.complete(record);
+    },
+
+    complete: function(record, afterLoc) {
+      if (record.type === "throw") {
+        throw record.arg;
+      }
+
+      if (record.type === "break" ||
+          record.type === "continue") {
+        this.next = record.arg;
+      } else if (record.type === "return") {
+        this.rval = this.arg = record.arg;
+        this.method = "return";
+        this.next = "end";
+      } else if (record.type === "normal" && afterLoc) {
+        this.next = afterLoc;
+      }
+
+      return ContinueSentinel;
+    },
+
+    finish: function(finallyLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.finallyLoc === finallyLoc) {
+          this.complete(entry.completion, entry.afterLoc);
+          resetTryEntry(entry);
+          return ContinueSentinel;
+        }
+      }
+    },
+
+    "catch": function(tryLoc) {
+      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
+        var entry = this.tryEntries[i];
+        if (entry.tryLoc === tryLoc) {
+          var record = entry.completion;
+          if (record.type === "throw") {
+            var thrown = record.arg;
+            resetTryEntry(entry);
+          }
+          return thrown;
+        }
+      }
+
+      // The context.catch method must only be called with a location
+      // argument that corresponds to a known catch block.
+      throw new Error("illegal catch attempt");
+    },
+
+    delegateYield: function(iterable, resultName, nextLoc) {
+      this.delegate = {
+        iterator: values(iterable),
+        resultName: resultName,
+        nextLoc: nextLoc
+      };
+
+      if (this.method === "next") {
+        // Deliberately forget the last sent value so that we don't
+        // accidentally pass it on to the delegate.
+        this.arg = undefined$1;
+      }
+
+      return ContinueSentinel;
+    }
+  };
+
+  // Regardless of whether this script is executing as a CommonJS module
+  // or not, return the runtime object so that we can declare the variable
+  // regeneratorRuntime in the outer scope, which allows this module to be
+  // injected easily by `bin/regenerator --include-runtime script.js`.
+  return exports;
+
+}(
+  // If this script is executing as a CommonJS module, use module.exports
+  // as the regeneratorRuntime namespace. Otherwise create a new empty
+  // object. Either way, the resulting object will be used to initialize
+  // the regeneratorRuntime variable at the top of this file.
+   module.exports 
+));
+
+try {
+  regeneratorRuntime = runtime;
+} catch (accidentalStrictMode) {
+  // This module should not be running in strict mode, so the above
+  // assignment should always work unless something is misconfigured. Just
+  // in case runtime.js accidentally runs in strict mode, in modern engines
+  // we can explicitly access globalThis. In older engines we can escape
+  // strict mode using a global Function call. This could conceivably fail
+  // if a Content Security Policy forbids using Function, but in that case
+  // the proper solution is to fix the accidental strict mode problem. If
+  // you've misconfigured your bundler to force strict mode and applied a
+  // CSP to forbid Function, and you're not willing to fix either of those
+  // problems, please detail your unique predicament in a GitHub issue.
+  if (typeof globalThis === "object") {
+    globalThis.regeneratorRuntime = runtime;
+  } else {
+    Function("r", "regeneratorRuntime = r")(runtime);
+  }
+}
+});
+
+var AxiosService = /*#__PURE__*/function () {
+  function AxiosService(config) {
+    if (!config) config = {};
+    this.axios = axios.create(config);
+  }
+
+  var _proto = AxiosService.prototype;
+
+  _proto.apiRequest = /*#__PURE__*/function () {
+    var _apiRequest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(config, url, data) {
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!config.headers) config.headers = {};
+              config.headers['Content-Type'] = 'application/json';
+              return _context.abrupt("return", this.axios(_extends({}, config, {
+                url: url,
+                data: data
+              })).then(function (res) {
+                return res.data;
+              }));
+
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function apiRequest(_x, _x2, _x3) {
+      return _apiRequest.apply(this, arguments);
+    }
+
+    return apiRequest;
+  }();
+
+  _proto.apiRequestHeader = /*#__PURE__*/function () {
+    var _apiRequestHeader = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(config, url, headerToRetrieve, data) {
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!config.headers) config.headers = {};
+              config.headers['Content-Type'] = 'application/json';
+              return _context2.abrupt("return", this.axios(_extends({}, config, {
+                url: url,
+                data: data
+              })).then(function (res) {
+                if (headerToRetrieve) {
+                  var _res$headers$headerTo;
+
+                  return (_res$headers$headerTo = res.headers[headerToRetrieve]) != null ? _res$headers$headerTo : res.headers[headerToRetrieve.toLowerCase()];
+                }
+
+                return res.headers;
+              }));
+
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function apiRequestHeader(_x4, _x5, _x6, _x7) {
+      return _apiRequestHeader.apply(this, arguments);
+    }
+
+    return apiRequestHeader;
+  }();
+
+  _proto.get = function get(url, config) {
+    return this.apiRequest(_extends({}, config, {
+      method: 'get'
+    }), url);
+  };
+
+  _proto.deleteRequest = function deleteRequest(url, config) {
+    return this.apiRequest(_extends({}, config, {
+      method: 'delete'
+    }), url);
+  };
+
+  _proto.post = function post(url, data, config) {
+    return this.apiRequest(_extends({}, config, {
+      method: 'post'
+    }), url, data);
+  };
+
+  _proto.put = function put(url, data, config) {
+    return this.apiRequest(_extends({}, config, {
+      method: 'put'
+    }), url, data);
+  };
+
+  _proto.patch = function patch(url, data, config) {
+    return this.apiRequest(_extends({}, config, {
+      method: 'patch'
+    }), url, data);
+  };
+
+  _proto.head = function head(url, config, headerToRetrieve, data) {
+    return this.apiRequestHeader(_extends({}, config, {
+      method: 'head'
+    }), url, headerToRetrieve, data);
+  };
+
+  return AxiosService;
+}();
+
+var APIService = /*#__PURE__*/function (_AxiosService) {
+  _inheritsLoose(APIService, _AxiosService);
+
+  function APIService(config, tokenRefreshFailureCallback) {
+    var _this;
+
+    _this = _AxiosService.call(this, config) || this;
+    _this.tokenRefreshFailureCallback = tokenRefreshFailureCallback;
+
+    var self = _assertThisInitialized(_this);
+
+    _this.axios.interceptors.request.use(function (config) {
+      var token = config.useRefreshToken ? self.getTokens().refreshToken : self.getTokens().accessToken;
+      config.headers = _extends({}, config.headers, {
+        Authorization: "Bearer " + token
+      });
+      return config;
+    }, function (error) {
+      Promise.reject(error);
+    });
+
+    createAuthRefreshInterceptor(_this.axios, /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(failedRequest) {
+        var tokenResp;
+        return runtime_1.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!self.authRefreshFn) {
+                  _context.next = 15;
+                  break;
+                }
+
+                _context.prev = 1;
+                _context.next = 4;
+                return self.authRefreshFn(self.getTokens().refreshToken);
+
+              case 4:
+                tokenResp = _context.sent;
+                self.setTokens({
+                  accessToken: tokenResp.accessToken,
+                  refreshToken: tokenResp.refreshToken
+                });
+                failedRequest.response.config.headers['Authorization'] = "Bearer " + self.getTokens().accessToken;
+                return _context.abrupt("return", Promise.resolve());
+
+              case 10:
+                _context.prev = 10;
+                _context.t0 = _context["catch"](1);
+                console.error('an error occured while refreshing tokens (notifying callback)', _context.t0);
+                if (self.tokenRefreshFailureCallback) self.tokenRefreshFailureCallback(failedRequest);
+                return _context.abrupt("return", Promise.resolve());
+
+              case 15:
+                console.error('The request could not refresh the token (authRefreshFn was not set)', failedRequest);
+                return _context.abrupt("return", Promise.resolve());
+
+              case 17:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, null, [[1, 10]]);
+      }));
+
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }(), {
+      statusCodes: [401, 403]
+    });
+    return _this;
+  }
+
+  var _proto = APIService.prototype;
+
+  _proto.setAuthRefreshFn = function setAuthRefreshFn(fn) {
+    this.authRefreshFn = fn;
+  };
+
+  _proto.setTokens = function setTokens(tokens) {
+    localStorage.setItem('tokens', JSON.stringify(tokens));
+  };
+
+  _proto.getTokens = function getTokens() {
+    var tokens = {};
+    var item = localStorage.getItem('tokens');
+
+    if (item) {
+      tokens = JSON.parse(item);
+    }
+
+    return tokens;
+  };
+
+  return APIService;
+}(AxiosService);
+
+(function (AssistantType) {
+  AssistantType["MedicalSecretary"] = "MedicalSecretary";
+  AssistantType["Nurse"] = "Nurse";
+  AssistantType["Specialist"] = "Specialist";
+  AssistantType["Administrative"] = "Administrative";
+  AssistantType["Other"] = "Other";
+})(exports.AssistantType || (exports.AssistantType = {}));
+
+(function (TransmissionKind) {
+  TransmissionKind["Fax"] = "Fax";
+  TransmissionKind["Email"] = "Email";
+  TransmissionKind["SMS"] = "SMS";
+  TransmissionKind["EncryptedEmail"] = "EncryptedEmail";
+  TransmissionKind["Logs"] = "Logs";
+  TransmissionKind["API"] = "API";
+  TransmissionKind["Other"] = "Other";
+})(exports.TransmissionKind || (exports.TransmissionKind = {}));
+
+(function (TransmissionStatus) {
+  TransmissionStatus["Preparing"] = "Preparing";
+  TransmissionStatus["Sending"] = "Sending";
+  TransmissionStatus["Sent"] = "Sent";
+  TransmissionStatus["Retrying"] = "Retrying";
+  TransmissionStatus["Failed"] = "Failed";
+  TransmissionStatus["DriverError"] = "DriverError";
+  TransmissionStatus["TimedOut"] = "TimedOut";
+  TransmissionStatus["ReceiverNotExist"] = "ReceiverNotExist";
+  TransmissionStatus["ReceiverNotAnswering"] = "ReceiverNotAnswering";
+  TransmissionStatus["ReceiverIncompatible"] = "ReceiverIncompatible";
+})(exports.TransmissionStatus || (exports.TransmissionStatus = {}));
+
+(function (FeeStatus) {
+  FeeStatus["NoFee"] = "NoFee";
+  FeeStatus["Pending"] = "Pending";
+  FeeStatus["Paid"] = "Paid";
+  FeeStatus["Reimbursed"] = "Reimbursed";
+  FeeStatus["Cancelled"] = "Cancelled";
+  FeeStatus["Contested"] = "Contested";
+})(exports.FeeStatus || (exports.FeeStatus = {}));
+
+(function (MedicalStatus) {
+  MedicalStatus["Creating"] = "Creating";
+  MedicalStatus["New"] = "New";
+  MedicalStatus["ToAnswer"] = "ToAnswer";
+  MedicalStatus["Answered"] = "Answered";
+  MedicalStatus["Closed"] = "Closed";
+  MedicalStatus["Reopened"] = "Reopened";
+  MedicalStatus["Archived"] = "Archived";
+})(exports.MedicalStatus || (exports.MedicalStatus = {}));
+
+(function (TaskStatus) {
+  TaskStatus["None"] = "None";
+  TaskStatus["ToDo"] = "ToDo";
+  TaskStatus["InProgress"] = "InProgress";
+  TaskStatus["Blocked"] = "Blocked";
+  TaskStatus["Done"] = "Done";
+})(exports.TaskStatus || (exports.TaskStatus = {}));
+
+(function (DiagnosisType) {
+  DiagnosisType["Generic"] = "Generic";
+  DiagnosisType["Private"] = "Private";
+  DiagnosisType["Instance"] = "Instance";
+})(exports.DiagnosisType || (exports.DiagnosisType = {}));
+
+(function (DrugType) {
+  DrugType["Generic"] = "Generic";
+  DrugType["Instance"] = "Instance";
+})(exports.DrugType || (exports.DrugType = {}));
+
+(function (PlanStatus) {
+  PlanStatus["Pending"] = "Pending";
+  PlanStatus["Accepted"] = "Accepted";
+  PlanStatus["Rejected"] = "Rejected";
+})(exports.PlanStatus || (exports.PlanStatus = {}));
+
+var AuthenticationFailed = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(AuthenticationFailed, _Error);
+
+  function AuthenticationFailed() {
+    return _Error.apply(this, arguments) || this;
+  }
+
+  return AuthenticationFailed;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var AuthenticationBadRequest = /*#__PURE__*/function (_Error2) {
+  _inheritsLoose(AuthenticationBadRequest, _Error2);
+
+  function AuthenticationBadRequest() {
+    return _Error2.apply(this, arguments) || this;
+  }
+
+  return AuthenticationBadRequest;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var AuthenticationServerError = /*#__PURE__*/function (_Error3) {
+  _inheritsLoose(AuthenticationServerError, _Error3);
+
+  function AuthenticationServerError() {
+    return _Error3.apply(this, arguments) || this;
+  }
+
+  return AuthenticationServerError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var IdentityCreationFailed = /*#__PURE__*/function (_Error4) {
+  _inheritsLoose(IdentityCreationFailed, _Error4);
+
+  function IdentityCreationFailed() {
+    return _Error4.apply(this, arguments) || this;
+  }
+
+  return IdentityCreationFailed;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var IdentityCreationBadRequest = /*#__PURE__*/function (_Error5) {
+  _inheritsLoose(IdentityCreationBadRequest, _Error5);
+
+  function IdentityCreationBadRequest() {
+    return _Error5.apply(this, arguments) || this;
+  }
+
+  return IdentityCreationBadRequest;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+var IdentityCreationConflict = /*#__PURE__*/function (_Error6) {
+  _inheritsLoose(IdentityCreationConflict, _Error6);
+
+  function IdentityCreationConflict() {
+    return _Error6.apply(this, arguments) || this;
+  }
+
+  return IdentityCreationConflict;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+(function (WorkflowType) {
+  WorkflowType["Onboard"] = "Onboard";
+  WorkflowType["Followup"] = "Followup";
+  WorkflowType["Renew"] = "Renew";
+  WorkflowType["DataRetrieve"] = "DataRetrieve";
+})(exports.WorkflowType || (exports.WorkflowType = {}));
+
+(function (RateDimension) {
+  RateDimension["RatioOnTotal"] = "RatioOnTotal";
+  RateDimension["FixedOnTotal"] = "FixedOnTotal";
+  RateDimension["RatioPlatformFee"] = "RatioPlatformFee";
+  RateDimension["FixedPlatformFee"] = "FixedPlatformFee";
+  RateDimension["RatioOnPlatformFeeTotal"] = "RatioOnPlatformFeeTotal";
+  RateDimension["FixedOnPlatformFeeTotal"] = "FixedOnPlatformFeeTotal";
+  RateDimension["RatioOnItem"] = "RatioOnItem";
+  RateDimension["FixedOnItem"] = "FixedOnItem";
+})(exports.RateDimension || (exports.RateDimension = {}));
+
+(function (PlanType) {
+  PlanType["Onboard"] = "Onboard";
+  PlanType["Followup"] = "Followup";
+  PlanType["Renew"] = "Renew";
+  PlanType["DataRetrieve"] = "DataRetrieve";
+})(exports.PlanType || (exports.PlanType = {}));
+
+(function (PaymentStatus) {
+  PaymentStatus["Pending"] = "Pending";
+  PaymentStatus["Success"] = "Success";
+  PaymentStatus["Failure"] = "Failure";
+  PaymentStatus["Canceled"] = "Canceled";
+})(exports.PaymentStatus || (exports.PaymentStatus = {}));
+
+(function (PractitionerStatus) {
+  PractitionerStatus["Practicing"] = "Practicing";
+  PractitionerStatus["Retired"] = "Retired";
+  PractitionerStatus["NotInvolvedAnymore"] = "NotInvolvedAnymore";
+  PractitionerStatus["Deactivated"] = "Deactivated";
+  PractitionerStatus["Flagged"] = "Flagged";
+  PractitionerStatus["InConflict"] = "InConflict";
+  PractitionerStatus["Delicensed"] = "Delicensed";
+})(exports.PractitionerStatus || (exports.PractitionerStatus = {}));
+
+(function (AssignmentStatus) {
+  AssignmentStatus["Assigned"] = "Assigned";
+  AssignmentStatus["Reassigned"] = "Reassigned";
+  AssignmentStatus["Cancelled"] = "Cancelled";
+})(exports.AssignmentStatus || (exports.AssignmentStatus = {}));
+
+(function (PractitionnerRoleType) {
+  PractitionnerRoleType["Doctor"] = "Doctor";
+  PractitionnerRoleType["MedicalAssistant"] = "MedicalAssistant";
+  PractitionnerRoleType["MedicalSecretary"] = "MedicalSecretary";
+  PractitionnerRoleType["Nurse"] = "Nurse";
+  PractitionnerRoleType["Specialist"] = "Specialist";
+  PractitionnerRoleType["LabAssistant"] = "LabAssistant";
+  PractitionnerRoleType["Administrative"] = "Administrative";
+  PractitionnerRoleType["ManualDispatcher"] = "ManualDispatcher";
+  PractitionnerRoleType["Other"] = "Other";
+})(exports.PractitionnerRoleType || (exports.PractitionnerRoleType = {}));
+
+(function (OtherRoleType) {
+  OtherRoleType["Patient"] = "Patient";
+  OtherRoleType["User"] = "User";
+  OtherRoleType["System"] = "System";
+})(exports.OtherRoleType || (exports.OtherRoleType = {}));
+
+(function (LicenseStatus) {
+  LicenseStatus["Valid"] = "Valid";
+  LicenseStatus["Invalid"] = "Invalid";
+  LicenseStatus["Expired"] = "Expired";
+  LicenseStatus["NA"] = "NA";
+  LicenseStatus["Removed"] = "Removed";
+})(exports.LicenseStatus || (exports.LicenseStatus = {}));
+
+(function (PeriodType) {
+  PeriodType["PerYear"] = "PerYear";
+  PeriodType["PerQuarter"] = "PerQuarter";
+  PeriodType["PerMonth"] = "PerMonth";
+  PeriodType["PerWeek"] = "PerWeek";
+  PeriodType["PerBusinessDay"] = "PerBusinessDay";
+  PeriodType["PerDay"] = "PerDay";
+  PeriodType["PerHour"] = "PerHour";
+})(exports.PeriodType || (exports.PeriodType = {}));
+
+(function (SyncStatus) {
+  SyncStatus["Requested"] = "Requested";
+  SyncStatus["Started"] = "Started";
+  SyncStatus["Succeeded"] = "Succeeded";
+  SyncStatus["Failed"] = "Failed";
+  SyncStatus["Cancelled"] = "Cancelled";
+})(exports.SyncStatus || (exports.SyncStatus = {}));
+
+(function (PracticeEmailKind) {
+  PracticeEmailKind["SignedUp"] = "SignedUp";
+  PracticeEmailKind["Onboarded"] = "Onboarded";
+  PracticeEmailKind["OnboardedPractitioner"] = "OnboardedPractitioner";
+  PracticeEmailKind["OnboardedPatient"] = "OnboardedPatient";
+  PracticeEmailKind["Answered"] = "Answered";
+  PracticeEmailKind["ToAnswer"] = "ToAnswer";
+  PracticeEmailKind["FollowedUp"] = "FollowedUp";
+  PracticeEmailKind["Renewed"] = "Renewed";
+  PracticeEmailKind["DataRetrieved"] = "DataRetrieved";
+})(exports.PracticeEmailKind || (exports.PracticeEmailKind = {}));
+
+(function (PracticeConfigKind) {
+  PracticeConfigKind["PractitionerConsultList"] = "PractitionerConsultList";
+  PracticeConfigKind["PractitionerChatbox"] = "PractitionerChatbox";
+  PracticeConfigKind["PracticeTheme"] = "PracticeTheme";
+  PracticeConfigKind["PracticeLocaleSwitcher"] = "PracticeLocaleSwitcher";
+  PracticeConfigKind["PracticeCookieBanner"] = "PracticeCookieBanner";
+})(exports.PracticeConfigKind || (exports.PracticeConfigKind = {}));
+
+(function (StripePriceType) {
+  StripePriceType["Default"] = "Default";
+  StripePriceType["Discount"] = "Discount";
+})(exports.StripePriceType || (exports.StripePriceType = {}));
+
+(function (IndexKey) {
+  IndexKey["Consultation"] = "Consultation";
+  IndexKey["IndexSnapshot"] = "IndexSnapshot";
+  IndexKey["ConsultationLockbox"] = "ConsultationLockbox";
+})(exports.IndexKey || (exports.IndexKey = {}));
+
+(function (DocumentType) {
+  DocumentType["Message"] = "Message";
+  DocumentType["Note"] = "Note";
+  DocumentType["DoctorsNote"] = "DoctorsNote";
+  DocumentType["Prescription"] = "Prescription";
+  DocumentType["ExamRequest"] = "ExamRequest";
+  DocumentType["Result"] = "Result";
+  DocumentType["Attachment"] = "Attachment";
+  DocumentType["BigFile"] = "BigFile";
+  DocumentType["MeetingRequest"] = "MeetingRequest";
+  DocumentType["AudioNote"] = "AudioNote";
+  DocumentType["VideoNote"] = "VideoNote";
+  DocumentType["PopulatedWorkflowData"] = "PopulatedWorkflowData";
+  DocumentType["TreatmentPlan"] = "TreatmentPlan";
+  DocumentType["ImageAlias"] = "ImageAlias";
+})(exports.DocumentType || (exports.DocumentType = {}));
+
+(function (MetadataCategory) {
+  MetadataCategory["ChildPersonal"] = "ChildPersonal";
+  MetadataCategory["Consultation"] = "Consultation";
+  MetadataCategory["DataRetrieval"] = "DataRetrieval";
+  MetadataCategory["Followup"] = "Followup";
+  MetadataCategory["Recovery"] = "Recovery";
+  MetadataCategory["Medical"] = "Medical";
+  MetadataCategory["OtherPersonal"] = "OtherPersonal";
+  MetadataCategory["Personal"] = "Personal";
+  MetadataCategory["Preference"] = "Preference";
+  MetadataCategory["Prescription"] = "Prescription";
+  MetadataCategory["Raw"] = "Raw";
+})(exports.MetadataCategory || (exports.MetadataCategory = {}));
+
+var ConsultService = /*#__PURE__*/function () {
+  function ConsultService(api, baseURL) {
+    this.api = api;
+    this.baseURL = baseURL;
+  }
+
+  var _proto = ConsultService.prototype;
+
+  _proto.consultCreate = function consultCreate(c) {
+    return this.api.post(this.baseURL + "/v1/consults", c);
+  }
+  /**
+   * This function returns the number of consults using parameters
+   * @param uuidPractice the practice uuid
+   * @param uuidRequester the requester uuid
+   * @param statusesMedical an array containing MedicalStatus to include
+   * @param statusesExclude an array containing MedicalStatus to exclude
+   * @param shortId a shortId matcher (will match all consult with a shortId starting with this `shortId`)
+   * @param columnToSortTo the list of columns separated by commas, to sort to (in order of sorting)
+   * @param orderToSortTo the type of sorting to do ('asc' for ascending or 'desc' for descending)
+   * @param perPage the number of item to retrieve per "page"
+   * @param indexPage the actual index of the page to retrieve (0 based: 0 is the first items)
+   * @param filterAssignedDoctor the uuid of the doctor for which to filter with
+   * @param filterCurrentPractitioner the uuid of the current assistant assigned to filter with
+   * @param filterIsoLocality the of isoLocality to filter with
+   * @returns a number of consult
+   */
+  ;
+
+  _proto.countConsults = function countConsults(uuidPractice, uuidRequester, statusesMedical, statusesExclude, shortId, columnToSortTo, orderToSortTo, perPage, indexPage, filterAssignedDoctor, filterCurrentPractitioner, filterIsoLocality) {
+    return this.api.head(this.baseURL + "/v1/consults", {
+      params: {
+        uuidPractice: uuidPractice,
+        uuidRequester: uuidRequester,
+        statusesMedical: statusesMedical,
+        statusesExclude: statusesExclude,
+        shortId: shortId,
+        perPage: perPage,
+        page: indexPage,
+        sortColumns: columnToSortTo,
+        orderColumns: orderToSortTo,
+        filterAssignedDoctor: filterAssignedDoctor,
+        filterCurrentPractitioner: filterCurrentPractitioner,
+        filterIsoLocality: filterIsoLocality
+      }
+    }, 'Content-Range').then(function (resContentRange) {
+      if (!resContentRange || typeof resContentRange !== 'string' && typeof resContentRange !== 'number') {
+        return 0;
+      }
+
+      if (typeof resContentRange === 'number') {
+        return resContentRange;
+      }
+
+      return parseInt(resContentRange);
+    });
+  }
+  /**
+   * This function get consults using parameters
+   * @param uuidPractice the practice uuid
+   * @param uuidRequester the requester uuid
+   * @param statusesMedical an array containing MedicalStatus to include
+   * @param statusesExclude an array containing MedicalStatus to exclude
+   * @param shortId a shortId matcher (will match all consult with a shortId starting with this `shortId`)
+   * @param columnToSortTo the list of columns separated by commas, to sort to (in order of sorting)
+   * @param orderToSortTo the type of sorting to do ('asc' for ascending or 'desc' for descending)
+   * @param perPage the number of item to retrieve per "page"
+   * @param indexPage the actual index of the page to retrieve (0 based: 0 is the first items)
+   * @param filterAssignedDoctor the uuid of the doctor for which to filter with
+   * @param filterCurrentPractitioner the uuid of the current assistant assigned to filter with
+   * @param filterIsoLocality the of isoLocality to filter with
+   * @returns a list of consult
+   */
+  ;
+
+  _proto.getConsults = function getConsults(uuidPractice, uuidRequester, statusesMedical, statusesExclude, shortId, columnToSortTo, orderToSortTo, perPage, indexPage, filterAssignedDoctor, filterCurrentPractitioner, filterIsoLocality) {
+    return this.api.get(this.baseURL + "/v1/consults", {
+      params: {
+        uuidPractice: uuidPractice,
+        uuidRequester: uuidRequester,
+        statusesMedical: statusesMedical,
+        statusesExclude: statusesExclude,
+        shortId: shortId,
+        perPage: perPage,
+        page: indexPage,
+        sortColumns: columnToSortTo,
+        orderColumns: orderToSortTo,
+        filterAssignedDoctor: filterAssignedDoctor,
+        filterCurrentPractitioner: filterCurrentPractitioner,
+        filterIsoLocality: filterIsoLocality
+      }
+    });
+  };
+
+  _proto.getConsultByUUID = function getConsultByUUID(uuidConsult, uuidPractice) {
+    return this.api.get(this.baseURL + "/v1/consults/" + uuidConsult, {
+      params: {
+        uuidPractice: uuidPractice
+      }
+    });
+  };
+
+  _proto.updateConsultByUUID = function updateConsultByUUID(uuidConsult, consult, uuidPractice, uuidRequester) {
+    return this.api.put(this.baseURL + "/v1/consults/" + uuidConsult, consult, {
+      params: {
+        uuidPractice: uuidPractice,
+        uuidRequester: uuidRequester
+      }
+    });
+  };
+
+  _proto.getConsultFaxStatuses = function getConsultFaxStatuses(uuidConsult) {
+    return this.api.get(this.baseURL + "/v1/consults/" + uuidConsult + "/transmissions", {
+      params: {
+        kind: exports.TransmissionKind.Fax
+      }
+    });
+  };
+
+  _proto.postConsultTransmission = function postConsultTransmission(uuidConsult, nameDriver, addressOrPhoneToSendTo, file, nameReceiver, txtTransmissionTitle, txtTransmissionNotes // numTry ?: number,
+  // delay ?: number,
+  ) {
+    if (nameDriver === void 0) {
+      nameDriver = 'Documo';
+    }
+
+    var data = new FormData();
+    data.append('nameDriverReceiver', nameDriver);
+
+    if (addressOrPhoneToSendTo) {
+      data.append('addressReceiver', addressOrPhoneToSendTo);
+    }
+
+    if (file) {
+      data.append('file', file);
+    }
+
+    if (nameReceiver) {
+      data.append('nameReceiver', nameReceiver);
+    }
+
+    if (txtTransmissionTitle) {
+      data.append('txtTransmissionTitle', txtTransmissionTitle);
+    }
+
+    if (txtTransmissionNotes) {
+      data.append('txtTransmissionNotes', txtTransmissionNotes);
+    }
+
+    return this.api.post(this.baseURL + "/v1/consults/" + uuidConsult + "/transmissions", data, {
+      headers: {
+        'Content-Type': 'multipart/form-data;'
+      }
+    });
+  };
+
+  _proto.postConsultFax = function postConsultFax(uuidConsult, addressReceiver, file) {
+    return this.postConsultTransmission(uuidConsult, 'Documo', addressReceiver, file);
+  };
+
+  _proto.postConsultEmail = function postConsultEmail(uuidConsult, file) {
+    return this.postConsultTransmission(uuidConsult, 'Pharmacierge', undefined, file);
+  };
+
+  _proto.retryConsultFax = function retryConsultFax(uuidConsult, transmissionId) {
+    return this.api.put(this.baseURL + "/v1/consults/" + uuidConsult + "/transmissions/" + transmissionId, {
+      status: exports.TransmissionStatus.Retrying
+    });
+  };
+
+  _proto.updateConsultTransmissionStatus = function updateConsultTransmissionStatus(transmissionId, uuidConsult, newStatus) {
+    return this.api.put(this.baseURL + "/v1/consults/" + uuidConsult + "/transmissions/" + transmissionId, {
+      status: newStatus
+    });
+  };
+
+  return ConsultService;
+}();
+
+var DiagnosisService = /*#__PURE__*/function () {
+  function DiagnosisService(api, baseURL) {
+    this.api = api;
+    this.baseURL = baseURL;
+  }
+
+  var _proto = DiagnosisService.prototype;
+
+  _proto.getDiagnoses = function getDiagnoses() {
+    return this.api.get(this.baseURL + "/v1/diagnoses");
+  }
+  /**
+   * Get a diagnosis by uuid that belongs to your practice
+   * @param uuidDiagnosis the uuid of the diagnosis
+   * @returns a diagnosis
+   */
+  ;
+
+  _proto.getDiagnosisByUuid = function getDiagnosisByUuid(uuidDiagnosis) {
+    return this.api.get(this.baseURL + "/v1/diagnoses/" + uuidDiagnosis);
+  };
+
+  _proto.createDiagnosis = function createDiagnosis(diagnosis) {
+    return this.api.post(this.baseURL + "/v1/diagnoses", diagnosis);
+  };
+
+  _proto.updateDiagnosis = function updateDiagnosis(uuid, diagnosis) {
+    return this.api.put(this.baseURL + "/v1/diagnoses/" + uuid, diagnosis);
+  };
+
+  _proto.getTreatmentsFromDiagnosisUuid = function getTreatmentsFromDiagnosisUuid(diagnosisUuid) {
+    return this.api.get(this.baseURL + "/v1/diagnoses/" + diagnosisUuid + "/treatments");
+  }
+  /**
+   * This function returns treatment plans associated to a consult
+   * @param uuidConsult the consult uuid to fetch
+   * @returns an array of TreatmentPlan
+   */
+  ;
+
+  _proto.getTreatmentPlansFromConsultUuid = function getTreatmentPlansFromConsultUuid(uuidConsult) {
+    return this.api.get(this.baseURL + "/v1/treatment-plans/", {
+      params: {
+        uuidConsult: uuidConsult
+      }
+    });
+  }
+  /**
+   * creates a new treatment for the specified diagnosis
+   * @param diagnosisUuid uuid of the diagnosis that the treatment is linked to
+   * @param treatmentRequest the treatment to be inserted
+   */
+  ;
+
+  _proto.createTreatment = function createTreatment(diagnosisUuid, treatmentRequest) {
+    return this.api.post(this.baseURL + "/v1/diagnoses/" + diagnosisUuid + "/treatments", treatmentRequest);
+  }
+  /**
+   * This function returns populated treatment plans associated to a consult
+   * @param uuidConsult the consult uuid to fetch
+   * @returns a TreatmentPlans object
+   */
+  ;
+
+  _proto.getTreatmentPlansPopulatedFromConsultUuid = function getTreatmentPlansPopulatedFromConsultUuid(uuidConsult) {
+    return this.api.get(this.baseURL + "/v1/treatment-plans/", {
+      params: {
+        uuidConsult: uuidConsult,
+        populated: true
+      }
+    });
+  };
+
+  _proto.postPlans = function postPlans(plans) {
+    return this.api.post(this.baseURL + "/v1/treatment-plans", plans);
+  };
+
+  _proto.updateTreatmentPlan = function updateTreatmentPlan(uuidPlan, uuidConsult, diagnosisRequest, plan) {
+    return this.api.put(this.baseURL + "/v1/treatment-plans/" + uuidPlan, {
+      uuidConsult: uuidConsult,
+      diagnosis: diagnosisRequest,
+      plan: plan
+    });
+  };
+
+  _proto.acceptTreatmentPlan = function acceptTreatmentPlan(uuidPlan, uuidConsult) {
+    return this.api.put(this.baseURL + "/v1/treatment-plans/" + uuidPlan + "/accept", {
+      uuidConsult: uuidConsult
+    });
+  }
+  /**
+   * retrieves all the drugs of the specified practice
+   * @param uuidPractice
+   */
+  ;
+
+  _proto.getAllDrugs =
+  /*#__PURE__*/
+  function () {
+    var _getAllDrugs = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(uuidPractice) {
+      var res;
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return this.api.get(this.baseURL + "/v1/drugs/practice/" + uuidPractice);
+
+            case 2:
+              res = _context.sent;
+
+              if (!(res && res.foundDrugs)) {
+                _context.next = 5;
+                break;
+              }
+
+              return _context.abrupt("return", res.foundDrugs);
+
+            case 5:
+              return _context.abrupt("return", undefined);
+
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function getAllDrugs(_x) {
+      return _getAllDrugs.apply(this, arguments);
+    }
+
+    return getAllDrugs;
+  }();
+
+  return DiagnosisService;
+}();
+
+var GuardService = /*#__PURE__*/function () {
+  function GuardService(api, baseURL) {
+    this.api = api;
+    this.baseURL = baseURL;
+    this.api.setAuthRefreshFn(this.authRefresh.bind(this));
+    this.identityCache = {};
+    this.whoAmICache = {};
+  }
+  /**
+   * Will replace access and refresh tokens with `tokens`
+   *
+   * Note:
+   * ```typescript
+   * setTokens({accessToken: undefined, refreshToken: 'aTokenValue'}) // will erase accessToken and set refreshToken with 'aTokenValue'
+   * setTokens({refreshToken: 'aTokenValue'}) // will keep actual value of accessToken and set refreshToken with 'aTokenValue'
+   *
+   * ```
+   * @param tokens
+   */
+
+
+  var _proto = GuardService.prototype;
+
+  _proto.setTokens = function setTokens(tokens) {
+    this.api.setTokens(_extends({}, this.api.getTokens(), tokens));
+  }
+  /**
+   * Allow to retrieve an access token and a refresh token in order
+   * to do authenticated request afterward
+   *
+   * @param req The credentials required to get an access token
+   * @returns AuthTokenResponse
+   */
+  ;
+
+  _proto.authToken =
+  /*#__PURE__*/
+  function () {
+    var _authToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(req) {
+      var resp, config, _e$response, code;
+
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.prev = 0;
+              config = {
+                skipAuthRefresh: true
+              };
+              _context.next = 4;
+              return this.api.post(this.baseURL + "/v1/auth/token", req, config);
+
+            case 4:
+              resp = _context.sent;
+              this.api.setTokens({
+                accessToken: resp.accessToken,
+                refreshToken: resp.refreshToken
+              });
+              _context.next = 19;
+              break;
+
+            case 8:
+              _context.prev = 8;
+              _context.t0 = _context["catch"](0);
+
+              if (!_context.t0.isAxiosError) {
+                _context.next = 18;
+                break;
+              }
+
+              code = (_e$response = _context.t0.response) == null ? void 0 : _e$response.status;
+              _context.t1 = code;
+              _context.next = _context.t1 === 400 ? 15 : _context.t1 === 500 ? 16 : _context.t1 === 401 ? 17 : 17;
+              break;
+
+            case 15:
+              throw new AuthenticationBadRequest();
+
+            case 16:
+              throw new AuthenticationServerError();
+
+            case 17:
+              throw new AuthenticationFailed();
+
+            case 18:
+              throw new AuthenticationFailed();
+
+            case 19:
+              return _context.abrupt("return", resp);
+
+            case 20:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this, [[0, 8]]);
+    }));
+
+    function authToken(_x) {
+      return _authToken.apply(this, arguments);
+    }
+
+    return authToken;
+  }()
+  /**
+   * Get new access and refresh token
+   *
+   * @returns AuthTokenResponse
+   */
+  ;
+
+  _proto.authRefresh =
+  /*#__PURE__*/
+  function () {
+    var _authRefresh = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(refreshToken) {
+      var config;
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              config = {
+                skipAuthRefresh: true,
+                useRefreshToken: true
+              };
+              return _context2.abrupt("return", this.api.put(this.baseURL + "/v1/auth/token", null, config));
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function authRefresh(_x2) {
+      return _authRefresh.apply(this, arguments);
+    }
+
+    return authRefresh;
+  }()
+  /**
+   * Call guard to overwrite existing refresh token cookie
+   *
+   * @returns void
+   */
+  ;
+
+  _proto.authLogout =
+  /*#__PURE__*/
+  function () {
+    var _authLogout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3() {
+      return runtime_1.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              return _context3.abrupt("return", this.api.get(this.baseURL + "/v1/auth/logout"));
+
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function authLogout() {
+      return _authLogout.apply(this, arguments);
+    }
+
+    return authLogout;
+  }()
+  /**
+   * Call guard to attempt account recovery
+   *
+   * @param req The email address / practice of the account to recover
+   * @returns void
+   */
+  ;
+
+  _proto.authRecover =
+  /*#__PURE__*/
+  function () {
+    var _authRecover = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(req) {
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", this.api.post(this.baseURL + "/v1/auth/recover", req));
+
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, this);
+    }));
+
+    function authRecover(_x3) {
+      return _authRecover.apply(this, arguments);
+    }
+
+    return authRecover;
+  }()
+  /**
+   * Allow to create a new identity. The identity will then need to be confirmed
+   * via an email link
+   *
+   * @param req the information about the new identity to create
+   * @returns IdentityResponse
+   */
+  ;
+
+  _proto.identityCreate =
+  /*#__PURE__*/
+  function () {
+    var _identityCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(req) {
+      var resp, _e$response2, code;
+
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _context5.prev = 0;
+              _context5.next = 3;
+              return this.api.post(this.baseURL + "/v1/identities", req);
+
+            case 3:
+              resp = _context5.sent;
+              this.api.setTokens({
+                refreshToken: resp.refreshToken
+              });
+              _context5.next = 18;
+              break;
+
+            case 7:
+              _context5.prev = 7;
+              _context5.t0 = _context5["catch"](0);
+
+              if (!_context5.t0.isAxiosError) {
+                _context5.next = 17;
+                break;
+              }
+
+              code = (_e$response2 = _context5.t0.response) == null ? void 0 : _e$response2.status;
+              _context5.t1 = code;
+              _context5.next = _context5.t1 === 400 ? 14 : _context5.t1 === 409 ? 15 : _context5.t1 === 500 ? 16 : 16;
+              break;
+
+            case 14:
+              throw new IdentityCreationBadRequest();
+
+            case 15:
+              throw new IdentityCreationConflict();
+
+            case 16:
+              throw new IdentityCreationFailed();
+
+            case 17:
+              throw new IdentityCreationFailed();
+
+            case 18:
+              return _context5.abrupt("return", resp);
+
+            case 19:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this, [[0, 7]]);
+    }));
+
+    function identityCreate(_x4) {
+      return _identityCreate.apply(this, arguments);
+    }
+
+    return identityCreate;
+  }()
+  /**
+   * Retrieve an identity. Will return public fields only when requested
+   * without authentication
+   *
+   * @param identityID Unique id of the identity to retrieve
+   * @returns IdentityResponse
+   */
+  ;
+
+  _proto.identityGet =
+  /*#__PURE__*/
+  function () {
+    var _identityGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(identityID) {
+      var _tokens$accessToken, _tokens$refreshToken;
+
+      var tokens, cacheKey;
+      return runtime_1.wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              tokens = this.api.getTokens();
+              cacheKey = ((_tokens$accessToken = tokens.accessToken) != null ? _tokens$accessToken : '') + ((_tokens$refreshToken = tokens.refreshToken) != null ? _tokens$refreshToken : '') + identityID;
+
+              if (!(!tokens.accessToken || !this.identityCache[cacheKey])) {
+                _context6.next = 6;
+                break;
+              }
+
+              _context6.next = 5;
+              return this.api.get(this.baseURL + "/v1/identities/" + identityID);
+
+            case 5:
+              this.identityCache[cacheKey] = _context6.sent;
+
+            case 6:
+              return _context6.abrupt("return", this.identityCache[cacheKey]);
+
+            case 7:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, this);
+    }));
+
+    function identityGet(_x5) {
+      return _identityGet.apply(this, arguments);
+    }
+
+    return identityGet;
+  }()
+  /**
+   * Get information about the current authenticated user
+   *
+   * @param refreshCache if true it will refresh the whoAmI cache (default: false)
+   * @returns WhoAmIResponse
+   */
+  ;
+
+  _proto.whoAmI =
+  /*#__PURE__*/
+  function () {
+    var _whoAmI = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(refreshCache) {
+      var _this$api$getTokens$a;
+
+      var cacheKey;
+      return runtime_1.wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              if (refreshCache === void 0) {
+                refreshCache = false;
+              }
+
+              cacheKey = (_this$api$getTokens$a = this.api.getTokens().accessToken) != null ? _this$api$getTokens$a : '';
+
+              if (!(!this.whoAmICache[cacheKey] || refreshCache)) {
+                _context7.next = 6;
+                break;
+              }
+
+              _context7.next = 5;
+              return this.api.get(this.baseURL + "/v1/auth/whoami");
+
+            case 5:
+              this.whoAmICache[cacheKey] = _context7.sent;
+
+            case 6:
+              return _context7.abrupt("return", this.whoAmICache[cacheKey]);
+
+            case 7:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7, this);
+    }));
+
+    function whoAmI(_x6) {
+      return _whoAmI.apply(this, arguments);
+    }
+
+    return whoAmI;
+  }()
+  /**
+   * Update an existing identity
+   *
+   * @param identityID unique id of identity to update
+   * @param req update request
+   * @returns IdentityResponse
+   */
+  ;
+
+  _proto.identityUpdate =
+  /*#__PURE__*/
+  function () {
+    var _identityUpdate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(identityID, req) {
+      return runtime_1.wrap(function _callee8$(_context8) {
+        while (1) {
+          switch (_context8.prev = _context8.next) {
+            case 0:
+              return _context8.abrupt("return", this.api.put(this.baseURL + "/v1/identities/" + identityID, req));
+
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }
+      }, _callee8, this);
+    }));
+
+    function identityUpdate(_x7, _x8) {
+      return _identityUpdate.apply(this, arguments);
+    }
+
+    return identityUpdate;
+  }()
+  /**
+   * Return base64 data representing a QR code that the
+   * current identity need in order to use MFA
+   *
+   * @param identityID unique id of the identity
+   * @param password the identity password (already hashed and in base64)
+   * @returns QRCodeResponse
+   */
+  ;
+
+  _proto.identityMFAQRCode =
+  /*#__PURE__*/
+  function () {
+    var _identityMFAQRCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(identityID, password) {
+      var req;
+      return runtime_1.wrap(function _callee9$(_context9) {
+        while (1) {
+          switch (_context9.prev = _context9.next) {
+            case 0:
+              req = {
+                password: password
+              };
+              return _context9.abrupt("return", this.api.post(this.baseURL + "/v1/identities/" + identityID + "/mfa", req, {
+                headers: {
+                  'Accept': 'application/json'
+                }
+              }));
+
+            case 2:
+            case "end":
+              return _context9.stop();
+          }
+        }
+      }, _callee9, this);
+    }));
+
+    function identityMFAQRCode(_x9, _x10) {
+      return _identityMFAQRCode.apply(this, arguments);
+    }
+
+    return identityMFAQRCode;
+  }();
+
+  return GuardService;
+}();
+
+var PracticeService = /*#__PURE__*/function () {
+  function PracticeService(api, baseURL) {
+    this.api = api;
+    this.baseURL = baseURL;
+  }
+  /**
+   * This function get the practice from the URL of a practice
+   * It is the entry point of our web apps
+   * @param practiceURL URL of the practice to search
+   * @param hydratePracticeConfigs (optional) if set true it the Practice field configs will be set
+   * @param accounts (optional) if set true it the Practice field accounts will be set
+   * @returns the found practice or undefined
+   */
+
+
+  var _proto = PracticeService.prototype;
+
+  _proto.practiceGetFromURL = function practiceGetFromURL(practiceURL, params) {
+    return this.api.get(this.baseURL + "/v1/practices", {
+      params: _extends({
+        url_practice: practiceURL
+      }, params)
+    });
+  };
+
+  _proto.practiceGetFromUuid = function practiceGetFromUuid(practiceUuid, locale, withAccounts) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid, {
+      params: {
+        locale: locale,
+        accounts: withAccounts
+      }
+    });
+  } /// Practice Configs
+
+  /**
+   * This function retrieves all configs of a specific practice
+   * @param practiceUuid uuid of the practice
+   * @returns the practice configs
+   */
+  ;
+
+  _proto.practiceConfigGetFromPracticeUuid = function practiceConfigGetFromPracticeUuid(practiceUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/configs");
+  }
+  /**
+   * This function retrieves a specific config of a practice
+   * @param practiceUuid uuid of the practice
+   * @param kind of the config
+   * @returns the practice config
+   */
+  ;
+
+  _proto.practiceConfigGetByKindForPracticeUuid = function practiceConfigGetByKindForPracticeUuid(practiceUuid, kind) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/configs/" + kind);
+  }
+  /**
+   * This function creates a config for a specific practice
+   * @param practiceUuid uuid of the practice
+   * @param config the config to add to the practice
+   * @returns the created practice config
+   */
+  ;
+
+  _proto.practiceConfigCreateForPracticeUuid = function practiceConfigCreateForPracticeUuid(practiceUuid, config) {
+    return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/configs", config);
+  }
+  /**
+   * This function updates a specific config of a practice
+   * @param practiceUuid uuid of the practice
+   * @param config the config to update
+   * @returns the practice config
+   */
+  ;
+
+  _proto.practiceConfigUpdate = function practiceConfigUpdate(config) {
+    return this.api.put(this.baseURL + "/v1/practices/" + config.uuidPractice + "/configs/" + config.kind, config);
+  } /// Accounts
+  ;
+
+  _proto.practiceGetAccounts = function practiceGetAccounts(practiceUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/accounts");
+  };
+
+  _proto.practiceGetAccount = function practiceGetAccount(practiceUuid, accountUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/accounts/" + accountUuid);
+  } /// Workflows
+  ;
+
+  _proto.practiceGetWorkflows = function practiceGetWorkflows(practiceUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/workflows");
+  };
+
+  _proto.practiceGetWorkflow = function practiceGetWorkflow(practiceUuid, workflowType) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/workflows/" + workflowType);
+  } /// Plans
+  ;
+
+  _proto.practiceGetPlans = function practiceGetPlans(practiceUuid, planType) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/plans", {
+      params: {
+        kind: planType
+      }
+    });
+  };
+
+  _proto.practiceGetPlan = function practiceGetPlan(practiceUuid, planId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/plans/" + planId);
+  };
+
+  _proto.practiceGetPlanPrices = function practiceGetPlanPrices(practiceUuid, planId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/plans/" + planId + "/prices");
+  } // Payments
+  ;
+
+  _proto.practiceGetPayments = function practiceGetPayments(practiceUuid, planType) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments", {
+      params: {
+        kind: planType
+      }
+    });
+  };
+
+  _proto.practiceGetPayment = function practiceGetPayment(practiceUuid, idStripeInvoiceOrPaymentIntent) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/" + idStripeInvoiceOrPaymentIntent);
+  };
+
+  _proto.practiceGetPaymentForStripePaymentIntentWithID = function practiceGetPaymentForStripePaymentIntentWithID(practiceUuid, stripePaymentIntentId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/" + stripePaymentIntentId);
+  } // Payments Intent
+  ;
+
+  _proto.practiceGetPaymentsIntents = function practiceGetPaymentsIntents(practiceUuid, planType) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/intents", {
+      params: {
+        kind: planType
+      }
+    });
+  }
+  /**
+   * This function return the user hased email to be use for creating payment intent
+   * @param email the email to hash
+   * @returns a hashed email
+   */
+  ;
+
+  _proto.getPaymentIntentHashedEmail = function getPaymentIntentHashedEmail(email) {
+    return _.Buffer.from(hash_js.sha256().update(email.toLowerCase()).digest('hex'), 'hex').toString('base64');
+  };
+
+  _proto.practiceCreatePaymentsIntent = function practiceCreatePaymentsIntent(practiceUuid, planId, userEmail, isoLocality, url_subdomain, promotionCode) {
+    return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/intents/", {
+      idPlan: planId,
+      hashUserEmail: userEmail ? this.getPaymentIntentHashedEmail(userEmail) : undefined,
+      isoLocality: isoLocality
+    }, {
+      params: {
+        url_subdomain: url_subdomain,
+        promotionCode: promotionCode
+      }
+    });
+  };
+
+  _proto.practiceGetPaymentsIntent = function practiceGetPaymentsIntent(practiceUuid, paymentIntentId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/intents/" + paymentIntentId);
+  };
+
+  _proto.practiceUpdatePaymentsIntent = function practiceUpdatePaymentsIntent(practiceUuid, idPraticePaymentIntent, practicePaymentIntent, userEmail, promotionCode) {
+    return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/intents/" + idPraticePaymentIntent, _extends({}, practicePaymentIntent, {
+      hashUserEmail: userEmail ? this.getPaymentIntentHashedEmail(userEmail) : undefined
+    }), {
+      params: {
+        promotionCode: promotionCode
+      }
+    });
+  } // Practitioner
+  ;
+
+  _proto.practiceGetPractitioners = function practiceGetPractitioners(practiceUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners");
+  };
+
+  _proto.practiceUpdatePractitioner = function practiceUpdatePractitioner(practiceUuid, practitionerUuid, requestBody) {
+    return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid, requestBody);
+  };
+
+  _proto.practiceGetPractitioner = function practiceGetPractitioner(practiceUuid, practitionerUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid);
+  } // Practitioner Licenses
+  ;
+
+  _proto.practiceGetPractitionerLicenses = function practiceGetPractitionerLicenses(practiceUuid, practitionerUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/licenses");
+  };
+
+  _proto.practiceCreatePractitionerLicense = function practiceCreatePractitionerLicense(practiceUuid, practitionerUuid, requestBody) {
+    return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/licenses", requestBody);
+  };
+
+  _proto.practiceUpdatePractitionerLicense = function practiceUpdatePractitionerLicense(practiceUuid, practitionerUuid, licenseId, requestBody) {
+    return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/licenses/" + licenseId, requestBody);
+  };
+
+  _proto.practiceGetPractitionerLicense = function practiceGetPractitionerLicense(practiceUuid, practitionerUuid, licenseId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/licenses/" + licenseId);
+  } // Practitioner Preferences
+  ;
+
+  _proto.practiceGetPractitionerPreferences = function practiceGetPractitionerPreferences(practiceUuid, practitionerUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/preferences");
+  };
+
+  _proto.practiceCreatePractitionerPreference = function practiceCreatePractitionerPreference(practiceUuid, practitionerUuid, requestBody) {
+    return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/preferences", requestBody);
+  };
+
+  _proto.practiceUpdatePractitionerPreference = function practiceUpdatePractitionerPreference(practiceUuid, practitionerUuid, preferenceId, requestBody) {
+    return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/preferences/" + preferenceId, requestBody);
+  };
+
+  _proto.practiceGetPractitionerPreference = function practiceGetPractitionerPreference(practiceUuid, practitionerUuid, preferenceId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/preferences/" + preferenceId);
+  } // Practitioner Roles
+  ;
+
+  _proto.practiceGetPractitionerRoles = function practiceGetPractitionerRoles(practiceUuid, practitionerUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles");
+  };
+
+  _proto.practiceCreatePractitionerRole = function practiceCreatePractitionerRole(practiceUuid, practitionerUuid, requestBody) {
+    return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles", requestBody);
+  };
+
+  _proto.practiceDeletePractitionerRoles = function practiceDeletePractitionerRoles(practiceUuid, practitionerUuid) {
+    return this.api.deleteRequest(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles");
+  };
+
+  _proto.practiceUpdatePractitionerRole = function practiceUpdatePractitionerRole(practiceUuid, practitionerUuid, roleId, requestBody) {
+    return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles/" + roleId, requestBody);
+  };
+
+  _proto.practiceGetPractitionerRole = function practiceGetPractitionerRole(practiceUuid, practitionerUuid, roleId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles/" + roleId);
+  };
+
+  _proto.practiceDeletePractitionerRole = function practiceDeletePractitionerRole(practiceUuid, practitionerUuid, roleId) {
+    return this.api.deleteRequest(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles/" + roleId);
+  } // Practitioner signature
+
+  /**
+   * This function returns the practitioner's signature as a Blob
+   * @param practiceUuid the practice uuid of the practitioner
+   * @param practitionerUuid the practitioner uuid
+   * @returns a blob representing the signature
+   */
+  ;
+
+  _proto.practiceGetPractitionerSignature = function practiceGetPractitionerSignature(practiceUuid, practitionerUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/signature", {
+      responseType: 'blob'
+    });
+  } // Assignments
+  ;
+
+  _proto.practiceGetAssignments = function practiceGetAssignments(practiceUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/assignments");
+  };
+
+  _proto.practiceCreateAssignment = function practiceCreateAssignment(practiceUuid, requestBody) {
+    return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/assignments", requestBody);
+  };
+
+  _proto.practiceUpdateAssignment = function practiceUpdateAssignment(practiceUuid, assignmentId, requestBody) {
+    return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/assignments/" + assignmentId, requestBody);
+  };
+
+  _proto.practiceGetAssignment = function practiceGetAssignment(practiceUuid, assignmentId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/assignments/" + assignmentId);
+  } // Quotas
+  ;
+
+  _proto.practiceGetQuotas = function practiceGetQuotas(practiceUuid) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/quotas");
+  };
+
+  _proto.practiceGetQuota = function practiceGetQuota(practiceUuid, quotaId) {
+    return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/quotas/" + quotaId);
+  };
+
+  return PracticeService;
+}();
+
+var TellerService = /*#__PURE__*/function () {
+  function TellerService(api, baseURL) {
+    this.api = api;
+    this.baseURL = baseURL;
+  }
+
+  var _proto = TellerService.prototype;
+
+  _proto.lockboxDataStore = /*#__PURE__*/function () {
+    var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", this.api.post(this.baseURL + "/v1/lockboxes/" + lockboxUuid + "/data", req, {
+                params: {
+                  lockbox_owner_uuid: lockboxOwnerUuid,
+                  data_uuid: previousDataUuid
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function lockboxDataStore(_x, _x2, _x3, _x4) {
+      return _lockboxDataStore.apply(this, arguments);
+    }
+
+    return lockboxDataStore;
+  }();
+
+  _proto.updateConsultByUUID = function updateConsultByUUID(patientUuid, uuidConsult, statusMedical, neverExpires) {
+    return this.api.put(this.baseURL + "/v1/consults/" + uuidConsult, {
+      patientUuid: patientUuid,
+      statusMedical: statusMedical,
+      neverExpires: neverExpires
+    });
+  };
+
+  return TellerService;
+}();
+
+var VaultService = /*#__PURE__*/function () {
+  function VaultService(api, baseURL) {
+    this.api = api;
+    this.baseURL = baseURL;
+  }
+
+  var _proto = VaultService.prototype;
+
+  _proto.lockboxCreate = /*#__PURE__*/function () {
+    var _lockboxCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(lockboxMetadata) {
+      return runtime_1.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", this.api.post(this.baseURL + "/v1/lockbox", lockboxMetadata));
+
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee, this);
+    }));
+
+    function lockboxCreate(_x) {
+      return _lockboxCreate.apply(this, arguments);
+    }
+
+    return lockboxCreate;
+  }();
+
+  _proto.lockboxMetadataAdd = /*#__PURE__*/function () {
+    var _lockboxMetadataAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(lockboxUuid, lockboxMetadata, lockboxOwnerUuid) {
+      return runtime_1.wrap(function _callee2$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              return _context2.abrupt("return", this.api.put(this.baseURL + "/v1/lockbox/" + lockboxUuid, lockboxMetadata, {
+                params: {
+                  lockbox_owner_uuid: lockboxOwnerUuid
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, _callee2, this);
+    }));
+
+    function lockboxMetadataAdd(_x2, _x3, _x4) {
+      return _lockboxMetadataAdd.apply(this, arguments);
+    }
+
+    return lockboxMetadataAdd;
+  }();
+
+  _proto.lockboxSecretGet = /*#__PURE__*/function () {
+    var _lockboxSecretGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(lockboxUuid, lockboxOwnerUuid) {
+      return runtime_1.wrap(function _callee3$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              return _context3.abrupt("return", this.api.get(this.baseURL + "/v1/lockboxes/" + lockboxUuid + "/secret", {
+                params: {
+                  lockbox_owner_uuid: lockboxOwnerUuid
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, _callee3, this);
+    }));
+
+    function lockboxSecretGet(_x5, _x6) {
+      return _lockboxSecretGet.apply(this, arguments);
+    }
+
+    return lockboxSecretGet;
+  }();
+
+  _proto.lockboxGrant = /*#__PURE__*/function () {
+    var _lockboxGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(lockboxUuid, req, lockboxOwnerUuid) {
+      return runtime_1.wrap(function _callee4$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              return _context4.abrupt("return", this.api.post(this.baseURL + "/v1/lockboxes/" + lockboxUuid + "/grant", req, {
+                params: {
+                  lockbox_owner_uuid: lockboxOwnerUuid
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, _callee4, this);
+    }));
+
+    function lockboxGrant(_x7, _x8, _x9) {
+      return _lockboxGrant.apply(this, arguments);
+    }
+
+    return lockboxGrant;
+  }()
+  /**
+   * Get all lockboxes granted to user
+   * @param filter filter of lockbox metadata
+   * @returns decrypted lockboxes granted to user
+   */
+  ;
+
+  _proto.grantsGet =
+  /*#__PURE__*/
+  function () {
+    var _grantsGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5() {
+      return runtime_1.wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              return _context5.abrupt("return", this.api.get(this.baseURL + "/v1/grants"));
+
+            case 1:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5, this);
+    }));
+
+    function grantsGet() {
+      return _grantsGet.apply(this, arguments);
+    }
+
+    return grantsGet;
+  }()
+  /**
+   * This function create or update a data into the vault.
+   * @note At creation it is necessary to have all `req` filled
+   * @note When setting `previousDataUuid` you are updating the data. `req` metadata fields are optional.
+   * @param lockboxUuid The lockbox uuid the data will be stored in
+   * @param req The request (please see notes)
+   * @param lockboxOwnerUuid The uuid of the owner of the lockbox (@deprecated)
+   * @param previousDataUuid The data uuid of the data you want to update
+   * @returns
+   */
+  ;
+
+  _proto.lockboxDataStore =
+  /*#__PURE__*/
+  function () {
+    var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
+      return runtime_1.wrap(function _callee6$(_context6) {
+        while (1) {
+          switch (_context6.prev = _context6.next) {
+            case 0:
+              return _context6.abrupt("return", this.api.post(this.baseURL + "/v1/lockboxes/" + lockboxUuid + "/data", req, {
+                params: {
+                  lockbox_owner_uuid: lockboxOwnerUuid,
+                  data_uuid: previousDataUuid
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context6.stop();
+          }
+        }
+      }, _callee6, this);
+    }));
+
+    function lockboxDataStore(_x10, _x11, _x12, _x13) {
+      return _lockboxDataStore.apply(this, arguments);
+    }
+
+    return lockboxDataStore;
+  }();
+
+  _proto.lockboxDataGet = /*#__PURE__*/function () {
+    var _lockboxDataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(lockboxUuid, dataUuid, lockboxOwnerUuid, stream) {
+      var data;
+      return runtime_1.wrap(function _callee7$(_context7) {
+        while (1) {
+          switch (_context7.prev = _context7.next) {
+            case 0:
+              if (stream === void 0) {
+                stream = true;
+              }
+
+              _context7.next = 3;
+              return this.api.get(this.baseURL + "/v1/lockboxes/" + lockboxUuid + "/data/" + dataUuid, {
+                params: {
+                  lockbox_owner_uuid: lockboxOwnerUuid,
+                  stream: stream
+                }
+              });
+
+            case 3:
+              data = _context7.sent;
+
+              if (!stream) {
+                _context7.next = 6;
+                break;
+              }
+
+              return _context7.abrupt("return", {
+                data: data
+              });
+
+            case 6:
+              return _context7.abrupt("return", data);
+
+            case 7:
+            case "end":
+              return _context7.stop();
+          }
+        }
+      }, _callee7, this);
+    }));
+
+    function lockboxDataGet(_x14, _x15, _x16, _x17) {
+      return _lockboxDataGet.apply(this, arguments);
+    }
+
+    return lockboxDataGet;
+  }();
+
+  _proto.lockboxManifestGet = /*#__PURE__*/function () {
+    var _lockboxManifestGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(lockboxUuid, filter, lockboxOwnerUuid) {
+      return runtime_1.wrap(function _callee8$(_context8) {
+        while (1) {
+          switch (_context8.prev = _context8.next) {
+            case 0:
+              return _context8.abrupt("return", this.api.get(this.baseURL + "/v1/lockboxes/" + lockboxUuid, {
+                params: {
+                  lockbox_owner_uuid: lockboxOwnerUuid,
+                  filter: filter
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context8.stop();
+          }
+        }
+      }, _callee8, this);
+    }));
+
+    function lockboxManifestGet(_x18, _x19, _x20) {
+      return _lockboxManifestGet.apply(this, arguments);
+    }
+
+    return lockboxManifestGet;
+  }();
+
+  _proto.lockboxMetadataGet = /*#__PURE__*/function () {
+    var _lockboxMetadataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(lockboxUuid, fields, groupby, filter, lockboxOwnerUuid) {
+      return runtime_1.wrap(function _callee9$(_context9) {
+        while (1) {
+          switch (_context9.prev = _context9.next) {
+            case 0:
+              return _context9.abrupt("return", this.api.get(this.baseURL + "/v1/lockboxes/" + lockboxUuid + "/metadata", {
+                params: {
+                  lockbox_owner_uuid: lockboxOwnerUuid,
+                  fields: fields,
+                  groupby: groupby,
+                  filter: filter
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context9.stop();
+          }
+        }
+      }, _callee9, this);
+    }));
+
+    function lockboxMetadataGet(_x21, _x22, _x23, _x24, _x25) {
+      return _lockboxMetadataGet.apply(this, arguments);
+    }
+
+    return lockboxMetadataGet;
+  }()
+  /**
+   * inserts or updates encrypted index entries
+   * @note if the index data is being inserted for a user other than the requester, use `indexOwnerUuid`
+   * @note if a uuid for an entry is provided, the service will perform an update
+   * @param entries the encrypted index data
+   * @param indexOwnerUuid
+   */
+  ;
+
+  _proto.vaultIndexPut =
+  /*#__PURE__*/
+  function () {
+    var _vaultIndexPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(entries, indexOwnerUuid) {
+      return runtime_1.wrap(function _callee10$(_context10) {
+        while (1) {
+          switch (_context10.prev = _context10.next) {
+            case 0:
+              return _context10.abrupt("return", this.api.put(this.baseURL + "/v1/index", entries, {
+                params: {
+                  index_owner_uuid: indexOwnerUuid
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context10.stop();
+          }
+        }
+      }, _callee10, this);
+    }));
+
+    function vaultIndexPut(_x26, _x27) {
+      return _vaultIndexPut.apply(this, arguments);
+    }
+
+    return vaultIndexPut;
+  }()
+  /**
+   * inserts or updates index snapshot for the provided index owner
+   * @note if the index data is being inserted for a user other than the requester, use `indexOwnerUuid`
+   * @param entry the encrypted index snapshot
+   */
+  ;
+
+  _proto.vaultIndexSnapshotPut =
+  /*#__PURE__*/
+  function () {
+    var _vaultIndexSnapshotPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(entry) {
+      return runtime_1.wrap(function _callee11$(_context11) {
+        while (1) {
+          switch (_context11.prev = _context11.next) {
+            case 0:
+              return _context11.abrupt("return", this.api.put(this.baseURL + "/v1/index-snapshot", entry));
+
+            case 1:
+            case "end":
+              return _context11.stop();
+          }
+        }
+      }, _callee11, this);
+    }));
+
+    function vaultIndexSnapshotPut(_x28) {
+      return _vaultIndexSnapshotPut.apply(this, arguments);
+    }
+
+    return vaultIndexSnapshotPut;
+  }()
+  /**
+   * Retrieves the encrypted index from the vault for the requesting user
+   * @note index keys can be specified to narrow the scope of index being requested
+   * @param indexKeys accepted index fields determined by vault
+   * @param identifiers: an array of unique_hashes or consultation uuids used to identify an index entry
+   * @param timestamp the minimum timestamp that index entries were created
+   * @returns the encrypted index
+   */
+  ;
+
+  _proto.vaultIndexGet =
+  /*#__PURE__*/
+  function () {
+    var _vaultIndexGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(indexKeys, identifiers, timestamp) {
+      return runtime_1.wrap(function _callee12$(_context12) {
+        while (1) {
+          switch (_context12.prev = _context12.next) {
+            case 0:
+              return _context12.abrupt("return", this.api.get(this.baseURL + "/v1/index", {
+                params: {
+                  index_keys: indexKeys,
+                  identifiers: identifiers,
+                  timestamp: timestamp
+                }
+              }));
+
+            case 1:
+            case "end":
+              return _context12.stop();
+          }
+        }
+      }, _callee12, this);
+    }));
+
+    function vaultIndexGet(_x29, _x30, _x31) {
+      return _vaultIndexGet.apply(this, arguments);
+    }
+
+    return vaultIndexGet;
+  }();
+
+  return VaultService;
+}();
+
+var WorkflowService = /*#__PURE__*/function () {
+  function WorkflowService(api, url) {
+    this.api = api;
+    this.v1Url = url + "/v1";
+  }
+  /**
+   * This function returns all workflows
+   * @returns desired workflow
+   */
+
+
+  var _proto = WorkflowService.prototype;
+
+  _proto.getWorkflows = function getWorkflows() {
+    return this.api.get(this.v1Url + "/workflows");
+  }
+  /**
+   * This function retrieves a workflow. If `locale` is not found, it will try to find 'en' version of it.
+   * By default, will return most recent workflow of a specific `id`. `createdAt` can be used to select older version.
+   * @param id The uuid of the workflow
+   * @param locale (optional) The desired locale of the workflow (default: 'en')
+   * @param createdAt (optional) The creation date of the workflow (also used for versionning)
+   * @returns desired workflow
+   */
+  ;
+
+  _proto.getWorkflow = function getWorkflow(id, locale, createdAt) {
+    return this.api.get(this.v1Url + "/workflows/" + id, {
+      params: {
+        locale: locale,
+        createdAt: createdAt
+      }
+    });
+  };
+
+  return WorkflowService;
+}();
+
+/**
+ * This function is used to initialize services with a provided url
+ * @param services an object containing the url of the services to init
+ * @param (optional) authenticationCallback the authentification callback
+ * @returns an instance of each services with a provided url
+ */
+
+var init = function init(services, authenticationCallback) {
+  var tellerBaseURL = services.tellerBaseURL,
+      practiceBaseURL = services.practiceBaseURL,
+      consultBaseURL = services.consultBaseURL,
+      vaultBaseURL = services.vaultBaseURL,
+      guardBaseURL = services.guardBaseURL,
+      workflowBaseURL = services.workflowBaseURL,
+      diagnosisBaseURL = services.diagnosisBaseURL;
+  var apiService = new APIService(undefined, authenticationCallback);
+  return {
+    tellerService: tellerBaseURL ? new TellerService(apiService, tellerBaseURL) : undefined,
+    practiceService: practiceBaseURL ? new PracticeService(apiService, practiceBaseURL) : undefined,
+    consultService: consultBaseURL ? new ConsultService(apiService, consultBaseURL) : undefined,
+    vaultService: vaultBaseURL ? new VaultService(apiService, vaultBaseURL) : undefined,
+    guardService: guardBaseURL ? new GuardService(apiService, guardBaseURL) : undefined,
+    workflowService: workflowBaseURL ? new WorkflowService(apiService, workflowBaseURL) : undefined,
+    diagnosisService: diagnosisBaseURL ? new DiagnosisService(apiService, diagnosisBaseURL) : undefined
+  };
+};
+
+exports.APIService = APIService;
+exports.AuthenticationBadRequest = AuthenticationBadRequest;
+exports.AuthenticationFailed = AuthenticationFailed;
+exports.AuthenticationServerError = AuthenticationServerError;
+exports.AxiosService = AxiosService;
+exports.ConsultService = ConsultService;
+exports.DiagnosisService = DiagnosisService;
+exports.GuardService = GuardService;
+exports.IdentityCreationBadRequest = IdentityCreationBadRequest;
+exports.IdentityCreationConflict = IdentityCreationConflict;
+exports.IdentityCreationFailed = IdentityCreationFailed;
+exports.PracticeService = PracticeService;
+exports.TellerService = TellerService;
+exports.VaultService = VaultService;
+exports.WorkflowService = WorkflowService;
+exports.default = init;
+//# sourceMappingURL=oro-sdk-apis.cjs.development.js.map