oro-sdk-apis 3.2.7 → 3.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -14,301 +14,11 @@ var axios = _interopDefault(require('axios'));
14
14
  * @param value the string to hash
15
15
  * @returns a base64 string representation of a hashed value
16
16
  */
17
+
17
18
  function hashToBase64String(value) {
18
19
  return _.Buffer.from(hash_js.sha256().update(value).digest('hex'), 'hex').toString('base64');
19
20
  }
20
21
 
21
- function _regeneratorRuntime() {
22
- _regeneratorRuntime = function () {
23
- return exports;
24
- };
25
- var exports = {},
26
- Op = Object.prototype,
27
- hasOwn = Op.hasOwnProperty,
28
- $Symbol = "function" == typeof Symbol ? Symbol : {},
29
- iteratorSymbol = $Symbol.iterator || "@@iterator",
30
- asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
31
- toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
32
- function define(obj, key, value) {
33
- return Object.defineProperty(obj, key, {
34
- value: value,
35
- enumerable: !0,
36
- configurable: !0,
37
- writable: !0
38
- }), obj[key];
39
- }
40
- try {
41
- define({}, "");
42
- } catch (err) {
43
- define = function (obj, key, value) {
44
- return obj[key] = value;
45
- };
46
- }
47
- function wrap(innerFn, outerFn, self, tryLocsList) {
48
- var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
49
- generator = Object.create(protoGenerator.prototype),
50
- context = new Context(tryLocsList || []);
51
- return generator._invoke = function (innerFn, self, context) {
52
- var state = "suspendedStart";
53
- return function (method, arg) {
54
- if ("executing" === state) throw new Error("Generator is already running");
55
- if ("completed" === state) {
56
- if ("throw" === method) throw arg;
57
- return doneResult();
58
- }
59
- for (context.method = method, context.arg = arg;;) {
60
- var delegate = context.delegate;
61
- if (delegate) {
62
- var delegateResult = maybeInvokeDelegate(delegate, context);
63
- if (delegateResult) {
64
- if (delegateResult === ContinueSentinel) continue;
65
- return delegateResult;
66
- }
67
- }
68
- if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
69
- if ("suspendedStart" === state) throw state = "completed", context.arg;
70
- context.dispatchException(context.arg);
71
- } else "return" === context.method && context.abrupt("return", context.arg);
72
- state = "executing";
73
- var record = tryCatch(innerFn, self, context);
74
- if ("normal" === record.type) {
75
- if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
76
- return {
77
- value: record.arg,
78
- done: context.done
79
- };
80
- }
81
- "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
82
- }
83
- };
84
- }(innerFn, self, context), generator;
85
- }
86
- function tryCatch(fn, obj, arg) {
87
- try {
88
- return {
89
- type: "normal",
90
- arg: fn.call(obj, arg)
91
- };
92
- } catch (err) {
93
- return {
94
- type: "throw",
95
- arg: err
96
- };
97
- }
98
- }
99
- exports.wrap = wrap;
100
- var ContinueSentinel = {};
101
- function Generator() {}
102
- function GeneratorFunction() {}
103
- function GeneratorFunctionPrototype() {}
104
- var IteratorPrototype = {};
105
- define(IteratorPrototype, iteratorSymbol, function () {
106
- return this;
107
- });
108
- var getProto = Object.getPrototypeOf,
109
- NativeIteratorPrototype = getProto && getProto(getProto(values([])));
110
- NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
111
- var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
112
- function defineIteratorMethods(prototype) {
113
- ["next", "throw", "return"].forEach(function (method) {
114
- define(prototype, method, function (arg) {
115
- return this._invoke(method, arg);
116
- });
117
- });
118
- }
119
- function AsyncIterator(generator, PromiseImpl) {
120
- function invoke(method, arg, resolve, reject) {
121
- var record = tryCatch(generator[method], generator, arg);
122
- if ("throw" !== record.type) {
123
- var result = record.arg,
124
- value = result.value;
125
- return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
126
- invoke("next", value, resolve, reject);
127
- }, function (err) {
128
- invoke("throw", err, resolve, reject);
129
- }) : PromiseImpl.resolve(value).then(function (unwrapped) {
130
- result.value = unwrapped, resolve(result);
131
- }, function (error) {
132
- return invoke("throw", error, resolve, reject);
133
- });
134
- }
135
- reject(record.arg);
136
- }
137
- var previousPromise;
138
- this._invoke = function (method, arg) {
139
- function callInvokeWithMethodAndArg() {
140
- return new PromiseImpl(function (resolve, reject) {
141
- invoke(method, arg, resolve, reject);
142
- });
143
- }
144
- return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
145
- };
146
- }
147
- function maybeInvokeDelegate(delegate, context) {
148
- var method = delegate.iterator[context.method];
149
- if (undefined === method) {
150
- if (context.delegate = null, "throw" === context.method) {
151
- if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
152
- context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
153
- }
154
- return ContinueSentinel;
155
- }
156
- var record = tryCatch(method, delegate.iterator, context.arg);
157
- if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
158
- var info = record.arg;
159
- return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
160
- }
161
- function pushTryEntry(locs) {
162
- var entry = {
163
- tryLoc: locs[0]
164
- };
165
- 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
166
- }
167
- function resetTryEntry(entry) {
168
- var record = entry.completion || {};
169
- record.type = "normal", delete record.arg, entry.completion = record;
170
- }
171
- function Context(tryLocsList) {
172
- this.tryEntries = [{
173
- tryLoc: "root"
174
- }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
175
- }
176
- function values(iterable) {
177
- if (iterable) {
178
- var iteratorMethod = iterable[iteratorSymbol];
179
- if (iteratorMethod) return iteratorMethod.call(iterable);
180
- if ("function" == typeof iterable.next) return iterable;
181
- if (!isNaN(iterable.length)) {
182
- var i = -1,
183
- next = function next() {
184
- for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
185
- return next.value = undefined, next.done = !0, next;
186
- };
187
- return next.next = next;
188
- }
189
- }
190
- return {
191
- next: doneResult
192
- };
193
- }
194
- function doneResult() {
195
- return {
196
- value: undefined,
197
- done: !0
198
- };
199
- }
200
- return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
201
- var ctor = "function" == typeof genFun && genFun.constructor;
202
- return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
203
- }, exports.mark = function (genFun) {
204
- return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
205
- }, exports.awrap = function (arg) {
206
- return {
207
- __await: arg
208
- };
209
- }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
210
- return this;
211
- }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
212
- void 0 === PromiseImpl && (PromiseImpl = Promise);
213
- var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
214
- return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
215
- return result.done ? result.value : iter.next();
216
- });
217
- }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
218
- return this;
219
- }), define(Gp, "toString", function () {
220
- return "[object Generator]";
221
- }), exports.keys = function (object) {
222
- var keys = [];
223
- for (var key in object) keys.push(key);
224
- return keys.reverse(), function next() {
225
- for (; keys.length;) {
226
- var key = keys.pop();
227
- if (key in object) return next.value = key, next.done = !1, next;
228
- }
229
- return next.done = !0, next;
230
- };
231
- }, exports.values = values, Context.prototype = {
232
- constructor: Context,
233
- reset: function (skipTempReset) {
234
- if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
235
- },
236
- stop: function () {
237
- this.done = !0;
238
- var rootRecord = this.tryEntries[0].completion;
239
- if ("throw" === rootRecord.type) throw rootRecord.arg;
240
- return this.rval;
241
- },
242
- dispatchException: function (exception) {
243
- if (this.done) throw exception;
244
- var context = this;
245
- function handle(loc, caught) {
246
- return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
247
- }
248
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
249
- var entry = this.tryEntries[i],
250
- record = entry.completion;
251
- if ("root" === entry.tryLoc) return handle("end");
252
- if (entry.tryLoc <= this.prev) {
253
- var hasCatch = hasOwn.call(entry, "catchLoc"),
254
- hasFinally = hasOwn.call(entry, "finallyLoc");
255
- if (hasCatch && hasFinally) {
256
- if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
257
- if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
258
- } else if (hasCatch) {
259
- if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
260
- } else {
261
- if (!hasFinally) throw new Error("try statement without catch or finally");
262
- if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
263
- }
264
- }
265
- }
266
- },
267
- abrupt: function (type, arg) {
268
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
269
- var entry = this.tryEntries[i];
270
- if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
271
- var finallyEntry = entry;
272
- break;
273
- }
274
- }
275
- finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
276
- var record = finallyEntry ? finallyEntry.completion : {};
277
- return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
278
- },
279
- complete: function (record, afterLoc) {
280
- if ("throw" === record.type) throw record.arg;
281
- return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
282
- },
283
- finish: function (finallyLoc) {
284
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
285
- var entry = this.tryEntries[i];
286
- if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
287
- }
288
- },
289
- catch: function (tryLoc) {
290
- for (var i = this.tryEntries.length - 1; i >= 0; --i) {
291
- var entry = this.tryEntries[i];
292
- if (entry.tryLoc === tryLoc) {
293
- var record = entry.completion;
294
- if ("throw" === record.type) {
295
- var thrown = record.arg;
296
- resetTryEntry(entry);
297
- }
298
- return thrown;
299
- }
300
- }
301
- throw new Error("illegal catch attempt");
302
- },
303
- delegateYield: function (iterable, resultName, nextLoc) {
304
- return this.delegate = {
305
- iterator: values(iterable),
306
- resultName: resultName,
307
- nextLoc: nextLoc
308
- }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
309
- }
310
- }, exports;
311
- }
312
22
  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
313
23
  try {
314
24
  var info = gen[key](arg);
@@ -317,64 +27,80 @@ function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
317
27
  reject(error);
318
28
  return;
319
29
  }
30
+
320
31
  if (info.done) {
321
32
  resolve(value);
322
33
  } else {
323
34
  Promise.resolve(value).then(_next, _throw);
324
35
  }
325
36
  }
37
+
326
38
  function _asyncToGenerator(fn) {
327
39
  return function () {
328
40
  var self = this,
329
- args = arguments;
41
+ args = arguments;
330
42
  return new Promise(function (resolve, reject) {
331
43
  var gen = fn.apply(self, args);
44
+
332
45
  function _next(value) {
333
46
  asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
334
47
  }
48
+
335
49
  function _throw(err) {
336
50
  asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
337
51
  }
52
+
338
53
  _next(undefined);
339
54
  });
340
55
  };
341
56
  }
57
+
342
58
  function _extends() {
343
- _extends = Object.assign ? Object.assign.bind() : function (target) {
59
+ _extends = Object.assign || function (target) {
344
60
  for (var i = 1; i < arguments.length; i++) {
345
61
  var source = arguments[i];
62
+
346
63
  for (var key in source) {
347
64
  if (Object.prototype.hasOwnProperty.call(source, key)) {
348
65
  target[key] = source[key];
349
66
  }
350
67
  }
351
68
  }
69
+
352
70
  return target;
353
71
  };
72
+
354
73
  return _extends.apply(this, arguments);
355
74
  }
75
+
356
76
  function _inheritsLoose(subClass, superClass) {
357
77
  subClass.prototype = Object.create(superClass.prototype);
358
78
  subClass.prototype.constructor = subClass;
79
+
359
80
  _setPrototypeOf(subClass, superClass);
360
81
  }
82
+
361
83
  function _getPrototypeOf(o) {
362
- _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
84
+ _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
363
85
  return o.__proto__ || Object.getPrototypeOf(o);
364
86
  };
365
87
  return _getPrototypeOf(o);
366
88
  }
89
+
367
90
  function _setPrototypeOf(o, p) {
368
- _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
91
+ _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
369
92
  o.__proto__ = p;
370
93
  return o;
371
94
  };
95
+
372
96
  return _setPrototypeOf(o, p);
373
97
  }
98
+
374
99
  function _isNativeReflectConstruct() {
375
100
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
376
101
  if (Reflect.construct.sham) return false;
377
102
  if (typeof Proxy === "function") return true;
103
+
378
104
  try {
379
105
  Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
380
106
  return true;
@@ -382,9 +108,10 @@ function _isNativeReflectConstruct() {
382
108
  return false;
383
109
  }
384
110
  }
111
+
385
112
  function _construct(Parent, args, Class) {
386
113
  if (_isNativeReflectConstruct()) {
387
- _construct = Reflect.construct.bind();
114
+ _construct = Reflect.construct;
388
115
  } else {
389
116
  _construct = function _construct(Parent, args, Class) {
390
117
  var a = [null];
@@ -395,25 +122,34 @@ function _construct(Parent, args, Class) {
395
122
  return instance;
396
123
  };
397
124
  }
125
+
398
126
  return _construct.apply(null, arguments);
399
127
  }
128
+
400
129
  function _isNativeFunction(fn) {
401
130
  return Function.toString.call(fn).indexOf("[native code]") !== -1;
402
131
  }
132
+
403
133
  function _wrapNativeSuper(Class) {
404
134
  var _cache = typeof Map === "function" ? new Map() : undefined;
135
+
405
136
  _wrapNativeSuper = function _wrapNativeSuper(Class) {
406
137
  if (Class === null || !_isNativeFunction(Class)) return Class;
138
+
407
139
  if (typeof Class !== "function") {
408
140
  throw new TypeError("Super expression must either be null or a function");
409
141
  }
142
+
410
143
  if (typeof _cache !== "undefined") {
411
144
  if (_cache.has(Class)) return _cache.get(Class);
145
+
412
146
  _cache.set(Class, Wrapper);
413
147
  }
148
+
414
149
  function Wrapper() {
415
150
  return _construct(Class, arguments, _getPrototypeOf(this).constructor);
416
151
  }
152
+
417
153
  Wrapper.prototype = Object.create(Class.prototype, {
418
154
  constructor: {
419
155
  value: Wrapper,
@@ -424,24 +160,789 @@ function _wrapNativeSuper(Class) {
424
160
  });
425
161
  return _setPrototypeOf(Wrapper, Class);
426
162
  };
163
+
427
164
  return _wrapNativeSuper(Class);
428
165
  }
166
+
429
167
  function _assertThisInitialized(self) {
430
168
  if (self === void 0) {
431
169
  throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
432
170
  }
433
- return self;
171
+
172
+ return self;
173
+ }
174
+
175
+ function createCommonjsModule(fn, module) {
176
+ return module = { exports: {} }, fn(module, module.exports), module.exports;
177
+ }
178
+
179
+ var runtime_1 = createCommonjsModule(function (module) {
180
+ /**
181
+ * Copyright (c) 2014-present, Facebook, Inc.
182
+ *
183
+ * This source code is licensed under the MIT license found in the
184
+ * LICENSE file in the root directory of this source tree.
185
+ */
186
+
187
+ var runtime = (function (exports) {
188
+
189
+ var Op = Object.prototype;
190
+ var hasOwn = Op.hasOwnProperty;
191
+ var undefined$1; // More compressible than void 0.
192
+ var $Symbol = typeof Symbol === "function" ? Symbol : {};
193
+ var iteratorSymbol = $Symbol.iterator || "@@iterator";
194
+ var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
195
+ var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
196
+
197
+ function define(obj, key, value) {
198
+ Object.defineProperty(obj, key, {
199
+ value: value,
200
+ enumerable: true,
201
+ configurable: true,
202
+ writable: true
203
+ });
204
+ return obj[key];
205
+ }
206
+ try {
207
+ // IE 8 has a broken Object.defineProperty that only works on DOM objects.
208
+ define({}, "");
209
+ } catch (err) {
210
+ define = function(obj, key, value) {
211
+ return obj[key] = value;
212
+ };
213
+ }
214
+
215
+ function wrap(innerFn, outerFn, self, tryLocsList) {
216
+ // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
217
+ var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
218
+ var generator = Object.create(protoGenerator.prototype);
219
+ var context = new Context(tryLocsList || []);
220
+
221
+ // The ._invoke method unifies the implementations of the .next,
222
+ // .throw, and .return methods.
223
+ generator._invoke = makeInvokeMethod(innerFn, self, context);
224
+
225
+ return generator;
226
+ }
227
+ exports.wrap = wrap;
228
+
229
+ // Try/catch helper to minimize deoptimizations. Returns a completion
230
+ // record like context.tryEntries[i].completion. This interface could
231
+ // have been (and was previously) designed to take a closure to be
232
+ // invoked without arguments, but in all the cases we care about we
233
+ // already have an existing method we want to call, so there's no need
234
+ // to create a new function object. We can even get away with assuming
235
+ // the method takes exactly one argument, since that happens to be true
236
+ // in every case, so we don't have to touch the arguments object. The
237
+ // only additional allocation required is the completion record, which
238
+ // has a stable shape and so hopefully should be cheap to allocate.
239
+ function tryCatch(fn, obj, arg) {
240
+ try {
241
+ return { type: "normal", arg: fn.call(obj, arg) };
242
+ } catch (err) {
243
+ return { type: "throw", arg: err };
244
+ }
245
+ }
246
+
247
+ var GenStateSuspendedStart = "suspendedStart";
248
+ var GenStateSuspendedYield = "suspendedYield";
249
+ var GenStateExecuting = "executing";
250
+ var GenStateCompleted = "completed";
251
+
252
+ // Returning this object from the innerFn has the same effect as
253
+ // breaking out of the dispatch switch statement.
254
+ var ContinueSentinel = {};
255
+
256
+ // Dummy constructor functions that we use as the .constructor and
257
+ // .constructor.prototype properties for functions that return Generator
258
+ // objects. For full spec compliance, you may wish to configure your
259
+ // minifier not to mangle the names of these two functions.
260
+ function Generator() {}
261
+ function GeneratorFunction() {}
262
+ function GeneratorFunctionPrototype() {}
263
+
264
+ // This is a polyfill for %IteratorPrototype% for environments that
265
+ // don't natively support it.
266
+ var IteratorPrototype = {};
267
+ define(IteratorPrototype, iteratorSymbol, function () {
268
+ return this;
269
+ });
270
+
271
+ var getProto = Object.getPrototypeOf;
272
+ var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
273
+ if (NativeIteratorPrototype &&
274
+ NativeIteratorPrototype !== Op &&
275
+ hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
276
+ // This environment has a native %IteratorPrototype%; use it instead
277
+ // of the polyfill.
278
+ IteratorPrototype = NativeIteratorPrototype;
279
+ }
280
+
281
+ var Gp = GeneratorFunctionPrototype.prototype =
282
+ Generator.prototype = Object.create(IteratorPrototype);
283
+ GeneratorFunction.prototype = GeneratorFunctionPrototype;
284
+ define(Gp, "constructor", GeneratorFunctionPrototype);
285
+ define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
286
+ GeneratorFunction.displayName = define(
287
+ GeneratorFunctionPrototype,
288
+ toStringTagSymbol,
289
+ "GeneratorFunction"
290
+ );
291
+
292
+ // Helper for defining the .next, .throw, and .return methods of the
293
+ // Iterator interface in terms of a single ._invoke method.
294
+ function defineIteratorMethods(prototype) {
295
+ ["next", "throw", "return"].forEach(function(method) {
296
+ define(prototype, method, function(arg) {
297
+ return this._invoke(method, arg);
298
+ });
299
+ });
300
+ }
301
+
302
+ exports.isGeneratorFunction = function(genFun) {
303
+ var ctor = typeof genFun === "function" && genFun.constructor;
304
+ return ctor
305
+ ? ctor === GeneratorFunction ||
306
+ // For the native GeneratorFunction constructor, the best we can
307
+ // do is to check its .name property.
308
+ (ctor.displayName || ctor.name) === "GeneratorFunction"
309
+ : false;
310
+ };
311
+
312
+ exports.mark = function(genFun) {
313
+ if (Object.setPrototypeOf) {
314
+ Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
315
+ } else {
316
+ genFun.__proto__ = GeneratorFunctionPrototype;
317
+ define(genFun, toStringTagSymbol, "GeneratorFunction");
318
+ }
319
+ genFun.prototype = Object.create(Gp);
320
+ return genFun;
321
+ };
322
+
323
+ // Within the body of any async function, `await x` is transformed to
324
+ // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
325
+ // `hasOwn.call(value, "__await")` to determine if the yielded value is
326
+ // meant to be awaited.
327
+ exports.awrap = function(arg) {
328
+ return { __await: arg };
329
+ };
330
+
331
+ function AsyncIterator(generator, PromiseImpl) {
332
+ function invoke(method, arg, resolve, reject) {
333
+ var record = tryCatch(generator[method], generator, arg);
334
+ if (record.type === "throw") {
335
+ reject(record.arg);
336
+ } else {
337
+ var result = record.arg;
338
+ var value = result.value;
339
+ if (value &&
340
+ typeof value === "object" &&
341
+ hasOwn.call(value, "__await")) {
342
+ return PromiseImpl.resolve(value.__await).then(function(value) {
343
+ invoke("next", value, resolve, reject);
344
+ }, function(err) {
345
+ invoke("throw", err, resolve, reject);
346
+ });
347
+ }
348
+
349
+ return PromiseImpl.resolve(value).then(function(unwrapped) {
350
+ // When a yielded Promise is resolved, its final value becomes
351
+ // the .value of the Promise<{value,done}> result for the
352
+ // current iteration.
353
+ result.value = unwrapped;
354
+ resolve(result);
355
+ }, function(error) {
356
+ // If a rejected Promise was yielded, throw the rejection back
357
+ // into the async generator function so it can be handled there.
358
+ return invoke("throw", error, resolve, reject);
359
+ });
360
+ }
361
+ }
362
+
363
+ var previousPromise;
364
+
365
+ function enqueue(method, arg) {
366
+ function callInvokeWithMethodAndArg() {
367
+ return new PromiseImpl(function(resolve, reject) {
368
+ invoke(method, arg, resolve, reject);
369
+ });
370
+ }
371
+
372
+ return previousPromise =
373
+ // If enqueue has been called before, then we want to wait until
374
+ // all previous Promises have been resolved before calling invoke,
375
+ // so that results are always delivered in the correct order. If
376
+ // enqueue has not been called before, then it is important to
377
+ // call invoke immediately, without waiting on a callback to fire,
378
+ // so that the async generator function has the opportunity to do
379
+ // any necessary setup in a predictable way. This predictability
380
+ // is why the Promise constructor synchronously invokes its
381
+ // executor callback, and why async functions synchronously
382
+ // execute code before the first await. Since we implement simple
383
+ // async functions in terms of async generators, it is especially
384
+ // important to get this right, even though it requires care.
385
+ previousPromise ? previousPromise.then(
386
+ callInvokeWithMethodAndArg,
387
+ // Avoid propagating failures to Promises returned by later
388
+ // invocations of the iterator.
389
+ callInvokeWithMethodAndArg
390
+ ) : callInvokeWithMethodAndArg();
391
+ }
392
+
393
+ // Define the unified helper method that is used to implement .next,
394
+ // .throw, and .return (see defineIteratorMethods).
395
+ this._invoke = enqueue;
396
+ }
397
+
398
+ defineIteratorMethods(AsyncIterator.prototype);
399
+ define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
400
+ return this;
401
+ });
402
+ exports.AsyncIterator = AsyncIterator;
403
+
404
+ // Note that simple async functions are implemented on top of
405
+ // AsyncIterator objects; they just return a Promise for the value of
406
+ // the final result produced by the iterator.
407
+ exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
408
+ if (PromiseImpl === void 0) PromiseImpl = Promise;
409
+
410
+ var iter = new AsyncIterator(
411
+ wrap(innerFn, outerFn, self, tryLocsList),
412
+ PromiseImpl
413
+ );
414
+
415
+ return exports.isGeneratorFunction(outerFn)
416
+ ? iter // If outerFn is a generator, return the full iterator.
417
+ : iter.next().then(function(result) {
418
+ return result.done ? result.value : iter.next();
419
+ });
420
+ };
421
+
422
+ function makeInvokeMethod(innerFn, self, context) {
423
+ var state = GenStateSuspendedStart;
424
+
425
+ return function invoke(method, arg) {
426
+ if (state === GenStateExecuting) {
427
+ throw new Error("Generator is already running");
428
+ }
429
+
430
+ if (state === GenStateCompleted) {
431
+ if (method === "throw") {
432
+ throw arg;
433
+ }
434
+
435
+ // Be forgiving, per 25.3.3.3.3 of the spec:
436
+ // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
437
+ return doneResult();
438
+ }
439
+
440
+ context.method = method;
441
+ context.arg = arg;
442
+
443
+ while (true) {
444
+ var delegate = context.delegate;
445
+ if (delegate) {
446
+ var delegateResult = maybeInvokeDelegate(delegate, context);
447
+ if (delegateResult) {
448
+ if (delegateResult === ContinueSentinel) continue;
449
+ return delegateResult;
450
+ }
451
+ }
452
+
453
+ if (context.method === "next") {
454
+ // Setting context._sent for legacy support of Babel's
455
+ // function.sent implementation.
456
+ context.sent = context._sent = context.arg;
457
+
458
+ } else if (context.method === "throw") {
459
+ if (state === GenStateSuspendedStart) {
460
+ state = GenStateCompleted;
461
+ throw context.arg;
462
+ }
463
+
464
+ context.dispatchException(context.arg);
465
+
466
+ } else if (context.method === "return") {
467
+ context.abrupt("return", context.arg);
468
+ }
469
+
470
+ state = GenStateExecuting;
471
+
472
+ var record = tryCatch(innerFn, self, context);
473
+ if (record.type === "normal") {
474
+ // If an exception is thrown from innerFn, we leave state ===
475
+ // GenStateExecuting and loop back for another invocation.
476
+ state = context.done
477
+ ? GenStateCompleted
478
+ : GenStateSuspendedYield;
479
+
480
+ if (record.arg === ContinueSentinel) {
481
+ continue;
482
+ }
483
+
484
+ return {
485
+ value: record.arg,
486
+ done: context.done
487
+ };
488
+
489
+ } else if (record.type === "throw") {
490
+ state = GenStateCompleted;
491
+ // Dispatch the exception by looping back around to the
492
+ // context.dispatchException(context.arg) call above.
493
+ context.method = "throw";
494
+ context.arg = record.arg;
495
+ }
496
+ }
497
+ };
498
+ }
499
+
500
+ // Call delegate.iterator[context.method](context.arg) and handle the
501
+ // result, either by returning a { value, done } result from the
502
+ // delegate iterator, or by modifying context.method and context.arg,
503
+ // setting context.delegate to null, and returning the ContinueSentinel.
504
+ function maybeInvokeDelegate(delegate, context) {
505
+ var method = delegate.iterator[context.method];
506
+ if (method === undefined$1) {
507
+ // A .throw or .return when the delegate iterator has no .throw
508
+ // method always terminates the yield* loop.
509
+ context.delegate = null;
510
+
511
+ if (context.method === "throw") {
512
+ // Note: ["return"] must be used for ES3 parsing compatibility.
513
+ if (delegate.iterator["return"]) {
514
+ // If the delegate iterator has a return method, give it a
515
+ // chance to clean up.
516
+ context.method = "return";
517
+ context.arg = undefined$1;
518
+ maybeInvokeDelegate(delegate, context);
519
+
520
+ if (context.method === "throw") {
521
+ // If maybeInvokeDelegate(context) changed context.method from
522
+ // "return" to "throw", let that override the TypeError below.
523
+ return ContinueSentinel;
524
+ }
525
+ }
526
+
527
+ context.method = "throw";
528
+ context.arg = new TypeError(
529
+ "The iterator does not provide a 'throw' method");
530
+ }
531
+
532
+ return ContinueSentinel;
533
+ }
534
+
535
+ var record = tryCatch(method, delegate.iterator, context.arg);
536
+
537
+ if (record.type === "throw") {
538
+ context.method = "throw";
539
+ context.arg = record.arg;
540
+ context.delegate = null;
541
+ return ContinueSentinel;
542
+ }
543
+
544
+ var info = record.arg;
545
+
546
+ if (! info) {
547
+ context.method = "throw";
548
+ context.arg = new TypeError("iterator result is not an object");
549
+ context.delegate = null;
550
+ return ContinueSentinel;
551
+ }
552
+
553
+ if (info.done) {
554
+ // Assign the result of the finished delegate to the temporary
555
+ // variable specified by delegate.resultName (see delegateYield).
556
+ context[delegate.resultName] = info.value;
557
+
558
+ // Resume execution at the desired location (see delegateYield).
559
+ context.next = delegate.nextLoc;
560
+
561
+ // If context.method was "throw" but the delegate handled the
562
+ // exception, let the outer generator proceed normally. If
563
+ // context.method was "next", forget context.arg since it has been
564
+ // "consumed" by the delegate iterator. If context.method was
565
+ // "return", allow the original .return call to continue in the
566
+ // outer generator.
567
+ if (context.method !== "return") {
568
+ context.method = "next";
569
+ context.arg = undefined$1;
570
+ }
571
+
572
+ } else {
573
+ // Re-yield the result returned by the delegate method.
574
+ return info;
575
+ }
576
+
577
+ // The delegate iterator is finished, so forget it and continue with
578
+ // the outer generator.
579
+ context.delegate = null;
580
+ return ContinueSentinel;
581
+ }
582
+
583
+ // Define Generator.prototype.{next,throw,return} in terms of the
584
+ // unified ._invoke helper method.
585
+ defineIteratorMethods(Gp);
586
+
587
+ define(Gp, toStringTagSymbol, "Generator");
588
+
589
+ // A Generator should always return itself as the iterator object when the
590
+ // @@iterator function is called on it. Some browsers' implementations of the
591
+ // iterator prototype chain incorrectly implement this, causing the Generator
592
+ // object to not be returned from this call. This ensures that doesn't happen.
593
+ // See https://github.com/facebook/regenerator/issues/274 for more details.
594
+ define(Gp, iteratorSymbol, function() {
595
+ return this;
596
+ });
597
+
598
+ define(Gp, "toString", function() {
599
+ return "[object Generator]";
600
+ });
601
+
602
+ function pushTryEntry(locs) {
603
+ var entry = { tryLoc: locs[0] };
604
+
605
+ if (1 in locs) {
606
+ entry.catchLoc = locs[1];
607
+ }
608
+
609
+ if (2 in locs) {
610
+ entry.finallyLoc = locs[2];
611
+ entry.afterLoc = locs[3];
612
+ }
613
+
614
+ this.tryEntries.push(entry);
615
+ }
616
+
617
+ function resetTryEntry(entry) {
618
+ var record = entry.completion || {};
619
+ record.type = "normal";
620
+ delete record.arg;
621
+ entry.completion = record;
622
+ }
623
+
624
+ function Context(tryLocsList) {
625
+ // The root entry object (effectively a try statement without a catch
626
+ // or a finally block) gives us a place to store values thrown from
627
+ // locations where there is no enclosing try statement.
628
+ this.tryEntries = [{ tryLoc: "root" }];
629
+ tryLocsList.forEach(pushTryEntry, this);
630
+ this.reset(true);
631
+ }
632
+
633
+ exports.keys = function(object) {
634
+ var keys = [];
635
+ for (var key in object) {
636
+ keys.push(key);
637
+ }
638
+ keys.reverse();
639
+
640
+ // Rather than returning an object with a next method, we keep
641
+ // things simple and return the next function itself.
642
+ return function next() {
643
+ while (keys.length) {
644
+ var key = keys.pop();
645
+ if (key in object) {
646
+ next.value = key;
647
+ next.done = false;
648
+ return next;
649
+ }
650
+ }
651
+
652
+ // To avoid creating an additional object, we just hang the .value
653
+ // and .done properties off the next function object itself. This
654
+ // also ensures that the minifier will not anonymize the function.
655
+ next.done = true;
656
+ return next;
657
+ };
658
+ };
659
+
660
+ function values(iterable) {
661
+ if (iterable) {
662
+ var iteratorMethod = iterable[iteratorSymbol];
663
+ if (iteratorMethod) {
664
+ return iteratorMethod.call(iterable);
665
+ }
666
+
667
+ if (typeof iterable.next === "function") {
668
+ return iterable;
669
+ }
670
+
671
+ if (!isNaN(iterable.length)) {
672
+ var i = -1, next = function next() {
673
+ while (++i < iterable.length) {
674
+ if (hasOwn.call(iterable, i)) {
675
+ next.value = iterable[i];
676
+ next.done = false;
677
+ return next;
678
+ }
679
+ }
680
+
681
+ next.value = undefined$1;
682
+ next.done = true;
683
+
684
+ return next;
685
+ };
686
+
687
+ return next.next = next;
688
+ }
689
+ }
690
+
691
+ // Return an iterator with no values.
692
+ return { next: doneResult };
693
+ }
694
+ exports.values = values;
695
+
696
+ function doneResult() {
697
+ return { value: undefined$1, done: true };
698
+ }
699
+
700
+ Context.prototype = {
701
+ constructor: Context,
702
+
703
+ reset: function(skipTempReset) {
704
+ this.prev = 0;
705
+ this.next = 0;
706
+ // Resetting context._sent for legacy support of Babel's
707
+ // function.sent implementation.
708
+ this.sent = this._sent = undefined$1;
709
+ this.done = false;
710
+ this.delegate = null;
711
+
712
+ this.method = "next";
713
+ this.arg = undefined$1;
714
+
715
+ this.tryEntries.forEach(resetTryEntry);
716
+
717
+ if (!skipTempReset) {
718
+ for (var name in this) {
719
+ // Not sure about the optimal order of these conditions:
720
+ if (name.charAt(0) === "t" &&
721
+ hasOwn.call(this, name) &&
722
+ !isNaN(+name.slice(1))) {
723
+ this[name] = undefined$1;
724
+ }
725
+ }
726
+ }
727
+ },
728
+
729
+ stop: function() {
730
+ this.done = true;
731
+
732
+ var rootEntry = this.tryEntries[0];
733
+ var rootRecord = rootEntry.completion;
734
+ if (rootRecord.type === "throw") {
735
+ throw rootRecord.arg;
736
+ }
737
+
738
+ return this.rval;
739
+ },
740
+
741
+ dispatchException: function(exception) {
742
+ if (this.done) {
743
+ throw exception;
744
+ }
745
+
746
+ var context = this;
747
+ function handle(loc, caught) {
748
+ record.type = "throw";
749
+ record.arg = exception;
750
+ context.next = loc;
751
+
752
+ if (caught) {
753
+ // If the dispatched exception was caught by a catch block,
754
+ // then let that catch block handle the exception normally.
755
+ context.method = "next";
756
+ context.arg = undefined$1;
757
+ }
758
+
759
+ return !! caught;
760
+ }
761
+
762
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
763
+ var entry = this.tryEntries[i];
764
+ var record = entry.completion;
765
+
766
+ if (entry.tryLoc === "root") {
767
+ // Exception thrown outside of any try block that could handle
768
+ // it, so set the completion value of the entire function to
769
+ // throw the exception.
770
+ return handle("end");
771
+ }
772
+
773
+ if (entry.tryLoc <= this.prev) {
774
+ var hasCatch = hasOwn.call(entry, "catchLoc");
775
+ var hasFinally = hasOwn.call(entry, "finallyLoc");
776
+
777
+ if (hasCatch && hasFinally) {
778
+ if (this.prev < entry.catchLoc) {
779
+ return handle(entry.catchLoc, true);
780
+ } else if (this.prev < entry.finallyLoc) {
781
+ return handle(entry.finallyLoc);
782
+ }
783
+
784
+ } else if (hasCatch) {
785
+ if (this.prev < entry.catchLoc) {
786
+ return handle(entry.catchLoc, true);
787
+ }
788
+
789
+ } else if (hasFinally) {
790
+ if (this.prev < entry.finallyLoc) {
791
+ return handle(entry.finallyLoc);
792
+ }
793
+
794
+ } else {
795
+ throw new Error("try statement without catch or finally");
796
+ }
797
+ }
798
+ }
799
+ },
800
+
801
+ abrupt: function(type, arg) {
802
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
803
+ var entry = this.tryEntries[i];
804
+ if (entry.tryLoc <= this.prev &&
805
+ hasOwn.call(entry, "finallyLoc") &&
806
+ this.prev < entry.finallyLoc) {
807
+ var finallyEntry = entry;
808
+ break;
809
+ }
810
+ }
811
+
812
+ if (finallyEntry &&
813
+ (type === "break" ||
814
+ type === "continue") &&
815
+ finallyEntry.tryLoc <= arg &&
816
+ arg <= finallyEntry.finallyLoc) {
817
+ // Ignore the finally entry if control is not jumping to a
818
+ // location outside the try/catch block.
819
+ finallyEntry = null;
820
+ }
821
+
822
+ var record = finallyEntry ? finallyEntry.completion : {};
823
+ record.type = type;
824
+ record.arg = arg;
825
+
826
+ if (finallyEntry) {
827
+ this.method = "next";
828
+ this.next = finallyEntry.finallyLoc;
829
+ return ContinueSentinel;
830
+ }
831
+
832
+ return this.complete(record);
833
+ },
834
+
835
+ complete: function(record, afterLoc) {
836
+ if (record.type === "throw") {
837
+ throw record.arg;
838
+ }
839
+
840
+ if (record.type === "break" ||
841
+ record.type === "continue") {
842
+ this.next = record.arg;
843
+ } else if (record.type === "return") {
844
+ this.rval = this.arg = record.arg;
845
+ this.method = "return";
846
+ this.next = "end";
847
+ } else if (record.type === "normal" && afterLoc) {
848
+ this.next = afterLoc;
849
+ }
850
+
851
+ return ContinueSentinel;
852
+ },
853
+
854
+ finish: function(finallyLoc) {
855
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
856
+ var entry = this.tryEntries[i];
857
+ if (entry.finallyLoc === finallyLoc) {
858
+ this.complete(entry.completion, entry.afterLoc);
859
+ resetTryEntry(entry);
860
+ return ContinueSentinel;
861
+ }
862
+ }
863
+ },
864
+
865
+ "catch": function(tryLoc) {
866
+ for (var i = this.tryEntries.length - 1; i >= 0; --i) {
867
+ var entry = this.tryEntries[i];
868
+ if (entry.tryLoc === tryLoc) {
869
+ var record = entry.completion;
870
+ if (record.type === "throw") {
871
+ var thrown = record.arg;
872
+ resetTryEntry(entry);
873
+ }
874
+ return thrown;
875
+ }
876
+ }
877
+
878
+ // The context.catch method must only be called with a location
879
+ // argument that corresponds to a known catch block.
880
+ throw new Error("illegal catch attempt");
881
+ },
882
+
883
+ delegateYield: function(iterable, resultName, nextLoc) {
884
+ this.delegate = {
885
+ iterator: values(iterable),
886
+ resultName: resultName,
887
+ nextLoc: nextLoc
888
+ };
889
+
890
+ if (this.method === "next") {
891
+ // Deliberately forget the last sent value so that we don't
892
+ // accidentally pass it on to the delegate.
893
+ this.arg = undefined$1;
894
+ }
895
+
896
+ return ContinueSentinel;
897
+ }
898
+ };
899
+
900
+ // Regardless of whether this script is executing as a CommonJS module
901
+ // or not, return the runtime object so that we can declare the variable
902
+ // regeneratorRuntime in the outer scope, which allows this module to be
903
+ // injected easily by `bin/regenerator --include-runtime script.js`.
904
+ return exports;
905
+
906
+ }(
907
+ // If this script is executing as a CommonJS module, use module.exports
908
+ // as the regeneratorRuntime namespace. Otherwise create a new empty
909
+ // object. Either way, the resulting object will be used to initialize
910
+ // the regeneratorRuntime variable at the top of this file.
911
+ module.exports
912
+ ));
913
+
914
+ try {
915
+ regeneratorRuntime = runtime;
916
+ } catch (accidentalStrictMode) {
917
+ // This module should not be running in strict mode, so the above
918
+ // assignment should always work unless something is misconfigured. Just
919
+ // in case runtime.js accidentally runs in strict mode, in modern engines
920
+ // we can explicitly access globalThis. In older engines we can escape
921
+ // strict mode using a global Function call. This could conceivably fail
922
+ // if a Content Security Policy forbids using Function, but in that case
923
+ // the proper solution is to fix the accidental strict mode problem. If
924
+ // you've misconfigured your bundler to force strict mode and applied a
925
+ // CSP to forbid Function, and you're not willing to fix either of those
926
+ // problems, please detail your unique predicament in a GitHub issue.
927
+ if (typeof globalThis === "object") {
928
+ globalThis.regeneratorRuntime = runtime;
929
+ } else {
930
+ Function("r", "regeneratorRuntime = r")(runtime);
931
+ }
434
932
  }
933
+ });
435
934
 
436
935
  var AxiosService = /*#__PURE__*/function () {
437
936
  function AxiosService(config) {
438
937
  if (!config) config = {};
439
938
  this.axios = axios.create(config);
440
939
  }
940
+
441
941
  var _proto = AxiosService.prototype;
942
+
442
943
  _proto.apiRequest = /*#__PURE__*/function () {
443
- var _apiRequest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(config, url, data) {
444
- return _regeneratorRuntime().wrap(function _callee$(_context) {
944
+ var _apiRequest = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(config, url, data) {
945
+ return runtime_1.wrap(function _callee$(_context) {
445
946
  while (1) {
446
947
  switch (_context.prev = _context.next) {
447
948
  case 0:
@@ -453,6 +954,7 @@ var AxiosService = /*#__PURE__*/function () {
453
954
  })).then(function (res) {
454
955
  return res.data;
455
956
  }));
957
+
456
958
  case 3:
457
959
  case "end":
458
960
  return _context.stop();
@@ -460,14 +962,17 @@ var AxiosService = /*#__PURE__*/function () {
460
962
  }
461
963
  }, _callee, this);
462
964
  }));
965
+
463
966
  function apiRequest(_x, _x2, _x3) {
464
967
  return _apiRequest.apply(this, arguments);
465
968
  }
969
+
466
970
  return apiRequest;
467
971
  }();
972
+
468
973
  _proto.apiRequestHeader = /*#__PURE__*/function () {
469
- var _apiRequestHeader = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(config, url, headerToRetrieve, data) {
470
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
974
+ var _apiRequestHeader = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(config, url, headerToRetrieve, data) {
975
+ return runtime_1.wrap(function _callee2$(_context2) {
471
976
  while (1) {
472
977
  switch (_context2.prev = _context2.next) {
473
978
  case 0:
@@ -479,10 +984,13 @@ var AxiosService = /*#__PURE__*/function () {
479
984
  })).then(function (res) {
480
985
  if (headerToRetrieve) {
481
986
  var _res$headers$headerTo;
987
+
482
988
  return (_res$headers$headerTo = res.headers[headerToRetrieve]) != null ? _res$headers$headerTo : res.headers[headerToRetrieve.toLowerCase()];
483
989
  }
990
+
484
991
  return res.headers;
485
992
  }));
993
+
486
994
  case 3:
487
995
  case "end":
488
996
  return _context2.stop();
@@ -490,46 +998,56 @@ var AxiosService = /*#__PURE__*/function () {
490
998
  }
491
999
  }, _callee2, this);
492
1000
  }));
1001
+
493
1002
  function apiRequestHeader(_x4, _x5, _x6, _x7) {
494
1003
  return _apiRequestHeader.apply(this, arguments);
495
1004
  }
1005
+
496
1006
  return apiRequestHeader;
497
1007
  }();
1008
+
498
1009
  _proto.get = function get(url, config) {
499
1010
  return this.apiRequest(_extends({}, config, {
500
1011
  method: 'get'
501
1012
  }), url);
502
1013
  };
1014
+
503
1015
  _proto.deleteRequest = function deleteRequest(url, config) {
504
1016
  return this.apiRequest(_extends({}, config, {
505
1017
  method: 'delete'
506
1018
  }), url);
507
1019
  };
1020
+
508
1021
  _proto.post = function post(url, data, config) {
509
1022
  return this.apiRequest(_extends({}, config, {
510
1023
  method: 'post'
511
1024
  }), url, data);
512
1025
  };
1026
+
513
1027
  _proto.put = function put(url, data, config) {
514
1028
  return this.apiRequest(_extends({}, config, {
515
1029
  method: 'put'
516
1030
  }), url, data);
517
1031
  };
1032
+
518
1033
  _proto.patch = function patch(url, data, config) {
519
1034
  return this.apiRequest(_extends({}, config, {
520
1035
  method: 'patch'
521
1036
  }), url, data);
522
1037
  };
1038
+
523
1039
  _proto.head = function head(url, config, headerToRetrieve, data) {
524
1040
  return this.apiRequestHeader(_extends({}, config, {
525
1041
  method: 'head'
526
1042
  }), url, headerToRetrieve, data);
527
1043
  };
1044
+
528
1045
  return AxiosService;
529
1046
  }();
530
1047
 
531
1048
  var APIService = /*#__PURE__*/function (_AxiosService) {
532
1049
  _inheritsLoose(APIService, _AxiosService);
1050
+
533
1051
  /**
534
1052
  * The API Service lets you use an axios API and handles oro backend services authentification via JWT tokens
535
1053
  * @param useLocalStorage if set to true, tokens will be stored in localStorage
@@ -538,11 +1056,14 @@ var APIService = /*#__PURE__*/function (_AxiosService) {
538
1056
  */
539
1057
  function APIService(useLocalStorage, config, tokenRefreshFailureCallback) {
540
1058
  var _this;
1059
+
541
1060
  _this = _AxiosService.call(this, config) || this;
542
1061
  _this.useLocalStorage = useLocalStorage;
543
1062
  _this.tokenRefreshFailureCallback = tokenRefreshFailureCallback;
544
1063
  _this.tokens = {};
1064
+
545
1065
  var self = _assertThisInitialized(_this);
1066
+
546
1067
  _this.axios.interceptors.request.use(function (config) {
547
1068
  var token = config.useRefreshToken ? self.getTokens().refreshToken : self.getTokens().accessToken;
548
1069
  config.headers = _extends({}, config.headers, {
@@ -552,10 +1073,11 @@ var APIService = /*#__PURE__*/function (_AxiosService) {
552
1073
  }, function (error) {
553
1074
  Promise.reject(error);
554
1075
  });
1076
+
555
1077
  createAuthRefreshInterceptor(_this.axios, /*#__PURE__*/function () {
556
- var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(failedRequest) {
1078
+ var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(failedRequest) {
557
1079
  var tokenResp;
558
- return _regeneratorRuntime().wrap(function _callee$(_context) {
1080
+ return runtime_1.wrap(function _callee$(_context) {
559
1081
  while (1) {
560
1082
  switch (_context.prev = _context.next) {
561
1083
  case 0:
@@ -563,9 +1085,11 @@ var APIService = /*#__PURE__*/function (_AxiosService) {
563
1085
  _context.next = 15;
564
1086
  break;
565
1087
  }
1088
+
566
1089
  _context.prev = 1;
567
1090
  _context.next = 4;
568
1091
  return self.authRefreshFn(self.getTokens().refreshToken);
1092
+
569
1093
  case 4:
570
1094
  tokenResp = _context.sent;
571
1095
  self.setTokens({
@@ -574,15 +1098,18 @@ var APIService = /*#__PURE__*/function (_AxiosService) {
574
1098
  });
575
1099
  failedRequest.response.config.headers['Authorization'] = "Bearer " + self.getTokens().accessToken;
576
1100
  return _context.abrupt("return", Promise.resolve());
1101
+
577
1102
  case 10:
578
1103
  _context.prev = 10;
579
1104
  _context.t0 = _context["catch"](1);
580
1105
  console.error('an error occured while refreshing tokens (notifying callback)', _context.t0);
581
1106
  if (self.tokenRefreshFailureCallback) self.tokenRefreshFailureCallback(failedRequest);
582
1107
  return _context.abrupt("return", Promise.resolve());
1108
+
583
1109
  case 15:
584
1110
  console.error('The request could not refresh the token (authRefreshFn was not set)', failedRequest);
585
1111
  return _context.abrupt("return", Promise.resolve());
1112
+
586
1113
  case 17:
587
1114
  case "end":
588
1115
  return _context.stop();
@@ -590,6 +1117,7 @@ var APIService = /*#__PURE__*/function (_AxiosService) {
590
1117
  }
591
1118
  }, _callee, null, [[1, 10]]);
592
1119
  }));
1120
+
593
1121
  return function (_x) {
594
1122
  return _ref.apply(this, arguments);
595
1123
  };
@@ -598,34 +1126,43 @@ var APIService = /*#__PURE__*/function (_AxiosService) {
598
1126
  });
599
1127
  return _this;
600
1128
  }
1129
+
601
1130
  var _proto = APIService.prototype;
1131
+
602
1132
  _proto.setAuthRefreshFn = function setAuthRefreshFn(fn) {
603
1133
  this.authRefreshFn = fn;
604
1134
  };
1135
+
605
1136
  _proto.setTokens = function setTokens(tokens) {
606
1137
  if (this.useLocalStorage) {
607
1138
  localStorage.setItem('tokens', JSON.stringify(tokens));
608
1139
  }
1140
+
609
1141
  this.tokens = tokens;
610
1142
  };
1143
+
611
1144
  _proto.getTokens = function getTokens() {
612
1145
  if (this.useLocalStorage) {
613
1146
  var tokens = {};
614
1147
  var item = localStorage.getItem('tokens');
1148
+
615
1149
  if (item) {
616
1150
  tokens = JSON.parse(item);
617
1151
  }
1152
+
618
1153
  return tokens;
619
1154
  } else {
620
1155
  return this.tokens;
621
1156
  }
622
1157
  };
1158
+
623
1159
  return APIService;
624
1160
  }(AxiosService);
625
1161
 
626
1162
  /**
627
1163
  * This service enables you to handle one authentication token per practice
628
1164
  */
1165
+
629
1166
  var ApisPracticeManager = /*#__PURE__*/function () {
630
1167
  /**
631
1168
  * The constructor
@@ -638,6 +1175,7 @@ var ApisPracticeManager = /*#__PURE__*/function () {
638
1175
  if (useLocalStorage === void 0) {
639
1176
  useLocalStorage = false;
640
1177
  }
1178
+
641
1179
  this.serviceCollReq = serviceCollReq;
642
1180
  this.getAuthTokenCbk = getAuthTokenCbk;
643
1181
  this.useLocalStorage = useLocalStorage;
@@ -648,28 +1186,36 @@ var ApisPracticeManager = /*#__PURE__*/function () {
648
1186
  * @param practiceUuid the uuid of the practice
649
1187
  * @returns a promise holding a `ServiceCollection`
650
1188
  */
1189
+
1190
+
651
1191
  var _proto = ApisPracticeManager.prototype;
1192
+
652
1193
  _proto.get =
653
1194
  /*#__PURE__*/
654
1195
  function () {
655
- var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(practiceUuid) {
1196
+ var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(practiceUuid) {
656
1197
  var _this = this;
1198
+
657
1199
  var practiceInstance, newPracticeInstance, authTokenFunc;
658
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
1200
+ return runtime_1.wrap(function _callee2$(_context2) {
659
1201
  while (1) {
660
1202
  switch (_context2.prev = _context2.next) {
661
1203
  case 0:
662
1204
  practiceInstance = this.practiceInstances.get(practiceUuid);
1205
+
663
1206
  if (!practiceInstance) {
664
1207
  _context2.next = 3;
665
1208
  break;
666
1209
  }
1210
+
667
1211
  return _context2.abrupt("return", practiceInstance);
1212
+
668
1213
  case 3:
669
1214
  newPracticeInstance = init(this.serviceCollReq, undefined, this.useLocalStorage); // Create one auth token callback per practice since the practice uuid needs to change
1215
+
670
1216
  authTokenFunc = /*#__PURE__*/function () {
671
- var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
672
- return _regeneratorRuntime().wrap(function _callee$(_context) {
1217
+ var _ref = _asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee() {
1218
+ return runtime_1.wrap(function _callee$(_context) {
673
1219
  while (1) {
674
1220
  switch (_context.prev = _context.next) {
675
1221
  case 0:
@@ -677,13 +1223,17 @@ var ApisPracticeManager = /*#__PURE__*/function () {
677
1223
  _context.next = 7;
678
1224
  break;
679
1225
  }
1226
+
680
1227
  console.log("\x1B[36m[Auth] Refresh auth called (practiceUuid: " + practiceUuid + ")\x1B[36m");
681
1228
  _context.next = 4;
682
1229
  return _this.getAuthTokenCbk(newPracticeInstance.guardService, practiceUuid);
1230
+
683
1231
  case 4:
684
1232
  return _context.abrupt("return", _context.sent);
1233
+
685
1234
  case 7:
686
1235
  throw Error('[Auth] Unable to refresh token guard service is undefined');
1236
+
687
1237
  case 8:
688
1238
  case "end":
689
1239
  return _context.stop();
@@ -691,17 +1241,22 @@ var ApisPracticeManager = /*#__PURE__*/function () {
691
1241
  }
692
1242
  }, _callee);
693
1243
  }));
1244
+
694
1245
  return function authTokenFunc() {
695
1246
  return _ref.apply(this, arguments);
696
1247
  };
697
1248
  }(); // Initialize the M2M token
1249
+
1250
+
698
1251
  _context2.next = 7;
699
1252
  return authTokenFunc();
1253
+
700
1254
  case 7:
701
1255
  // Set the refresh tokens callback
702
1256
  newPracticeInstance.apiService.setAuthRefreshFn(authTokenFunc);
703
1257
  this.practiceInstances.set(practiceUuid, newPracticeInstance);
704
1258
  return _context2.abrupt("return", newPracticeInstance);
1259
+
705
1260
  case 10:
706
1261
  case "end":
707
1262
  return _context2.stop();
@@ -709,11 +1264,14 @@ var ApisPracticeManager = /*#__PURE__*/function () {
709
1264
  }
710
1265
  }, _callee2, this);
711
1266
  }));
1267
+
712
1268
  function get(_x) {
713
1269
  return _get.apply(this, arguments);
714
1270
  }
1271
+
715
1272
  return get;
716
1273
  }();
1274
+
717
1275
  return ApisPracticeManager;
718
1276
  }();
719
1277
 
@@ -724,6 +1282,7 @@ var ApisPracticeManager = /*#__PURE__*/function () {
724
1282
  AssistantType["Administrative"] = "Administrative";
725
1283
  AssistantType["Other"] = "Other";
726
1284
  })(exports.AssistantType || (exports.AssistantType = {}));
1285
+
727
1286
  (function (TransmissionKind) {
728
1287
  TransmissionKind["Fax"] = "Fax";
729
1288
  TransmissionKind["Email"] = "Email";
@@ -733,6 +1292,7 @@ var ApisPracticeManager = /*#__PURE__*/function () {
733
1292
  TransmissionKind["API"] = "API";
734
1293
  TransmissionKind["Other"] = "Other";
735
1294
  })(exports.TransmissionKind || (exports.TransmissionKind = {}));
1295
+
736
1296
  (function (TransmissionStatus) {
737
1297
  TransmissionStatus["Preparing"] = "Preparing";
738
1298
  TransmissionStatus["Sending"] = "Sending";
@@ -745,10 +1305,12 @@ var ApisPracticeManager = /*#__PURE__*/function () {
745
1305
  TransmissionStatus["ReceiverNotAnswering"] = "ReceiverNotAnswering";
746
1306
  TransmissionStatus["ReceiverIncompatible"] = "ReceiverIncompatible";
747
1307
  })(exports.TransmissionStatus || (exports.TransmissionStatus = {}));
1308
+
748
1309
  (function (ConsultType) {
749
1310
  ConsultType["Onboard"] = "Onboard";
750
1311
  ConsultType["Refill"] = "Refill";
751
1312
  })(exports.ConsultType || (exports.ConsultType = {}));
1313
+
752
1314
  (function (FeeStatus) {
753
1315
  FeeStatus["NoFee"] = "NoFee";
754
1316
  FeeStatus["Pending"] = "Pending";
@@ -757,6 +1319,7 @@ var ApisPracticeManager = /*#__PURE__*/function () {
757
1319
  FeeStatus["Cancelled"] = "Cancelled";
758
1320
  FeeStatus["Contested"] = "Contested";
759
1321
  })(exports.FeeStatus || (exports.FeeStatus = {}));
1322
+
760
1323
  (function (MedicalStatus) {
761
1324
  MedicalStatus["Creating"] = "Creating";
762
1325
  MedicalStatus["New"] = "New";
@@ -767,6 +1330,7 @@ var ApisPracticeManager = /*#__PURE__*/function () {
767
1330
  MedicalStatus["Archived"] = "Archived";
768
1331
  MedicalStatus["Failed"] = "Failed";
769
1332
  })(exports.MedicalStatus || (exports.MedicalStatus = {}));
1333
+
770
1334
  (function (TaskStatus) {
771
1335
  TaskStatus["None"] = "None";
772
1336
  TaskStatus["ToDo"] = "ToDo";
@@ -774,6 +1338,7 @@ var ApisPracticeManager = /*#__PURE__*/function () {
774
1338
  TaskStatus["Blocked"] = "Blocked";
775
1339
  TaskStatus["Done"] = "Done";
776
1340
  })(exports.TaskStatus || (exports.TaskStatus = {}));
1341
+
777
1342
  (function (ClosedReasonType) {
778
1343
  /**
779
1344
  * A completed consultation
@@ -782,18 +1347,22 @@ var ApisPracticeManager = /*#__PURE__*/function () {
782
1347
  /**
783
1348
  * The conclusion was that what the patient submitted was not a disease
784
1349
  */
1350
+
785
1351
  ClosedReasonType["NotADisease"] = "NotADisease";
786
1352
  /**
787
1353
  * The consultation was not appropriate for virtual
788
1354
  */
1355
+
789
1356
  ClosedReasonType["NotAppropriateForVirtual"] = "NotAppropriateForVirtual";
790
1357
  /**
791
1358
  * Any other reason why the consultation was closed
792
1359
  */
1360
+
793
1361
  ClosedReasonType["Other"] = "Other";
794
1362
  /**
795
1363
  * A consultation that is required to be done in person
796
1364
  */
1365
+
797
1366
  ClosedReasonType["RequiresInPerson"] = "RequiresInPerson";
798
1367
  })(exports.ClosedReasonType || (exports.ClosedReasonType = {}));
799
1368
 
@@ -802,14 +1371,17 @@ var ApisPracticeManager = /*#__PURE__*/function () {
802
1371
  VisibilityType["Private"] = "Private";
803
1372
  VisibilityType["Instance"] = "Instance";
804
1373
  })(exports.VisibilityType || (exports.VisibilityType = {}));
1374
+
805
1375
  (function (DrugType) {
806
1376
  DrugType["Generic"] = "Generic";
807
1377
  DrugType["Instance"] = "Instance";
808
1378
  })(exports.DrugType || (exports.DrugType = {}));
1379
+
809
1380
  (function (PrescriptionStatus) {
810
1381
  PrescriptionStatus["Existing"] = "Existing";
811
1382
  PrescriptionStatus["Deleted"] = "Deleted";
812
1383
  })(exports.PrescriptionStatus || (exports.PrescriptionStatus = {}));
1384
+
813
1385
  (function (PlanStatus) {
814
1386
  PlanStatus["Pending"] = "Pending";
815
1387
  PlanStatus["Accepted"] = "Accepted";
@@ -818,58 +1390,74 @@ var ApisPracticeManager = /*#__PURE__*/function () {
818
1390
 
819
1391
  var AuthenticationFailed = /*#__PURE__*/function (_Error) {
820
1392
  _inheritsLoose(AuthenticationFailed, _Error);
1393
+
821
1394
  function AuthenticationFailed() {
822
1395
  return _Error.apply(this, arguments) || this;
823
1396
  }
1397
+
824
1398
  return AuthenticationFailed;
825
1399
  }( /*#__PURE__*/_wrapNativeSuper(Error));
826
1400
  var AuthenticationBadRequest = /*#__PURE__*/function (_Error2) {
827
1401
  _inheritsLoose(AuthenticationBadRequest, _Error2);
1402
+
828
1403
  function AuthenticationBadRequest() {
829
1404
  return _Error2.apply(this, arguments) || this;
830
1405
  }
1406
+
831
1407
  return AuthenticationBadRequest;
832
1408
  }( /*#__PURE__*/_wrapNativeSuper(Error));
833
1409
  var AuthenticationServerError = /*#__PURE__*/function (_Error3) {
834
1410
  _inheritsLoose(AuthenticationServerError, _Error3);
1411
+
835
1412
  function AuthenticationServerError() {
836
1413
  return _Error3.apply(this, arguments) || this;
837
1414
  }
1415
+
838
1416
  return AuthenticationServerError;
839
1417
  }( /*#__PURE__*/_wrapNativeSuper(Error));
840
1418
  var AuthenticationUnconfirmedEmail = /*#__PURE__*/function (_Error4) {
841
1419
  _inheritsLoose(AuthenticationUnconfirmedEmail, _Error4);
1420
+
842
1421
  function AuthenticationUnconfirmedEmail() {
843
1422
  return _Error4.apply(this, arguments) || this;
844
1423
  }
1424
+
845
1425
  return AuthenticationUnconfirmedEmail;
846
1426
  }( /*#__PURE__*/_wrapNativeSuper(Error));
847
1427
  var IdentityCreationFailed = /*#__PURE__*/function (_Error5) {
848
1428
  _inheritsLoose(IdentityCreationFailed, _Error5);
1429
+
849
1430
  function IdentityCreationFailed() {
850
1431
  return _Error5.apply(this, arguments) || this;
851
1432
  }
1433
+
852
1434
  return IdentityCreationFailed;
853
1435
  }( /*#__PURE__*/_wrapNativeSuper(Error));
854
1436
  var IdentityCreationBadRequest = /*#__PURE__*/function (_Error6) {
855
1437
  _inheritsLoose(IdentityCreationBadRequest, _Error6);
1438
+
856
1439
  function IdentityCreationBadRequest() {
857
1440
  return _Error6.apply(this, arguments) || this;
858
1441
  }
1442
+
859
1443
  return IdentityCreationBadRequest;
860
1444
  }( /*#__PURE__*/_wrapNativeSuper(Error));
861
1445
  var IdentityCreationConflict = /*#__PURE__*/function (_Error7) {
862
1446
  _inheritsLoose(IdentityCreationConflict, _Error7);
1447
+
863
1448
  function IdentityCreationConflict() {
864
1449
  return _Error7.apply(this, arguments) || this;
865
1450
  }
1451
+
866
1452
  return IdentityCreationConflict;
867
1453
  }( /*#__PURE__*/_wrapNativeSuper(Error));
868
1454
  var VaultDataMissing = /*#__PURE__*/function (_Error8) {
869
1455
  _inheritsLoose(VaultDataMissing, _Error8);
1456
+
870
1457
  function VaultDataMissing() {
871
1458
  return _Error8.apply(this, arguments) || this;
872
1459
  }
1460
+
873
1461
  return VaultDataMissing;
874
1462
  }( /*#__PURE__*/_wrapNativeSuper(Error));
875
1463
 
@@ -879,6 +1467,7 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
879
1467
  WorkflowType["Renew"] = "Renew";
880
1468
  WorkflowType["DataRetrieve"] = "DataRetrieve";
881
1469
  })(exports.WorkflowType || (exports.WorkflowType = {}));
1470
+
882
1471
  (function (RateDimension) {
883
1472
  RateDimension["RatioOnTotal"] = "RatioOnTotal";
884
1473
  RateDimension["FixedOnTotal"] = "FixedOnTotal";
@@ -889,18 +1478,21 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
889
1478
  RateDimension["RatioOnItem"] = "RatioOnItem";
890
1479
  RateDimension["FixedOnItem"] = "FixedOnItem";
891
1480
  })(exports.RateDimension || (exports.RateDimension = {}));
1481
+
892
1482
  (function (PlanType) {
893
1483
  PlanType["Onboard"] = "Onboard";
894
1484
  PlanType["Followup"] = "Followup";
895
1485
  PlanType["Renew"] = "Renew";
896
1486
  PlanType["DataRetrieve"] = "DataRetrieve";
897
1487
  })(exports.PlanType || (exports.PlanType = {}));
1488
+
898
1489
  (function (PaymentStatus) {
899
1490
  PaymentStatus["Pending"] = "Pending";
900
1491
  PaymentStatus["Success"] = "Success";
901
1492
  PaymentStatus["Failure"] = "Failure";
902
1493
  PaymentStatus["Canceled"] = "Canceled";
903
1494
  })(exports.PaymentStatus || (exports.PaymentStatus = {}));
1495
+
904
1496
  (function (PractitionerStatus) {
905
1497
  PractitionerStatus["Practicing"] = "Practicing";
906
1498
  PractitionerStatus["Retired"] = "Retired";
@@ -910,11 +1502,13 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
910
1502
  PractitionerStatus["InConflict"] = "InConflict";
911
1503
  PractitionerStatus["Delicensed"] = "Delicensed";
912
1504
  })(exports.PractitionerStatus || (exports.PractitionerStatus = {}));
1505
+
913
1506
  (function (AssignmentStatus) {
914
1507
  AssignmentStatus["Assigned"] = "Assigned";
915
1508
  AssignmentStatus["Reassigned"] = "Reassigned";
916
1509
  AssignmentStatus["Cancelled"] = "Cancelled";
917
1510
  })(exports.AssignmentStatus || (exports.AssignmentStatus = {}));
1511
+
918
1512
  (function (PractitionnerRoleType) {
919
1513
  PractitionnerRoleType["Doctor"] = "Doctor";
920
1514
  PractitionnerRoleType["MedicalAssistant"] = "MedicalAssistant";
@@ -926,11 +1520,13 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
926
1520
  PractitionnerRoleType["ManualDispatcher"] = "ManualDispatcher";
927
1521
  PractitionnerRoleType["Other"] = "Other";
928
1522
  })(exports.PractitionnerRoleType || (exports.PractitionnerRoleType = {}));
1523
+
929
1524
  (function (OtherRoleType) {
930
1525
  OtherRoleType["Patient"] = "Patient";
931
1526
  OtherRoleType["User"] = "User";
932
1527
  OtherRoleType["System"] = "System";
933
1528
  })(exports.OtherRoleType || (exports.OtherRoleType = {}));
1529
+
934
1530
  (function (LicenseStatus) {
935
1531
  LicenseStatus["Valid"] = "Valid";
936
1532
  LicenseStatus["Invalid"] = "Invalid";
@@ -938,6 +1534,7 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
938
1534
  LicenseStatus["NA"] = "NA";
939
1535
  LicenseStatus["Removed"] = "Removed";
940
1536
  })(exports.LicenseStatus || (exports.LicenseStatus = {}));
1537
+
941
1538
  (function (PeriodType) {
942
1539
  PeriodType["PerYear"] = "PerYear";
943
1540
  PeriodType["PerQuarter"] = "PerQuarter";
@@ -947,6 +1544,7 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
947
1544
  PeriodType["PerDay"] = "PerDay";
948
1545
  PeriodType["PerHour"] = "PerHour";
949
1546
  })(exports.PeriodType || (exports.PeriodType = {}));
1547
+
950
1548
  (function (SyncStatus) {
951
1549
  SyncStatus["Requested"] = "Requested";
952
1550
  SyncStatus["Started"] = "Started";
@@ -954,6 +1552,7 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
954
1552
  SyncStatus["Failed"] = "Failed";
955
1553
  SyncStatus["Cancelled"] = "Cancelled";
956
1554
  })(exports.SyncStatus || (exports.SyncStatus = {}));
1555
+
957
1556
  (function (PracticeEmailKind) {
958
1557
  PracticeEmailKind["SignedUp"] = "SignedUp";
959
1558
  PracticeEmailKind["Onboarded"] = "Onboarded";
@@ -972,6 +1571,7 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
972
1571
  PracticeEmailKind["OnlinePharmacyFaxSent"] = "OnlinePharmacyFaxSent";
973
1572
  PracticeEmailKind["ResumeConsult"] = "ResumeConsult";
974
1573
  })(exports.PracticeEmailKind || (exports.PracticeEmailKind = {}));
1574
+
975
1575
  (function (PracticeConfigKind) {
976
1576
  PracticeConfigKind["PatientConsultCard"] = "PatientConsultCard";
977
1577
  PracticeConfigKind["PracticeCloseConsultationTypes"] = "PracticeCloseConsultationTypes";
@@ -992,10 +1592,12 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
992
1592
  PracticeConfigKind["PracticeAddressField"] = "PracticeAddressField";
993
1593
  PracticeConfigKind["PracticeDiagnosisAndTreatment"] = "PracticeDiagnosisAndTreatment";
994
1594
  })(exports.PracticeConfigKind || (exports.PracticeConfigKind = {}));
1595
+
995
1596
  (function (StripePriceType) {
996
1597
  StripePriceType["Default"] = "Default";
997
1598
  StripePriceType["Discount"] = "Discount";
998
1599
  })(exports.StripePriceType || (exports.StripePriceType = {}));
1600
+
999
1601
  (function (PaymentIntentRequestMetadataKind) {
1000
1602
  PaymentIntentRequestMetadataKind["ConsultRequestMetadata"] = "ConsultRequestMetadata";
1001
1603
  PaymentIntentRequestMetadataKind["RefillTreatmentRequestMetadata"] = "RefillTreatmentRequestMetadata";
@@ -1006,6 +1608,7 @@ var VaultDataMissing = /*#__PURE__*/function (_Error8) {
1006
1608
  IndexKey["IndexSnapshot"] = "IndexSnapshot";
1007
1609
  IndexKey["ConsultationLockbox"] = "ConsultationLockbox";
1008
1610
  })(exports.IndexKey || (exports.IndexKey = {}));
1611
+
1009
1612
  (function (DocumentType) {
1010
1613
  DocumentType["Message"] = "Message";
1011
1614
  DocumentType["Note"] = "Note";
@@ -1052,7 +1655,9 @@ var ConsultService = /*#__PURE__*/function () {
1052
1655
  this.api = api;
1053
1656
  this.baseURL = baseURL;
1054
1657
  }
1658
+
1055
1659
  var _proto = ConsultService.prototype;
1660
+
1056
1661
  _proto.consultCreate = function consultCreate(c) {
1057
1662
  return this.api.post(this.baseURL + "/v1/consults", c);
1058
1663
  }
@@ -1072,7 +1677,9 @@ var ConsultService = /*#__PURE__*/function () {
1072
1677
  * @param filterIsoLocality the of isoLocality to filter with
1073
1678
  * @param filterAssignee array of practitioner uuids with which you want to filter the consultations
1074
1679
  * @returns a number of consult
1075
- */;
1680
+ */
1681
+ ;
1682
+
1076
1683
  _proto.countConsults = function countConsults(uuidPractice, uuidRequester, statusesMedical, statusesExclude, shortId, columnToSortTo, orderToSortTo, perPage, indexPage, filterAssignedDoctor, filterCurrentPractitioner, filterIsoLocality, filterAssignee, typesConsult, uuidParent) {
1077
1684
  return this.api.head(this.baseURL + "/v1/consults", {
1078
1685
  params: {
@@ -1096,9 +1703,11 @@ var ConsultService = /*#__PURE__*/function () {
1096
1703
  if (!resContentRange || typeof resContentRange !== 'string' && typeof resContentRange !== 'number') {
1097
1704
  return 0;
1098
1705
  }
1706
+
1099
1707
  if (typeof resContentRange === 'number') {
1100
1708
  return resContentRange;
1101
1709
  }
1710
+
1102
1711
  return parseInt(resContentRange);
1103
1712
  });
1104
1713
  }
@@ -1117,7 +1726,9 @@ var ConsultService = /*#__PURE__*/function () {
1117
1726
  * @param filterCurrentPractitioner the uuid of the current assistant assigned to filter with
1118
1727
  * @param filterIsoLocality the of isoLocality to filter with
1119
1728
  * @returns a list of consult
1120
- */;
1729
+ */
1730
+ ;
1731
+
1121
1732
  _proto.getConsults = function getConsults(uuidPractice, uuidRequester, statusesMedical, statusesExclude, shortId, columnToSortTo, orderToSortTo, perPage, indexPage, filterAssignedDoctor, filterCurrentPractitioner, filterIsoLocality, filterAssignee, uuidParent, typesConsult) {
1122
1733
  return this.api.get(this.baseURL + "/v1/consults", {
1123
1734
  params: {
@@ -1139,6 +1750,7 @@ var ConsultService = /*#__PURE__*/function () {
1139
1750
  }
1140
1751
  });
1141
1752
  };
1753
+
1142
1754
  _proto.getConsultByUUID = function getConsultByUUID(uuidConsult, uuidPractice) {
1143
1755
  return this.api.get(this.baseURL + "/v1/consults/" + uuidConsult, {
1144
1756
  params: {
@@ -1146,6 +1758,7 @@ var ConsultService = /*#__PURE__*/function () {
1146
1758
  }
1147
1759
  });
1148
1760
  };
1761
+
1149
1762
  _proto.updateConsultByUUID = function updateConsultByUUID(uuidConsult, consult, uuidPractice, uuidRequester) {
1150
1763
  return this.api.put(this.baseURL + "/v1/consults/" + uuidConsult, consult, {
1151
1764
  params: {
@@ -1154,6 +1767,7 @@ var ConsultService = /*#__PURE__*/function () {
1154
1767
  }
1155
1768
  });
1156
1769
  };
1770
+
1157
1771
  _proto.getConsultFaxStatuses = function getConsultFaxStatuses(uuidConsult) {
1158
1772
  return this.api.get(this.baseURL + "/v1/consults/" + uuidConsult + "/transmissions", {
1159
1773
  params: {
@@ -1161,52 +1775,64 @@ var ConsultService = /*#__PURE__*/function () {
1161
1775
  }
1162
1776
  });
1163
1777
  };
1164
- _proto.postConsultTransmission = function postConsultTransmission(uuidConsult, nameDriver, addressOrPhoneToSendTo, file, nameReceiver, txtTransmissionTitle, txtTransmissionNotes
1165
- // numTry ?: number,
1778
+
1779
+ _proto.postConsultTransmission = function postConsultTransmission(uuidConsult, nameDriver, addressOrPhoneToSendTo, file, nameReceiver, txtTransmissionTitle, txtTransmissionNotes // numTry ?: number,
1166
1780
  // delay ?: number,
1167
1781
  ) {
1168
1782
  if (nameDriver === void 0) {
1169
1783
  nameDriver = 'Documo';
1170
1784
  }
1785
+
1171
1786
  var data = new FormData();
1172
1787
  data.append('nameDriverReceiver', nameDriver);
1788
+
1173
1789
  if (addressOrPhoneToSendTo) {
1174
1790
  data.append('addressReceiver', addressOrPhoneToSendTo);
1175
1791
  }
1792
+
1176
1793
  if (file) {
1177
1794
  data.append('file', file);
1178
1795
  }
1796
+
1179
1797
  if (nameReceiver) {
1180
1798
  data.append('nameReceiver', nameReceiver);
1181
1799
  }
1800
+
1182
1801
  if (txtTransmissionTitle) {
1183
1802
  data.append('txtTransmissionTitle', txtTransmissionTitle);
1184
1803
  }
1804
+
1185
1805
  if (txtTransmissionNotes) {
1186
1806
  data.append('txtTransmissionNotes', txtTransmissionNotes);
1187
1807
  }
1808
+
1188
1809
  return this.api.post(this.baseURL + "/v1/consults/" + uuidConsult + "/transmissions", data, {
1189
1810
  headers: {
1190
1811
  'Content-Type': 'multipart/form-data;'
1191
1812
  }
1192
1813
  });
1193
1814
  };
1815
+
1194
1816
  _proto.postConsultFax = function postConsultFax(uuidConsult, addressReceiver, file) {
1195
1817
  return this.postConsultTransmission(uuidConsult, 'Documo', addressReceiver, file);
1196
1818
  };
1819
+
1197
1820
  _proto.postConsultEmail = function postConsultEmail(uuidConsult, file) {
1198
1821
  return this.postConsultTransmission(uuidConsult, 'Pharmacierge', undefined, file);
1199
1822
  };
1823
+
1200
1824
  _proto.retryConsultFax = function retryConsultFax(uuidConsult, transmissionId) {
1201
1825
  return this.api.put(this.baseURL + "/v1/consults/" + uuidConsult + "/transmissions/" + transmissionId, {
1202
1826
  status: exports.TransmissionStatus.Retrying
1203
1827
  });
1204
1828
  };
1829
+
1205
1830
  _proto.updateConsultTransmissionStatus = function updateConsultTransmissionStatus(transmissionId, uuidConsult, newStatus) {
1206
1831
  return this.api.put(this.baseURL + "/v1/consults/" + uuidConsult + "/transmissions/" + transmissionId, {
1207
1832
  status: newStatus
1208
1833
  });
1209
1834
  };
1835
+
1210
1836
  return ConsultService;
1211
1837
  }();
1212
1838
 
@@ -1215,7 +1841,9 @@ var DiagnosisService = /*#__PURE__*/function () {
1215
1841
  this.api = api;
1216
1842
  this.baseURL = baseURL;
1217
1843
  }
1844
+
1218
1845
  var _proto = DiagnosisService.prototype;
1846
+
1219
1847
  _proto.getDiagnoses = function getDiagnoses() {
1220
1848
  return this.api.get(this.baseURL + "/v1/diagnoses");
1221
1849
  }
@@ -1223,16 +1851,21 @@ var DiagnosisService = /*#__PURE__*/function () {
1223
1851
  * Get a diagnosis by uuid that belongs to your practice
1224
1852
  * @param uuidDiagnosis the uuid of the diagnosis
1225
1853
  * @returns a diagnosis
1226
- */;
1854
+ */
1855
+ ;
1856
+
1227
1857
  _proto.getDiagnosisByUuid = function getDiagnosisByUuid(uuidDiagnosis) {
1228
1858
  return this.api.get(this.baseURL + "/v1/diagnoses/" + uuidDiagnosis);
1229
1859
  };
1860
+
1230
1861
  _proto.createDiagnosis = function createDiagnosis(diagnosis) {
1231
1862
  return this.api.post(this.baseURL + "/v1/diagnoses", diagnosis);
1232
1863
  };
1864
+
1233
1865
  _proto.updateDiagnosis = function updateDiagnosis(uuid, diagnosis) {
1234
1866
  return this.api.put(this.baseURL + "/v1/diagnoses/" + uuid, diagnosis);
1235
1867
  };
1868
+
1236
1869
  _proto.getTreatmentsFromDiagnosisUuid = function getTreatmentsFromDiagnosisUuid(diagnosisUuid) {
1237
1870
  return this.api.get(this.baseURL + "/v1/diagnoses/" + diagnosisUuid + "/treatments");
1238
1871
  }
@@ -1240,7 +1873,9 @@ var DiagnosisService = /*#__PURE__*/function () {
1240
1873
  * This function returns treatment plans associated to a consult
1241
1874
  * @param uuidConsult the consult uuid to fetch
1242
1875
  * @returns an array of TreatmentPlan
1243
- */;
1876
+ */
1877
+ ;
1878
+
1244
1879
  _proto.getTreatmentPlansFromConsultUuid = function getTreatmentPlansFromConsultUuid(uuidConsult) {
1245
1880
  return this.api.get(this.baseURL + "/v1/treatment-plans/", {
1246
1881
  params: {
@@ -1252,7 +1887,9 @@ var DiagnosisService = /*#__PURE__*/function () {
1252
1887
  * creates a new treatment for the specified diagnosis
1253
1888
  * @param diagnosisUuid uuid of the diagnosis that the treatment is linked to
1254
1889
  * @param treatmentRequest the treatment to be inserted
1255
- */;
1890
+ */
1891
+ ;
1892
+
1256
1893
  _proto.createTreatment = function createTreatment(diagnosisUuid, treatmentRequest) {
1257
1894
  return this.api.post(this.baseURL + "/v1/diagnoses/" + diagnosisUuid + "/treatments", treatmentRequest);
1258
1895
  }
@@ -1260,7 +1897,9 @@ var DiagnosisService = /*#__PURE__*/function () {
1260
1897
  * This function returns populated treatment plans associated to a consult
1261
1898
  * @param uuidConsult the consult uuid to fetch
1262
1899
  * @returns a TreatmentPlans object
1263
- */;
1900
+ */
1901
+ ;
1902
+
1264
1903
  _proto.getTreatmentPlansPopulatedFromConsultUuid = function getTreatmentPlansPopulatedFromConsultUuid(uuidConsult) {
1265
1904
  return this.api.get(this.baseURL + "/v1/treatment-plans/", {
1266
1905
  params: {
@@ -1269,9 +1908,11 @@ var DiagnosisService = /*#__PURE__*/function () {
1269
1908
  }
1270
1909
  });
1271
1910
  };
1911
+
1272
1912
  _proto.postPlans = function postPlans(plans) {
1273
1913
  return this.api.post(this.baseURL + "/v1/treatment-plans", plans);
1274
1914
  };
1915
+
1275
1916
  _proto.updateTreatmentPlan = function updateTreatmentPlan(uuidPlan, uuidConsult, diagnosisRequest, plan, refill) {
1276
1917
  return this.api.put(this.baseURL + "/v1/treatment-plans/" + uuidPlan, {
1277
1918
  uuidConsult: uuidConsult,
@@ -1280,6 +1921,7 @@ var DiagnosisService = /*#__PURE__*/function () {
1280
1921
  refill: refill
1281
1922
  });
1282
1923
  };
1924
+
1283
1925
  _proto.acceptTreatmentPlan = function acceptTreatmentPlan(uuidPlan, uuidConsult) {
1284
1926
  return this.api.put(this.baseURL + "/v1/treatment-plans/" + uuidPlan + "/accept", {
1285
1927
  uuidConsult: uuidConsult
@@ -1288,27 +1930,34 @@ var DiagnosisService = /*#__PURE__*/function () {
1288
1930
  /**
1289
1931
  * retrieves all the drugs of the specified practice
1290
1932
  * @param uuidPractice
1291
- */;
1933
+ */
1934
+ ;
1935
+
1292
1936
  _proto.getAllDrugs =
1293
1937
  /*#__PURE__*/
1294
1938
  function () {
1295
- var _getAllDrugs = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(uuidPractice) {
1939
+ var _getAllDrugs = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(uuidPractice) {
1296
1940
  var res;
1297
- return _regeneratorRuntime().wrap(function _callee$(_context) {
1941
+ return runtime_1.wrap(function _callee$(_context) {
1298
1942
  while (1) {
1299
1943
  switch (_context.prev = _context.next) {
1300
1944
  case 0:
1301
1945
  _context.next = 2;
1302
1946
  return this.api.get(this.baseURL + "/v1/drugs/practice/" + uuidPractice);
1947
+
1303
1948
  case 2:
1304
1949
  res = _context.sent;
1950
+
1305
1951
  if (!(res && res.foundDrugs)) {
1306
1952
  _context.next = 5;
1307
1953
  break;
1308
1954
  }
1955
+
1309
1956
  return _context.abrupt("return", res.foundDrugs);
1957
+
1310
1958
  case 5:
1311
1959
  return _context.abrupt("return", undefined);
1960
+
1312
1961
  case 6:
1313
1962
  case "end":
1314
1963
  return _context.stop();
@@ -1316,11 +1965,14 @@ var DiagnosisService = /*#__PURE__*/function () {
1316
1965
  }
1317
1966
  }, _callee, this);
1318
1967
  }));
1968
+
1319
1969
  function getAllDrugs(_x) {
1320
1970
  return _getAllDrugs.apply(this, arguments);
1321
1971
  }
1972
+
1322
1973
  return getAllDrugs;
1323
1974
  }();
1975
+
1324
1976
  return DiagnosisService;
1325
1977
  }();
1326
1978
 
@@ -1329,6 +1981,7 @@ var GuardService = /*#__PURE__*/function () {
1329
1981
  this.api = api;
1330
1982
  this.baseURL = baseURL;
1331
1983
  this.api.setAuthRefreshFn(this.authRefresh.bind(this)); // This is the default behavior for User JWT tokens. If you want other kind of refresh you shall overwrite this call
1984
+
1332
1985
  this.identityCache = {};
1333
1986
  this.whoAmICache = {};
1334
1987
  }
@@ -1343,7 +1996,10 @@ var GuardService = /*#__PURE__*/function () {
1343
1996
  * ```
1344
1997
  * @param tokens
1345
1998
  */
1999
+
2000
+
1346
2001
  var _proto = GuardService.prototype;
2002
+
1347
2003
  _proto.setTokens = function setTokens(tokens) {
1348
2004
  this.api.setTokens(_extends({}, this.api.getTokens(), tokens));
1349
2005
  }
@@ -1352,13 +2008,16 @@ var GuardService = /*#__PURE__*/function () {
1352
2008
  *
1353
2009
  * @param req The credentials required to get an access token
1354
2010
  * @returns AuthTokenResponse
1355
- */;
2011
+ */
2012
+ ;
2013
+
1356
2014
  _proto.m2mToken =
1357
2015
  /*#__PURE__*/
1358
2016
  function () {
1359
- var _m2mToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(req) {
2017
+ var _m2mToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(req) {
1360
2018
  var resp, config, _e$response, code;
1361
- return _regeneratorRuntime().wrap(function _callee$(_context) {
2019
+
2020
+ return runtime_1.wrap(function _callee$(_context) {
1362
2021
  while (1) {
1363
2022
  switch (_context.prev = _context.next) {
1364
2023
  case 0:
@@ -1368,6 +2027,7 @@ var GuardService = /*#__PURE__*/function () {
1368
2027
  };
1369
2028
  _context.next = 4;
1370
2029
  return this.api.post(this.baseURL + "/v1/m2m/token", req, config);
2030
+
1371
2031
  case 4:
1372
2032
  resp = _context.sent;
1373
2033
  this.api.setTokens({
@@ -1375,28 +2035,37 @@ var GuardService = /*#__PURE__*/function () {
1375
2035
  });
1376
2036
  _context.next = 20;
1377
2037
  break;
2038
+
1378
2039
  case 8:
1379
2040
  _context.prev = 8;
1380
2041
  _context.t0 = _context["catch"](0);
1381
2042
  console.error('Error while posting m2m token:', _context.t0);
2043
+
1382
2044
  if (!_context.t0.isAxiosError) {
1383
2045
  _context.next = 19;
1384
2046
  break;
1385
2047
  }
2048
+
1386
2049
  code = (_e$response = _context.t0.response) == null ? void 0 : _e$response.status;
1387
2050
  _context.t1 = code;
1388
2051
  _context.next = _context.t1 === 400 ? 16 : _context.t1 === 500 ? 17 : _context.t1 === 401 ? 18 : 18;
1389
2052
  break;
2053
+
1390
2054
  case 16:
1391
2055
  throw new AuthenticationBadRequest();
2056
+
1392
2057
  case 17:
1393
2058
  throw new AuthenticationServerError();
2059
+
1394
2060
  case 18:
1395
2061
  throw new AuthenticationFailed();
2062
+
1396
2063
  case 19:
1397
2064
  throw new AuthenticationFailed();
2065
+
1398
2066
  case 20:
1399
2067
  return _context.abrupt("return", resp);
2068
+
1400
2069
  case 21:
1401
2070
  case "end":
1402
2071
  return _context.stop();
@@ -1404,23 +2073,29 @@ var GuardService = /*#__PURE__*/function () {
1404
2073
  }
1405
2074
  }, _callee, this, [[0, 8]]);
1406
2075
  }));
2076
+
1407
2077
  function m2mToken(_x) {
1408
2078
  return _m2mToken.apply(this, arguments);
1409
2079
  }
2080
+
1410
2081
  return m2mToken;
1411
- }() /**
1412
- * Allow to retrieve an access token and a refresh token in order
1413
- * to do authenticated request afterward
1414
- *
1415
- * @param req The credentials required to get an access token
1416
- * @returns AuthTokenResponse
1417
- */;
2082
+ }()
2083
+ /**
2084
+ * Allow to retrieve an access token and a refresh token in order
2085
+ * to do authenticated request afterward
2086
+ *
2087
+ * @param req The credentials required to get an access token
2088
+ * @returns AuthTokenResponse
2089
+ */
2090
+ ;
2091
+
1418
2092
  _proto.authToken =
1419
2093
  /*#__PURE__*/
1420
2094
  function () {
1421
- var _authToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(req) {
2095
+ var _authToken = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(req) {
1422
2096
  var resp, config, _e$response2, code;
1423
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
2097
+
2098
+ return runtime_1.wrap(function _callee2$(_context2) {
1424
2099
  while (1) {
1425
2100
  switch (_context2.prev = _context2.next) {
1426
2101
  case 0:
@@ -1430,6 +2105,7 @@ var GuardService = /*#__PURE__*/function () {
1430
2105
  };
1431
2106
  _context2.next = 4;
1432
2107
  return this.api.post(this.baseURL + "/v1/auth/token", req, config);
2108
+
1433
2109
  case 4:
1434
2110
  resp = _context2.sent;
1435
2111
  this.api.setTokens({
@@ -1438,30 +2114,40 @@ var GuardService = /*#__PURE__*/function () {
1438
2114
  });
1439
2115
  _context2.next = 21;
1440
2116
  break;
2117
+
1441
2118
  case 8:
1442
2119
  _context2.prev = 8;
1443
2120
  _context2.t0 = _context2["catch"](0);
1444
2121
  console.error('Error while posting auth token:', _context2.t0);
2122
+
1445
2123
  if (!_context2.t0.isAxiosError) {
1446
2124
  _context2.next = 20;
1447
2125
  break;
1448
2126
  }
2127
+
1449
2128
  code = (_e$response2 = _context2.t0.response) == null ? void 0 : _e$response2.status;
1450
2129
  _context2.t1 = code;
1451
2130
  _context2.next = _context2.t1 === 400 ? 16 : _context2.t1 === 424 ? 17 : _context2.t1 === 500 ? 18 : _context2.t1 === 401 ? 19 : 19;
1452
2131
  break;
2132
+
1453
2133
  case 16:
1454
2134
  throw new AuthenticationBadRequest();
2135
+
1455
2136
  case 17:
1456
2137
  throw new AuthenticationUnconfirmedEmail();
2138
+
1457
2139
  case 18:
1458
2140
  throw new AuthenticationServerError();
2141
+
1459
2142
  case 19:
1460
2143
  throw new AuthenticationFailed();
2144
+
1461
2145
  case 20:
1462
2146
  throw new AuthenticationFailed();
2147
+
1463
2148
  case 21:
1464
2149
  return _context2.abrupt("return", resp);
2150
+
1465
2151
  case 22:
1466
2152
  case "end":
1467
2153
  return _context2.stop();
@@ -1469,21 +2155,26 @@ var GuardService = /*#__PURE__*/function () {
1469
2155
  }
1470
2156
  }, _callee2, this, [[0, 8]]);
1471
2157
  }));
2158
+
1472
2159
  function authToken(_x2) {
1473
2160
  return _authToken.apply(this, arguments);
1474
2161
  }
2162
+
1475
2163
  return authToken;
1476
- }() /**
1477
- * Get new access and refresh token
1478
- *
1479
- * @returns AuthTokenResponse
1480
- */;
2164
+ }()
2165
+ /**
2166
+ * Get new access and refresh token
2167
+ *
2168
+ * @returns AuthTokenResponse
2169
+ */
2170
+ ;
2171
+
1481
2172
  _proto.authRefresh =
1482
2173
  /*#__PURE__*/
1483
2174
  function () {
1484
- var _authRefresh = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(refreshToken) {
2175
+ var _authRefresh = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(refreshToken) {
1485
2176
  var config;
1486
- return _regeneratorRuntime().wrap(function _callee3$(_context3) {
2177
+ return runtime_1.wrap(function _callee3$(_context3) {
1487
2178
  while (1) {
1488
2179
  switch (_context3.prev = _context3.next) {
1489
2180
  case 0:
@@ -1492,6 +2183,7 @@ var GuardService = /*#__PURE__*/function () {
1492
2183
  useRefreshToken: true
1493
2184
  };
1494
2185
  return _context3.abrupt("return", this.api.put(this.baseURL + "/v1/auth/token", null, config));
2186
+
1495
2187
  case 2:
1496
2188
  case "end":
1497
2189
  return _context3.stop();
@@ -1499,24 +2191,30 @@ var GuardService = /*#__PURE__*/function () {
1499
2191
  }
1500
2192
  }, _callee3, this);
1501
2193
  }));
2194
+
1502
2195
  function authRefresh(_x3) {
1503
2196
  return _authRefresh.apply(this, arguments);
1504
2197
  }
2198
+
1505
2199
  return authRefresh;
1506
- }() /**
1507
- * Call guard to overwrite existing refresh token cookie
1508
- *
1509
- * @returns void
1510
- */;
2200
+ }()
2201
+ /**
2202
+ * Call guard to overwrite existing refresh token cookie
2203
+ *
2204
+ * @returns void
2205
+ */
2206
+ ;
2207
+
1511
2208
  _proto.authLogout =
1512
2209
  /*#__PURE__*/
1513
2210
  function () {
1514
- var _authLogout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
1515
- return _regeneratorRuntime().wrap(function _callee4$(_context4) {
2211
+ var _authLogout = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4() {
2212
+ return runtime_1.wrap(function _callee4$(_context4) {
1516
2213
  while (1) {
1517
2214
  switch (_context4.prev = _context4.next) {
1518
2215
  case 0:
1519
2216
  return _context4.abrupt("return", this.api.get(this.baseURL + "/v1/auth/logout"));
2217
+
1520
2218
  case 1:
1521
2219
  case "end":
1522
2220
  return _context4.stop();
@@ -1524,25 +2222,31 @@ var GuardService = /*#__PURE__*/function () {
1524
2222
  }
1525
2223
  }, _callee4, this);
1526
2224
  }));
2225
+
1527
2226
  function authLogout() {
1528
2227
  return _authLogout.apply(this, arguments);
1529
2228
  }
2229
+
1530
2230
  return authLogout;
1531
- }() /**
1532
- * Call guard to attempt account recovery
1533
- *
1534
- * @param req The email address / practice of the account to recover
1535
- * @returns void
1536
- */;
2231
+ }()
2232
+ /**
2233
+ * Call guard to attempt account recovery
2234
+ *
2235
+ * @param req The email address / practice of the account to recover
2236
+ * @returns void
2237
+ */
2238
+ ;
2239
+
1537
2240
  _proto.authRecover =
1538
2241
  /*#__PURE__*/
1539
2242
  function () {
1540
- var _authRecover = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(req) {
1541
- return _regeneratorRuntime().wrap(function _callee5$(_context5) {
2243
+ var _authRecover = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5(req) {
2244
+ return runtime_1.wrap(function _callee5$(_context5) {
1542
2245
  while (1) {
1543
2246
  switch (_context5.prev = _context5.next) {
1544
2247
  case 0:
1545
2248
  return _context5.abrupt("return", this.api.post(this.baseURL + "/v1/auth/recover", req));
2249
+
1546
2250
  case 1:
1547
2251
  case "end":
1548
2252
  return _context5.stop();
@@ -1550,29 +2254,36 @@ var GuardService = /*#__PURE__*/function () {
1550
2254
  }
1551
2255
  }, _callee5, this);
1552
2256
  }));
2257
+
1553
2258
  function authRecover(_x4) {
1554
2259
  return _authRecover.apply(this, arguments);
1555
2260
  }
2261
+
1556
2262
  return authRecover;
1557
- }() /**
1558
- * Allow to create a new identity. The identity will then need to be confirmed
1559
- * via an email link
1560
- *
1561
- * @param req the information about the new identity to create
1562
- * @returns IdentityResponse
1563
- */;
2263
+ }()
2264
+ /**
2265
+ * Allow to create a new identity. The identity will then need to be confirmed
2266
+ * via an email link
2267
+ *
2268
+ * @param req the information about the new identity to create
2269
+ * @returns IdentityResponse
2270
+ */
2271
+ ;
2272
+
1564
2273
  _proto.identityCreate =
1565
2274
  /*#__PURE__*/
1566
2275
  function () {
1567
- var _identityCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(req) {
2276
+ var _identityCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(req) {
1568
2277
  var resp, _e$response3, code;
1569
- return _regeneratorRuntime().wrap(function _callee6$(_context6) {
2278
+
2279
+ return runtime_1.wrap(function _callee6$(_context6) {
1570
2280
  while (1) {
1571
2281
  switch (_context6.prev = _context6.next) {
1572
2282
  case 0:
1573
2283
  _context6.prev = 0;
1574
2284
  _context6.next = 3;
1575
2285
  return this.api.post(this.baseURL + "/v1/identities", req);
2286
+
1576
2287
  case 3:
1577
2288
  resp = _context6.sent;
1578
2289
  this.api.setTokens({
@@ -1580,27 +2291,36 @@ var GuardService = /*#__PURE__*/function () {
1580
2291
  });
1581
2292
  _context6.next = 18;
1582
2293
  break;
2294
+
1583
2295
  case 7:
1584
2296
  _context6.prev = 7;
1585
2297
  _context6.t0 = _context6["catch"](0);
2298
+
1586
2299
  if (!_context6.t0.isAxiosError) {
1587
2300
  _context6.next = 17;
1588
2301
  break;
1589
2302
  }
2303
+
1590
2304
  code = (_e$response3 = _context6.t0.response) == null ? void 0 : _e$response3.status;
1591
2305
  _context6.t1 = code;
1592
2306
  _context6.next = _context6.t1 === 400 ? 14 : _context6.t1 === 409 ? 15 : _context6.t1 === 500 ? 16 : 16;
1593
2307
  break;
2308
+
1594
2309
  case 14:
1595
2310
  throw new IdentityCreationBadRequest();
2311
+
1596
2312
  case 15:
1597
2313
  throw new IdentityCreationConflict();
2314
+
1598
2315
  case 16:
1599
2316
  throw new IdentityCreationFailed();
2317
+
1600
2318
  case 17:
1601
2319
  throw new IdentityCreationFailed();
2320
+
1602
2321
  case 18:
1603
2322
  return _context6.abrupt("return", resp);
2323
+
1604
2324
  case 19:
1605
2325
  case "end":
1606
2326
  return _context6.stop();
@@ -1608,50 +2328,65 @@ var GuardService = /*#__PURE__*/function () {
1608
2328
  }
1609
2329
  }, _callee6, this, [[0, 7]]);
1610
2330
  }));
2331
+
1611
2332
  function identityCreate(_x5) {
1612
2333
  return _identityCreate.apply(this, arguments);
1613
2334
  }
2335
+
1614
2336
  return identityCreate;
1615
- }() /**
1616
- * Retrieve an identity. Will return public fields only when requested
1617
- * without authentication
1618
- *
1619
- * @param identityID Unique id of the identity to retrieve
1620
- * @param skipCache (default: false) will skip identity cache (not even update it)
1621
- * @returns IdentityResponse
1622
- */;
2337
+ }()
2338
+ /**
2339
+ * Retrieve an identity. Will return public fields only when requested
2340
+ * without authentication
2341
+ *
2342
+ * @param identityID Unique id of the identity to retrieve
2343
+ * @param skipCache (default: false) will skip identity cache (not even update it)
2344
+ * @returns IdentityResponse
2345
+ */
2346
+ ;
2347
+
1623
2348
  _proto.identityGet =
1624
2349
  /*#__PURE__*/
1625
2350
  function () {
1626
- var _identityGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(identityID, skipCache) {
2351
+ var _identityGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(identityID, skipCache) {
1627
2352
  var _tokens$accessToken, _tokens$refreshToken;
2353
+
1628
2354
  var tokens, cacheKey, identity;
1629
- return _regeneratorRuntime().wrap(function _callee7$(_context7) {
2355
+ return runtime_1.wrap(function _callee7$(_context7) {
1630
2356
  while (1) {
1631
2357
  switch (_context7.prev = _context7.next) {
1632
2358
  case 0:
1633
2359
  if (skipCache === void 0) {
1634
2360
  skipCache = false;
1635
2361
  }
2362
+
1636
2363
  tokens = this.api.getTokens();
1637
2364
  cacheKey = ((_tokens$accessToken = tokens.accessToken) != null ? _tokens$accessToken : '') + ((_tokens$refreshToken = tokens.refreshToken) != null ? _tokens$refreshToken : '') + identityID;
2365
+
1638
2366
  if (!(skipCache || !tokens.accessToken || !this.identityCache[cacheKey])) {
1639
2367
  _context7.next = 10;
1640
2368
  break;
1641
2369
  }
2370
+
1642
2371
  _context7.next = 6;
1643
2372
  return this.api.get(this.baseURL + "/v1/identities/" + identityID);
2373
+
1644
2374
  case 6:
1645
2375
  identity = _context7.sent;
2376
+
1646
2377
  if (!skipCache) {
1647
2378
  _context7.next = 9;
1648
2379
  break;
1649
2380
  }
2381
+
1650
2382
  return _context7.abrupt("return", identity);
2383
+
1651
2384
  case 9:
1652
2385
  this.identityCache[cacheKey] = identity;
2386
+
1653
2387
  case 10:
1654
2388
  return _context7.abrupt("return", this.identityCache[cacheKey]);
2389
+
1655
2390
  case 11:
1656
2391
  case "end":
1657
2392
  return _context7.stop();
@@ -1659,40 +2394,52 @@ var GuardService = /*#__PURE__*/function () {
1659
2394
  }
1660
2395
  }, _callee7, this);
1661
2396
  }));
2397
+
1662
2398
  function identityGet(_x6, _x7) {
1663
2399
  return _identityGet.apply(this, arguments);
1664
2400
  }
2401
+
1665
2402
  return identityGet;
1666
- }() /**
1667
- * Get information about the current authenticated user
1668
- *
1669
- * @param refreshCache if true it will refresh the whoAmI cache (default: false)
1670
- * @returns WhoAmIResponse
1671
- */;
2403
+ }()
2404
+ /**
2405
+ * Get information about the current authenticated user
2406
+ *
2407
+ * @param refreshCache if true it will refresh the whoAmI cache (default: false)
2408
+ * @returns WhoAmIResponse
2409
+ */
2410
+ ;
2411
+
1672
2412
  _proto.whoAmI =
1673
2413
  /*#__PURE__*/
1674
2414
  function () {
1675
- var _whoAmI = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(refreshCache) {
2415
+ var _whoAmI = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(refreshCache) {
1676
2416
  var _this$api$getTokens$a;
2417
+
1677
2418
  var cacheKey;
1678
- return _regeneratorRuntime().wrap(function _callee8$(_context8) {
2419
+ return runtime_1.wrap(function _callee8$(_context8) {
1679
2420
  while (1) {
1680
2421
  switch (_context8.prev = _context8.next) {
1681
2422
  case 0:
1682
2423
  if (refreshCache === void 0) {
1683
2424
  refreshCache = false;
1684
2425
  }
2426
+
1685
2427
  cacheKey = (_this$api$getTokens$a = this.api.getTokens().accessToken) != null ? _this$api$getTokens$a : '';
2428
+
1686
2429
  if (!(!this.whoAmICache[cacheKey] || refreshCache)) {
1687
2430
  _context8.next = 6;
1688
2431
  break;
1689
2432
  }
2433
+
1690
2434
  _context8.next = 5;
1691
2435
  return this.api.get(this.baseURL + "/v1/auth/whoami");
2436
+
1692
2437
  case 5:
1693
2438
  this.whoAmICache[cacheKey] = _context8.sent;
2439
+
1694
2440
  case 6:
1695
2441
  return _context8.abrupt("return", this.whoAmICache[cacheKey]);
2442
+
1696
2443
  case 7:
1697
2444
  case "end":
1698
2445
  return _context8.stop();
@@ -1700,26 +2447,32 @@ var GuardService = /*#__PURE__*/function () {
1700
2447
  }
1701
2448
  }, _callee8, this);
1702
2449
  }));
2450
+
1703
2451
  function whoAmI(_x8) {
1704
2452
  return _whoAmI.apply(this, arguments);
1705
2453
  }
2454
+
1706
2455
  return whoAmI;
1707
- }() /**
1708
- * Update an existing identity
1709
- *
1710
- * @param identityID unique id of identity to update
1711
- * @param req update request
1712
- * @returns IdentityResponse
1713
- */;
2456
+ }()
2457
+ /**
2458
+ * Update an existing identity
2459
+ *
2460
+ * @param identityID unique id of identity to update
2461
+ * @param req update request
2462
+ * @returns IdentityResponse
2463
+ */
2464
+ ;
2465
+
1714
2466
  _proto.identityUpdate =
1715
2467
  /*#__PURE__*/
1716
2468
  function () {
1717
- var _identityUpdate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(identityID, req) {
1718
- return _regeneratorRuntime().wrap(function _callee9$(_context9) {
2469
+ var _identityUpdate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(identityID, req) {
2470
+ return runtime_1.wrap(function _callee9$(_context9) {
1719
2471
  while (1) {
1720
2472
  switch (_context9.prev = _context9.next) {
1721
2473
  case 0:
1722
2474
  return _context9.abrupt("return", this.api.put(this.baseURL + "/v1/identities/" + identityID, req));
2475
+
1723
2476
  case 1:
1724
2477
  case "end":
1725
2478
  return _context9.stop();
@@ -1727,24 +2480,29 @@ var GuardService = /*#__PURE__*/function () {
1727
2480
  }
1728
2481
  }, _callee9, this);
1729
2482
  }));
2483
+
1730
2484
  function identityUpdate(_x9, _x10) {
1731
2485
  return _identityUpdate.apply(this, arguments);
1732
2486
  }
2487
+
1733
2488
  return identityUpdate;
1734
- }() /**
1735
- * Return base64 data representing a QR code that the
1736
- * current identity need in order to use MFA
1737
- *
1738
- * @param identityID unique id of the identity
1739
- * @param password the identity password (already hashed and in base64)
1740
- * @returns QRCodeResponse
1741
- */;
2489
+ }()
2490
+ /**
2491
+ * Return base64 data representing a QR code that the
2492
+ * current identity need in order to use MFA
2493
+ *
2494
+ * @param identityID unique id of the identity
2495
+ * @param password the identity password (already hashed and in base64)
2496
+ * @returns QRCodeResponse
2497
+ */
2498
+ ;
2499
+
1742
2500
  _proto.identityMFAQRCode =
1743
2501
  /*#__PURE__*/
1744
2502
  function () {
1745
- var _identityMFAQRCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(identityID, password) {
2503
+ var _identityMFAQRCode = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(identityID, password) {
1746
2504
  var req;
1747
- return _regeneratorRuntime().wrap(function _callee10$(_context10) {
2505
+ return runtime_1.wrap(function _callee10$(_context10) {
1748
2506
  while (1) {
1749
2507
  switch (_context10.prev = _context10.next) {
1750
2508
  case 0:
@@ -1756,6 +2514,7 @@ var GuardService = /*#__PURE__*/function () {
1756
2514
  Accept: 'application/json'
1757
2515
  }
1758
2516
  }));
2517
+
1759
2518
  case 2:
1760
2519
  case "end":
1761
2520
  return _context10.stop();
@@ -1763,25 +2522,31 @@ var GuardService = /*#__PURE__*/function () {
1763
2522
  }
1764
2523
  }, _callee10, this);
1765
2524
  }));
2525
+
1766
2526
  function identityMFAQRCode(_x11, _x12) {
1767
2527
  return _identityMFAQRCode.apply(this, arguments);
1768
2528
  }
2529
+
1769
2530
  return identityMFAQRCode;
1770
- }() /**
1771
- * Attempt to resend the email confirmation email
1772
- *
1773
- * @param req IdentityResendConfirmEmailRequest
1774
- * @return void
1775
- */;
2531
+ }()
2532
+ /**
2533
+ * Attempt to resend the email confirmation email
2534
+ *
2535
+ * @param req IdentityResendConfirmEmailRequest
2536
+ * @return void
2537
+ */
2538
+ ;
2539
+
1776
2540
  _proto.identitySendConfirmEmail =
1777
2541
  /*#__PURE__*/
1778
2542
  function () {
1779
- var _identitySendConfirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(req) {
1780
- return _regeneratorRuntime().wrap(function _callee11$(_context11) {
2543
+ var _identitySendConfirmEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(req) {
2544
+ return runtime_1.wrap(function _callee11$(_context11) {
1781
2545
  while (1) {
1782
2546
  switch (_context11.prev = _context11.next) {
1783
2547
  case 0:
1784
2548
  return _context11.abrupt("return", this.api.post(this.baseURL + "/v1/identity/confirm", req));
2549
+
1785
2550
  case 1:
1786
2551
  case "end":
1787
2552
  return _context11.stop();
@@ -1789,25 +2554,31 @@ var GuardService = /*#__PURE__*/function () {
1789
2554
  }
1790
2555
  }, _callee11, this);
1791
2556
  }));
2557
+
1792
2558
  function identitySendConfirmEmail(_x13) {
1793
2559
  return _identitySendConfirmEmail.apply(this, arguments);
1794
2560
  }
2561
+
1795
2562
  return identitySendConfirmEmail;
1796
- }() /**
1797
- * Get an identity using a customer email (format: customer+[b64Hash]@orohealth.me)
1798
- *
1799
- * @param email the customer email
1800
- * @returns IdentityResponse
1801
- */;
2563
+ }()
2564
+ /**
2565
+ * Get an identity using a customer email (format: customer+[b64Hash]@orohealth.me)
2566
+ *
2567
+ * @param email the customer email
2568
+ * @returns IdentityResponse
2569
+ */
2570
+ ;
2571
+
1802
2572
  _proto.identityGetByCustomerEmail =
1803
2573
  /*#__PURE__*/
1804
2574
  function () {
1805
- var _identityGetByCustomerEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(email) {
1806
- return _regeneratorRuntime().wrap(function _callee12$(_context12) {
2575
+ var _identityGetByCustomerEmail = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(email) {
2576
+ return runtime_1.wrap(function _callee12$(_context12) {
1807
2577
  while (1) {
1808
2578
  switch (_context12.prev = _context12.next) {
1809
2579
  case 0:
1810
2580
  return _context12.abrupt("return", this.identityGetByHash(email.substring(email.indexOf('+') + 1, email.indexOf('@'))));
2581
+
1811
2582
  case 1:
1812
2583
  case "end":
1813
2584
  return _context12.stop();
@@ -1815,25 +2586,31 @@ var GuardService = /*#__PURE__*/function () {
1815
2586
  }
1816
2587
  }, _callee12, this);
1817
2588
  }));
2589
+
1818
2590
  function identityGetByCustomerEmail(_x14) {
1819
2591
  return _identityGetByCustomerEmail.apply(this, arguments);
1820
2592
  }
2593
+
1821
2594
  return identityGetByCustomerEmail;
1822
- }() /**
1823
- * Get an identity using a base64 hash
1824
- *
1825
- * @param b64Hash base64 hash of the identity
1826
- * @returns IdentityResponse
1827
- */;
2595
+ }()
2596
+ /**
2597
+ * Get an identity using a base64 hash
2598
+ *
2599
+ * @param b64Hash base64 hash of the identity
2600
+ * @returns IdentityResponse
2601
+ */
2602
+ ;
2603
+
1828
2604
  _proto.identityGetByHash =
1829
2605
  /*#__PURE__*/
1830
2606
  function () {
1831
- var _identityGetByHash = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee13(b64Hash) {
1832
- return _regeneratorRuntime().wrap(function _callee13$(_context13) {
2607
+ var _identityGetByHash = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee13(b64Hash) {
2608
+ return runtime_1.wrap(function _callee13$(_context13) {
1833
2609
  while (1) {
1834
2610
  switch (_context13.prev = _context13.next) {
1835
2611
  case 0:
1836
2612
  return _context13.abrupt("return", this.identityGet(b64Hash.replace(/\+/g, '-').replace(/\//g, '_')));
2613
+
1837
2614
  case 1:
1838
2615
  case "end":
1839
2616
  return _context13.stop();
@@ -1841,11 +2618,14 @@ var GuardService = /*#__PURE__*/function () {
1841
2618
  }
1842
2619
  }, _callee13, this);
1843
2620
  }));
2621
+
1844
2622
  function identityGetByHash(_x15) {
1845
2623
  return _identityGetByHash.apply(this, arguments);
1846
2624
  }
2625
+
1847
2626
  return identityGetByHash;
1848
2627
  }();
2628
+
1849
2629
  return GuardService;
1850
2630
  }();
1851
2631
 
@@ -1859,7 +2639,10 @@ var SearchService = /*#__PURE__*/function () {
1859
2639
  * @param consultUUID
1860
2640
  * @param terms the search terms to be indexed
1861
2641
  */
2642
+
2643
+
1862
2644
  var _proto = SearchService.prototype;
2645
+
1863
2646
  _proto.index = function index(consultUUID, terms) {
1864
2647
  return this.api.post(this.baseURL + "/v1/index", {
1865
2648
  consultUUID: consultUUID,
@@ -1869,12 +2652,15 @@ var SearchService = /*#__PURE__*/function () {
1869
2652
  /**
1870
2653
  * Searches for the consultations corresponding to the search terms entered in the query
1871
2654
  * @param terms array of search terms
1872
- */;
2655
+ */
2656
+ ;
2657
+
1873
2658
  _proto.search = function search(terms) {
1874
2659
  return this.api.post(this.baseURL + "/v1/search", {
1875
2660
  terms: terms
1876
2661
  });
1877
2662
  };
2663
+
1878
2664
  return SearchService;
1879
2665
  }();
1880
2666
 
@@ -1891,7 +2677,10 @@ var PracticeService = /*#__PURE__*/function () {
1891
2677
  * @param accounts (optional) if set true it the Practice field accounts will be set
1892
2678
  * @returns the found practice or undefined
1893
2679
  */
2680
+
2681
+
1894
2682
  var _proto = PracticeService.prototype;
2683
+
1895
2684
  _proto.practiceGetFromURL = function practiceGetFromURL(practiceURL, params) {
1896
2685
  return this.api.get(this.baseURL + "/v1/practices", {
1897
2686
  params: _extends({
@@ -1899,6 +2688,7 @@ var PracticeService = /*#__PURE__*/function () {
1899
2688
  }, params)
1900
2689
  });
1901
2690
  };
2691
+
1902
2692
  _proto.practiceGetFromUuid = function practiceGetFromUuid(practiceUuid, locale, withAccounts) {
1903
2693
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid, {
1904
2694
  params: {
@@ -1906,13 +2696,15 @@ var PracticeService = /*#__PURE__*/function () {
1906
2696
  accounts: withAccounts
1907
2697
  }
1908
2698
  });
1909
- }
1910
- /// Practice Configs
2699
+ } /// Practice Configs
2700
+
1911
2701
  /**
1912
2702
  * This function retrieves all configs of a specific practice
1913
2703
  * @param practiceUuid uuid of the practice
1914
2704
  * @returns the practice configs
1915
- */;
2705
+ */
2706
+ ;
2707
+
1916
2708
  _proto.practiceConfigGetFromPracticeUuid = function practiceConfigGetFromPracticeUuid(practiceUuid) {
1917
2709
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/configs");
1918
2710
  }
@@ -1921,7 +2713,9 @@ var PracticeService = /*#__PURE__*/function () {
1921
2713
  * @param practiceUuid uuid of the practice
1922
2714
  * @param kind of the config
1923
2715
  * @returns the practice config
1924
- */;
2716
+ */
2717
+ ;
2718
+
1925
2719
  _proto.practiceConfigGetByKindForPracticeUuid = function practiceConfigGetByKindForPracticeUuid(practiceUuid, kind) {
1926
2720
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/configs/" + kind);
1927
2721
  }
@@ -1930,7 +2724,9 @@ var PracticeService = /*#__PURE__*/function () {
1930
2724
  * @param practiceUuid uuid of the practice
1931
2725
  * @param config the config to add to the practice
1932
2726
  * @returns the created practice config
1933
- */;
2727
+ */
2728
+ ;
2729
+
1934
2730
  _proto.practiceConfigCreateForPracticeUuid = function practiceConfigCreateForPracticeUuid(practiceUuid, config) {
1935
2731
  return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/configs", config);
1936
2732
  }
@@ -1939,15 +2735,18 @@ var PracticeService = /*#__PURE__*/function () {
1939
2735
  * @param practiceUuid uuid of the practice
1940
2736
  * @param config the config to update
1941
2737
  * @returns the practice config
1942
- */;
2738
+ */
2739
+ ;
2740
+
1943
2741
  _proto.practiceConfigUpdate = function practiceConfigUpdate(config) {
1944
2742
  return this.api.put(this.baseURL + "/v1/practices/" + config.uuidPractice + "/configs/" + config.kind, config);
1945
- }
1946
- /// Accounts
2743
+ } /// Accounts
1947
2744
  ;
2745
+
1948
2746
  _proto.practiceGetAccounts = function practiceGetAccounts(practiceUuid) {
1949
2747
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/accounts");
1950
2748
  };
2749
+
1951
2750
  _proto.practiceGetAccount = function practiceGetAccount(practiceUuid, accountUuid) {
1952
2751
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/accounts/" + accountUuid);
1953
2752
  }
@@ -1956,7 +2755,9 @@ var PracticeService = /*#__PURE__*/function () {
1956
2755
  * @param practiceUuid the uuid of the practice
1957
2756
  * @param kind (optional) the kind of WorkflowType to filter in
1958
2757
  * @returns a list of PracticeWorkflow
1959
- */;
2758
+ */
2759
+ ;
2760
+
1960
2761
  _proto.practiceGetWorkflows = function practiceGetWorkflows(practiceUuid, kind) {
1961
2762
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/workflows", {
1962
2763
  params: {
@@ -1964,11 +2765,12 @@ var PracticeService = /*#__PURE__*/function () {
1964
2765
  }
1965
2766
  });
1966
2767
  };
2768
+
1967
2769
  _proto.practiceGetWorkflow = function practiceGetWorkflow(practiceUuid, workflowType) {
1968
2770
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/workflows/" + workflowType);
1969
- }
1970
- /// Plans
2771
+ } /// Plans
1971
2772
  ;
2773
+
1972
2774
  _proto.practiceGetPlans = function practiceGetPlans(practiceUuid, planType) {
1973
2775
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/plans", {
1974
2776
  params: {
@@ -1976,14 +2778,16 @@ var PracticeService = /*#__PURE__*/function () {
1976
2778
  }
1977
2779
  });
1978
2780
  };
2781
+
1979
2782
  _proto.practiceGetPlan = function practiceGetPlan(practiceUuid, planId) {
1980
2783
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/plans/" + planId);
1981
2784
  };
2785
+
1982
2786
  _proto.practiceGetPlanPrices = function practiceGetPlanPrices(practiceUuid, planId) {
1983
2787
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/plans/" + planId + "/prices");
1984
- }
1985
- // Payments
2788
+ } // Payments
1986
2789
  ;
2790
+
1987
2791
  _proto.practiceGetPayments = function practiceGetPayments(practiceUuid, statusPayment, withConsultUUIDNULL, perPage, indexPage) {
1988
2792
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments", {
1989
2793
  params: {
@@ -1994,14 +2798,16 @@ var PracticeService = /*#__PURE__*/function () {
1994
2798
  }
1995
2799
  });
1996
2800
  };
2801
+
1997
2802
  _proto.practiceGetPayment = function practiceGetPayment(practiceUuid, idStripeInvoiceOrPaymentIntent) {
1998
2803
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/" + idStripeInvoiceOrPaymentIntent);
1999
2804
  };
2805
+
2000
2806
  _proto.practiceGetPaymentForStripePaymentIntentWithID = function practiceGetPaymentForStripePaymentIntentWithID(practiceUuid, stripePaymentIntentId) {
2001
2807
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/" + stripePaymentIntentId);
2002
- }
2003
- // Payments Intent
2808
+ } // Payments Intent
2004
2809
  ;
2810
+
2005
2811
  _proto.practiceGetPaymentsIntents = function practiceGetPaymentsIntents(practiceUuid, planType) {
2006
2812
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/intents", {
2007
2813
  params: {
@@ -2013,7 +2819,9 @@ var PracticeService = /*#__PURE__*/function () {
2013
2819
  * This function return the user hased email to be use for creating payment intent
2014
2820
  * @param email the email to hash
2015
2821
  * @returns a hashed email
2016
- */;
2822
+ */
2823
+ ;
2824
+
2017
2825
  _proto.getPaymentIntentHashedEmail = function getPaymentIntentHashedEmail(email) {
2018
2826
  return hashToBase64String(email.toLowerCase());
2019
2827
  }
@@ -2027,7 +2835,9 @@ var PracticeService = /*#__PURE__*/function () {
2027
2835
  * @param promotionCode (optional) promotion code to apply
2028
2836
  * @param requestMetadata (optional) the request metadata to use. If defined, when payment service call our hooks in practice, it will use it to do required action (create a consult, refill a consult, etc.).
2029
2837
  * @returns
2030
- */;
2838
+ */
2839
+ ;
2840
+
2031
2841
  _proto.practiceCreatePaymentsIntent = function practiceCreatePaymentsIntent(practiceUuid, planId, userEmail, isoLocality, url_subdomain, requestMetadata) {
2032
2842
  return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/intents/", {
2033
2843
  idPlan: planId,
@@ -2040,6 +2850,7 @@ var PracticeService = /*#__PURE__*/function () {
2040
2850
  }
2041
2851
  });
2042
2852
  };
2853
+
2043
2854
  _proto.practiceGetPaymentsIntent = function practiceGetPaymentsIntent(practiceUuid, paymentIntentId) {
2044
2855
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/intents/" + paymentIntentId);
2045
2856
  }
@@ -2052,7 +2863,9 @@ var PracticeService = /*#__PURE__*/function () {
2052
2863
  * @param promotionCode (optional) promotional code to apply
2053
2864
  * @param finalize (optional) if true will finalize the PracticePaymentIntent and related Stripe.Invoice. Once, finalized you cannot modify the PracticePaymentIntent anymore.
2054
2865
  * @returns the updated PracticePaymentIntent
2055
- */;
2866
+ */
2867
+ ;
2868
+
2056
2869
  _proto.practiceUpdatePaymentsIntent = function practiceUpdatePaymentsIntent(practiceUuid, idPraticePaymentIntent, practicePaymentIntent, userEmail, promotionCode, finalize) {
2057
2870
  return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/intents/" + idPraticePaymentIntent, _extends({}, practicePaymentIntent, {
2058
2871
  hashUserEmail: userEmail ? this.getPaymentIntentHashedEmail(userEmail) : undefined
@@ -2067,103 +2880,125 @@ var PracticeService = /*#__PURE__*/function () {
2067
2880
  * Invoice
2068
2881
  * @param practiceUuid UUID of the practice to get the invoice from
2069
2882
  * @param invoiceId ID of the invoice in stripe
2070
- */;
2883
+ */
2884
+ ;
2885
+
2071
2886
  _proto.getInvoice = function getInvoice(practiceUuid, invoiceId) {
2072
2887
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/payments/invoices/" + invoiceId);
2073
- }
2074
- // Practitioner
2888
+ } // Practitioner
2075
2889
  ;
2890
+
2076
2891
  _proto.practiceGetPractitioners = function practiceGetPractitioners(practiceUuid) {
2077
2892
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners");
2078
2893
  };
2894
+
2079
2895
  _proto.practiceUpdatePractitioner = function practiceUpdatePractitioner(practiceUuid, practitionerUuid, requestBody) {
2080
2896
  return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid, requestBody);
2081
2897
  };
2898
+
2082
2899
  _proto.practiceGetPractitioner = function practiceGetPractitioner(practiceUuid, practitionerUuid) {
2083
2900
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid);
2084
- }
2085
- // Practitioner Licenses
2901
+ } // Practitioner Licenses
2086
2902
  ;
2903
+
2087
2904
  _proto.practiceGetPractitionerLicenses = function practiceGetPractitionerLicenses(practiceUuid, practitionerUuid) {
2088
2905
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/licenses");
2089
2906
  };
2907
+
2090
2908
  _proto.practiceCreatePractitionerLicense = function practiceCreatePractitionerLicense(practiceUuid, practitionerUuid, requestBody) {
2091
2909
  return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/licenses", requestBody);
2092
2910
  };
2911
+
2093
2912
  _proto.practiceUpdatePractitionerLicense = function practiceUpdatePractitionerLicense(practiceUuid, practitionerUuid, licenseId, requestBody) {
2094
2913
  return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/licenses/" + licenseId, requestBody);
2095
2914
  };
2915
+
2096
2916
  _proto.practiceGetPractitionerLicense = function practiceGetPractitionerLicense(practiceUuid, practitionerUuid, licenseId) {
2097
2917
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/licenses/" + licenseId);
2098
- }
2099
- // Practitioner Preferences
2918
+ } // Practitioner Preferences
2100
2919
  ;
2920
+
2101
2921
  _proto.practiceGetPractitionerPreferences = function practiceGetPractitionerPreferences(practiceUuid, practitionerUuid) {
2102
2922
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/preferences");
2103
2923
  };
2924
+
2104
2925
  _proto.practiceCreatePractitionerPreference = function practiceCreatePractitionerPreference(practiceUuid, practitionerUuid, requestBody) {
2105
2926
  return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/preferences", requestBody);
2106
2927
  };
2928
+
2107
2929
  _proto.practiceUpdatePractitionerPreference = function practiceUpdatePractitionerPreference(practiceUuid, practitionerUuid, preferenceId, requestBody) {
2108
2930
  return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/preferences/" + preferenceId, requestBody);
2109
2931
  };
2932
+
2110
2933
  _proto.practiceGetPractitionerPreference = function practiceGetPractitionerPreference(practiceUuid, practitionerUuid, preferenceId) {
2111
2934
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/preferences/" + preferenceId);
2112
- }
2113
- // Practitioner Roles
2935
+ } // Practitioner Roles
2114
2936
  ;
2937
+
2115
2938
  _proto.practiceGetPractitionerRoles = function practiceGetPractitionerRoles(practiceUuid, practitionerUuid) {
2116
2939
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles");
2117
2940
  };
2941
+
2118
2942
  _proto.practiceCreatePractitionerRole = function practiceCreatePractitionerRole(practiceUuid, practitionerUuid, requestBody) {
2119
2943
  return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles", requestBody);
2120
2944
  };
2945
+
2121
2946
  _proto.practiceDeletePractitionerRoles = function practiceDeletePractitionerRoles(practiceUuid, practitionerUuid) {
2122
2947
  return this.api.deleteRequest(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles");
2123
2948
  };
2949
+
2124
2950
  _proto.practiceUpdatePractitionerRole = function practiceUpdatePractitionerRole(practiceUuid, practitionerUuid, roleId, requestBody) {
2125
2951
  return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles/" + roleId, requestBody);
2126
2952
  };
2953
+
2127
2954
  _proto.practiceGetPractitionerRole = function practiceGetPractitionerRole(practiceUuid, practitionerUuid, roleId) {
2128
2955
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles/" + roleId);
2129
2956
  };
2957
+
2130
2958
  _proto.practiceDeletePractitionerRole = function practiceDeletePractitionerRole(practiceUuid, practitionerUuid, roleId) {
2131
2959
  return this.api.deleteRequest(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/roles/" + roleId);
2132
- }
2133
- // Practitioner signature
2960
+ } // Practitioner signature
2961
+
2134
2962
  /**
2135
2963
  * This function returns the practitioner's signature as a Blob
2136
2964
  * @param practiceUuid the practice uuid of the practitioner
2137
2965
  * @param practitionerUuid the practitioner uuid
2138
2966
  * @returns a blob representing the signature
2139
- */;
2967
+ */
2968
+ ;
2969
+
2140
2970
  _proto.practiceGetPractitionerSignature = function practiceGetPractitionerSignature(practiceUuid, practitionerUuid) {
2141
2971
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/practitioners/" + practitionerUuid + "/signature", {
2142
2972
  responseType: 'blob'
2143
2973
  });
2144
- }
2145
- // Assignments
2974
+ } // Assignments
2146
2975
  ;
2976
+
2147
2977
  _proto.practiceGetAssignments = function practiceGetAssignments(practiceUuid) {
2148
2978
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/assignments");
2149
2979
  };
2980
+
2150
2981
  _proto.practiceCreateAssignment = function practiceCreateAssignment(practiceUuid, requestBody) {
2151
2982
  return this.api.post(this.baseURL + "/v1/practices/" + practiceUuid + "/assignments", requestBody);
2152
2983
  };
2984
+
2153
2985
  _proto.practiceUpdateAssignment = function practiceUpdateAssignment(practiceUuid, assignmentId, requestBody) {
2154
2986
  return this.api.put(this.baseURL + "/v1/practices/" + practiceUuid + "/assignments/" + assignmentId, requestBody);
2155
2987
  };
2988
+
2156
2989
  _proto.practiceGetAssignment = function practiceGetAssignment(practiceUuid, assignmentId) {
2157
2990
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/assignments/" + assignmentId);
2158
- }
2159
- // Quotas
2991
+ } // Quotas
2160
2992
  ;
2993
+
2161
2994
  _proto.practiceGetQuotas = function practiceGetQuotas(practiceUuid) {
2162
2995
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/quotas");
2163
2996
  };
2997
+
2164
2998
  _proto.practiceGetQuota = function practiceGetQuota(practiceUuid, quotaId) {
2165
2999
  return this.api.get(this.baseURL + "/v1/practices/" + practiceUuid + "/quotas/" + quotaId);
2166
3000
  };
3001
+
2167
3002
  return PracticeService;
2168
3003
  }();
2169
3004
 
@@ -2172,10 +3007,12 @@ var TellerService = /*#__PURE__*/function () {
2172
3007
  this.api = api;
2173
3008
  this.baseURL = baseURL;
2174
3009
  }
3010
+
2175
3011
  var _proto = TellerService.prototype;
3012
+
2176
3013
  _proto.lockboxDataStore = /*#__PURE__*/function () {
2177
- var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
2178
- return _regeneratorRuntime().wrap(function _callee$(_context) {
3014
+ var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
3015
+ return runtime_1.wrap(function _callee$(_context) {
2179
3016
  while (1) {
2180
3017
  switch (_context.prev = _context.next) {
2181
3018
  case 0:
@@ -2185,6 +3022,7 @@ var TellerService = /*#__PURE__*/function () {
2185
3022
  data_uuid: previousDataUuid
2186
3023
  }
2187
3024
  }));
3025
+
2188
3026
  case 1:
2189
3027
  case "end":
2190
3028
  return _context.stop();
@@ -2192,11 +3030,14 @@ var TellerService = /*#__PURE__*/function () {
2192
3030
  }
2193
3031
  }, _callee, this);
2194
3032
  }));
3033
+
2195
3034
  function lockboxDataStore(_x, _x2, _x3, _x4) {
2196
3035
  return _lockboxDataStore.apply(this, arguments);
2197
3036
  }
3037
+
2198
3038
  return lockboxDataStore;
2199
3039
  }();
3040
+
2200
3041
  _proto.updateConsultByUUID = function updateConsultByUUID(patientUuid, uuidConsult, statusMedical, closedReasonType, closedReasonDescription, neverExpires) {
2201
3042
  return this.api.put(this.baseURL + "/v1/consults/" + uuidConsult, {
2202
3043
  patientUuid: patientUuid,
@@ -2214,7 +3055,9 @@ var TellerService = /*#__PURE__*/function () {
2214
3055
  * @param consultationShortId the consultation short id
2215
3056
  * @param fax the address where to send the fax
2216
3057
  * @returns void
2217
- */;
3058
+ */
3059
+ ;
3060
+
2218
3061
  _proto.notifyFaxFailed = function notifyFaxFailed(practiceUuid, consultationUuid, consultationShortId, fax) {
2219
3062
  return this.api.post(this.baseURL + "/v1/fax-failed", {
2220
3063
  consultationUuid: consultationUuid,
@@ -2231,7 +3074,9 @@ var TellerService = /*#__PURE__*/function () {
2231
3074
  * @todo - Make service only exposed route
2232
3075
  * @param uuidConsult the uuid of the consult to reassign
2233
3076
  * @param newPractitionerUuid the uuid of the practitioner that will get reassigned
2234
- */;
3077
+ */
3078
+ ;
3079
+
2235
3080
  _proto.reassignmentEmail = function reassignmentEmail(uuidConsult, newPractitionerUuid) {
2236
3081
  return this.api.post(this.baseURL + "/v1/consult/" + uuidConsult + "/reassignment-email", {
2237
3082
  newPractitionerUuid: newPractitionerUuid
@@ -2243,7 +3088,9 @@ var TellerService = /*#__PURE__*/function () {
2243
3088
  * @param consult
2244
3089
  * @param patientUuid
2245
3090
  * @returns void
2246
- */;
3091
+ */
3092
+ ;
3093
+
2247
3094
  _proto.sendOnlineFaxSuccessfulEmail = function sendOnlineFaxSuccessfulEmail(consult, patientUuid) {
2248
3095
  return this.api.post(this.baseURL + "/v1/online-fax-notify", {
2249
3096
  consult: consult,
@@ -2254,10 +3101,13 @@ var TellerService = /*#__PURE__*/function () {
2254
3101
  * This function will send an email to patient to allow them to resume the consult.
2255
3102
  * @param req the body of the resume consult request
2256
3103
  * @returns void
2257
- */;
3104
+ */
3105
+ ;
3106
+
2258
3107
  _proto.sendResumeConsultEmail = function sendResumeConsultEmail(req) {
2259
3108
  return this.api.post(this.baseURL + "/v1/resume-consult-email", req);
2260
3109
  };
3110
+
2261
3111
  return TellerService;
2262
3112
  }();
2263
3113
 
@@ -2266,14 +3116,17 @@ var VaultService = /*#__PURE__*/function () {
2266
3116
  this.api = api;
2267
3117
  this.baseURL = baseURL;
2268
3118
  }
3119
+
2269
3120
  var _proto = VaultService.prototype;
3121
+
2270
3122
  _proto.lockboxCreate = /*#__PURE__*/function () {
2271
- var _lockboxCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(lockboxMetadata) {
2272
- return _regeneratorRuntime().wrap(function _callee$(_context) {
3123
+ var _lockboxCreate = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee(lockboxMetadata) {
3124
+ return runtime_1.wrap(function _callee$(_context) {
2273
3125
  while (1) {
2274
3126
  switch (_context.prev = _context.next) {
2275
3127
  case 0:
2276
3128
  return _context.abrupt("return", this.api.post(this.baseURL + "/v1/lockbox", lockboxMetadata));
3129
+
2277
3130
  case 1:
2278
3131
  case "end":
2279
3132
  return _context.stop();
@@ -2281,14 +3134,17 @@ var VaultService = /*#__PURE__*/function () {
2281
3134
  }
2282
3135
  }, _callee, this);
2283
3136
  }));
3137
+
2284
3138
  function lockboxCreate(_x) {
2285
3139
  return _lockboxCreate.apply(this, arguments);
2286
3140
  }
3141
+
2287
3142
  return lockboxCreate;
2288
3143
  }();
3144
+
2289
3145
  _proto.lockboxMetadataAdd = /*#__PURE__*/function () {
2290
- var _lockboxMetadataAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(lockboxUuid, lockboxMetadata, lockboxOwnerUuid) {
2291
- return _regeneratorRuntime().wrap(function _callee2$(_context2) {
3146
+ var _lockboxMetadataAdd = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee2(lockboxUuid, lockboxMetadata, lockboxOwnerUuid) {
3147
+ return runtime_1.wrap(function _callee2$(_context2) {
2292
3148
  while (1) {
2293
3149
  switch (_context2.prev = _context2.next) {
2294
3150
  case 0:
@@ -2297,6 +3153,7 @@ var VaultService = /*#__PURE__*/function () {
2297
3153
  lockbox_owner_uuid: lockboxOwnerUuid
2298
3154
  }
2299
3155
  }));
3156
+
2300
3157
  case 1:
2301
3158
  case "end":
2302
3159
  return _context2.stop();
@@ -2304,14 +3161,17 @@ var VaultService = /*#__PURE__*/function () {
2304
3161
  }
2305
3162
  }, _callee2, this);
2306
3163
  }));
3164
+
2307
3165
  function lockboxMetadataAdd(_x2, _x3, _x4) {
2308
3166
  return _lockboxMetadataAdd.apply(this, arguments);
2309
3167
  }
3168
+
2310
3169
  return lockboxMetadataAdd;
2311
3170
  }();
3171
+
2312
3172
  _proto.lockboxSecretGet = /*#__PURE__*/function () {
2313
- var _lockboxSecretGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(lockboxUuid, lockboxOwnerUuid) {
2314
- return _regeneratorRuntime().wrap(function _callee3$(_context3) {
3173
+ var _lockboxSecretGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee3(lockboxUuid, lockboxOwnerUuid) {
3174
+ return runtime_1.wrap(function _callee3$(_context3) {
2315
3175
  while (1) {
2316
3176
  switch (_context3.prev = _context3.next) {
2317
3177
  case 0:
@@ -2320,6 +3180,7 @@ var VaultService = /*#__PURE__*/function () {
2320
3180
  lockbox_owner_uuid: lockboxOwnerUuid
2321
3181
  }
2322
3182
  }));
3183
+
2323
3184
  case 1:
2324
3185
  case "end":
2325
3186
  return _context3.stop();
@@ -2327,14 +3188,17 @@ var VaultService = /*#__PURE__*/function () {
2327
3188
  }
2328
3189
  }, _callee3, this);
2329
3190
  }));
3191
+
2330
3192
  function lockboxSecretGet(_x5, _x6) {
2331
3193
  return _lockboxSecretGet.apply(this, arguments);
2332
3194
  }
3195
+
2333
3196
  return lockboxSecretGet;
2334
3197
  }();
3198
+
2335
3199
  _proto.lockboxGrant = /*#__PURE__*/function () {
2336
- var _lockboxGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(lockboxUuid, req, lockboxOwnerUuid) {
2337
- return _regeneratorRuntime().wrap(function _callee4$(_context4) {
3200
+ var _lockboxGrant = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee4(lockboxUuid, req, lockboxOwnerUuid) {
3201
+ return runtime_1.wrap(function _callee4$(_context4) {
2338
3202
  while (1) {
2339
3203
  switch (_context4.prev = _context4.next) {
2340
3204
  case 0:
@@ -2343,6 +3207,7 @@ var VaultService = /*#__PURE__*/function () {
2343
3207
  lockbox_owner_uuid: lockboxOwnerUuid
2344
3208
  }
2345
3209
  }));
3210
+
2346
3211
  case 1:
2347
3212
  case "end":
2348
3213
  return _context4.stop();
@@ -2350,24 +3215,30 @@ var VaultService = /*#__PURE__*/function () {
2350
3215
  }
2351
3216
  }, _callee4, this);
2352
3217
  }));
3218
+
2353
3219
  function lockboxGrant(_x7, _x8, _x9) {
2354
3220
  return _lockboxGrant.apply(this, arguments);
2355
3221
  }
3222
+
2356
3223
  return lockboxGrant;
2357
- }() /**
2358
- * Get all lockboxes granted to user
2359
- * @param filter filter of lockbox metadata
2360
- * @returns decrypted lockboxes granted to user
2361
- */;
3224
+ }()
3225
+ /**
3226
+ * Get all lockboxes granted to user
3227
+ * @param filter filter of lockbox metadata
3228
+ * @returns decrypted lockboxes granted to user
3229
+ */
3230
+ ;
3231
+
2362
3232
  _proto.grantsGet =
2363
3233
  /*#__PURE__*/
2364
3234
  function () {
2365
- var _grantsGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
2366
- return _regeneratorRuntime().wrap(function _callee5$(_context5) {
3235
+ var _grantsGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee5() {
3236
+ return runtime_1.wrap(function _callee5$(_context5) {
2367
3237
  while (1) {
2368
3238
  switch (_context5.prev = _context5.next) {
2369
3239
  case 0:
2370
3240
  return _context5.abrupt("return", this.api.get(this.baseURL + "/v1/grants"));
3241
+
2371
3242
  case 1:
2372
3243
  case "end":
2373
3244
  return _context5.stop();
@@ -2375,25 +3246,30 @@ var VaultService = /*#__PURE__*/function () {
2375
3246
  }
2376
3247
  }, _callee5, this);
2377
3248
  }));
3249
+
2378
3250
  function grantsGet() {
2379
3251
  return _grantsGet.apply(this, arguments);
2380
3252
  }
3253
+
2381
3254
  return grantsGet;
2382
- }() /**
2383
- * This function create or update a data into the vault.
2384
- * @note At creation it is necessary to have all `req` filled
2385
- * @note When setting `previousDataUuid` you are updating the data. `req` metadata fields are optional.
2386
- * @param lockboxUuid The lockbox uuid the data will be stored in
2387
- * @param req The request (please see notes)
2388
- * @param lockboxOwnerUuid The uuid of the owner of the lockbox (@deprecated)
2389
- * @param previousDataUuid The data uuid of the data you want to update
2390
- * @returns
2391
- */;
3255
+ }()
3256
+ /**
3257
+ * This function create or update a data into the vault.
3258
+ * @note At creation it is necessary to have all `req` filled
3259
+ * @note When setting `previousDataUuid` you are updating the data. `req` metadata fields are optional.
3260
+ * @param lockboxUuid The lockbox uuid the data will be stored in
3261
+ * @param req The request (please see notes)
3262
+ * @param lockboxOwnerUuid The uuid of the owner of the lockbox (@deprecated)
3263
+ * @param previousDataUuid The data uuid of the data you want to update
3264
+ * @returns
3265
+ */
3266
+ ;
3267
+
2392
3268
  _proto.lockboxDataStore =
2393
3269
  /*#__PURE__*/
2394
3270
  function () {
2395
- var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
2396
- return _regeneratorRuntime().wrap(function _callee6$(_context6) {
3271
+ var _lockboxDataStore = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee6(lockboxUuid, req, lockboxOwnerUuid, previousDataUuid) {
3272
+ return runtime_1.wrap(function _callee6$(_context6) {
2397
3273
  while (1) {
2398
3274
  switch (_context6.prev = _context6.next) {
2399
3275
  case 0:
@@ -2403,6 +3279,7 @@ var VaultService = /*#__PURE__*/function () {
2403
3279
  data_uuid: previousDataUuid
2404
3280
  }
2405
3281
  }));
3282
+
2406
3283
  case 1:
2407
3284
  case "end":
2408
3285
  return _context6.stop();
@@ -2410,21 +3287,25 @@ var VaultService = /*#__PURE__*/function () {
2410
3287
  }
2411
3288
  }, _callee6, this);
2412
3289
  }));
3290
+
2413
3291
  function lockboxDataStore(_x10, _x11, _x12, _x13) {
2414
3292
  return _lockboxDataStore.apply(this, arguments);
2415
3293
  }
3294
+
2416
3295
  return lockboxDataStore;
2417
3296
  }();
3297
+
2418
3298
  _proto.lockboxDataGet = /*#__PURE__*/function () {
2419
- var _lockboxDataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(lockboxUuid, dataUuid, lockboxOwnerUuid, stream) {
3299
+ var _lockboxDataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee7(lockboxUuid, dataUuid, lockboxOwnerUuid, stream) {
2420
3300
  var data;
2421
- return _regeneratorRuntime().wrap(function _callee7$(_context7) {
3301
+ return runtime_1.wrap(function _callee7$(_context7) {
2422
3302
  while (1) {
2423
3303
  switch (_context7.prev = _context7.next) {
2424
3304
  case 0:
2425
3305
  if (stream === void 0) {
2426
3306
  stream = true;
2427
3307
  }
3308
+
2428
3309
  _context7.next = 3;
2429
3310
  return this.api.get(this.baseURL + "/v1/lockboxes/" + lockboxUuid + "/data/" + dataUuid, {
2430
3311
  params: {
@@ -2432,17 +3313,22 @@ var VaultService = /*#__PURE__*/function () {
2432
3313
  stream: stream
2433
3314
  }
2434
3315
  });
3316
+
2435
3317
  case 3:
2436
3318
  data = _context7.sent;
3319
+
2437
3320
  if (!stream) {
2438
3321
  _context7.next = 6;
2439
3322
  break;
2440
3323
  }
3324
+
2441
3325
  return _context7.abrupt("return", {
2442
3326
  data: data
2443
3327
  });
3328
+
2444
3329
  case 6:
2445
3330
  return _context7.abrupt("return", data);
3331
+
2446
3332
  case 7:
2447
3333
  case "end":
2448
3334
  return _context7.stop();
@@ -2450,14 +3336,17 @@ var VaultService = /*#__PURE__*/function () {
2450
3336
  }
2451
3337
  }, _callee7, this);
2452
3338
  }));
3339
+
2453
3340
  function lockboxDataGet(_x14, _x15, _x16, _x17) {
2454
3341
  return _lockboxDataGet.apply(this, arguments);
2455
3342
  }
3343
+
2456
3344
  return lockboxDataGet;
2457
3345
  }();
3346
+
2458
3347
  _proto.lockboxManifestGet = /*#__PURE__*/function () {
2459
- var _lockboxManifestGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(lockboxUuid, filter, lockboxOwnerUuid) {
2460
- return _regeneratorRuntime().wrap(function _callee8$(_context8) {
3348
+ var _lockboxManifestGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee8(lockboxUuid, filter, lockboxOwnerUuid) {
3349
+ return runtime_1.wrap(function _callee8$(_context8) {
2461
3350
  while (1) {
2462
3351
  switch (_context8.prev = _context8.next) {
2463
3352
  case 0:
@@ -2467,6 +3356,7 @@ var VaultService = /*#__PURE__*/function () {
2467
3356
  filter: filter
2468
3357
  }
2469
3358
  }));
3359
+
2470
3360
  case 1:
2471
3361
  case "end":
2472
3362
  return _context8.stop();
@@ -2474,14 +3364,17 @@ var VaultService = /*#__PURE__*/function () {
2474
3364
  }
2475
3365
  }, _callee8, this);
2476
3366
  }));
3367
+
2477
3368
  function lockboxManifestGet(_x18, _x19, _x20) {
2478
3369
  return _lockboxManifestGet.apply(this, arguments);
2479
3370
  }
3371
+
2480
3372
  return lockboxManifestGet;
2481
3373
  }();
3374
+
2482
3375
  _proto.lockboxMetadataGet = /*#__PURE__*/function () {
2483
- var _lockboxMetadataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(lockboxUuid, fields, groupby, filter, lockboxOwnerUuid) {
2484
- return _regeneratorRuntime().wrap(function _callee9$(_context9) {
3376
+ var _lockboxMetadataGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee9(lockboxUuid, fields, groupby, filter, lockboxOwnerUuid) {
3377
+ return runtime_1.wrap(function _callee9$(_context9) {
2485
3378
  while (1) {
2486
3379
  switch (_context9.prev = _context9.next) {
2487
3380
  case 0:
@@ -2493,6 +3386,7 @@ var VaultService = /*#__PURE__*/function () {
2493
3386
  filter: filter
2494
3387
  }
2495
3388
  }));
3389
+
2496
3390
  case 1:
2497
3391
  case "end":
2498
3392
  return _context9.stop();
@@ -2500,22 +3394,27 @@ var VaultService = /*#__PURE__*/function () {
2500
3394
  }
2501
3395
  }, _callee9, this);
2502
3396
  }));
3397
+
2503
3398
  function lockboxMetadataGet(_x21, _x22, _x23, _x24, _x25) {
2504
3399
  return _lockboxMetadataGet.apply(this, arguments);
2505
3400
  }
3401
+
2506
3402
  return lockboxMetadataGet;
2507
- }() /**
2508
- * inserts or updates encrypted index entries
2509
- * @note if the index data is being inserted for a user other than the requester, use `indexOwnerUuid`
2510
- * @note if a uuid for an entry is provided, the service will perform an update
2511
- * @param entries the encrypted index data
2512
- * @param indexOwnerUuid
2513
- */;
3403
+ }()
3404
+ /**
3405
+ * inserts or updates encrypted index entries
3406
+ * @note if the index data is being inserted for a user other than the requester, use `indexOwnerUuid`
3407
+ * @note if a uuid for an entry is provided, the service will perform an update
3408
+ * @param entries the encrypted index data
3409
+ * @param indexOwnerUuid
3410
+ */
3411
+ ;
3412
+
2514
3413
  _proto.vaultIndexPut =
2515
3414
  /*#__PURE__*/
2516
3415
  function () {
2517
- var _vaultIndexPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(entries, indexOwnerUuid) {
2518
- return _regeneratorRuntime().wrap(function _callee10$(_context10) {
3416
+ var _vaultIndexPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee10(entries, indexOwnerUuid) {
3417
+ return runtime_1.wrap(function _callee10$(_context10) {
2519
3418
  while (1) {
2520
3419
  switch (_context10.prev = _context10.next) {
2521
3420
  case 0:
@@ -2524,6 +3423,7 @@ var VaultService = /*#__PURE__*/function () {
2524
3423
  index_owner_uuid: indexOwnerUuid
2525
3424
  }
2526
3425
  }));
3426
+
2527
3427
  case 1:
2528
3428
  case "end":
2529
3429
  return _context10.stop();
@@ -2531,24 +3431,30 @@ var VaultService = /*#__PURE__*/function () {
2531
3431
  }
2532
3432
  }, _callee10, this);
2533
3433
  }));
3434
+
2534
3435
  function vaultIndexPut(_x26, _x27) {
2535
3436
  return _vaultIndexPut.apply(this, arguments);
2536
3437
  }
3438
+
2537
3439
  return vaultIndexPut;
2538
- }() /**
2539
- * inserts or updates index snapshot for the provided index owner
2540
- * @note if the index data is being inserted for a user other than the requester, use `indexOwnerUuid`
2541
- * @param entry the encrypted index snapshot
2542
- */;
3440
+ }()
3441
+ /**
3442
+ * inserts or updates index snapshot for the provided index owner
3443
+ * @note if the index data is being inserted for a user other than the requester, use `indexOwnerUuid`
3444
+ * @param entry the encrypted index snapshot
3445
+ */
3446
+ ;
3447
+
2543
3448
  _proto.vaultIndexSnapshotPut =
2544
3449
  /*#__PURE__*/
2545
3450
  function () {
2546
- var _vaultIndexSnapshotPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(entry) {
2547
- return _regeneratorRuntime().wrap(function _callee11$(_context11) {
3451
+ var _vaultIndexSnapshotPut = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee11(entry) {
3452
+ return runtime_1.wrap(function _callee11$(_context11) {
2548
3453
  while (1) {
2549
3454
  switch (_context11.prev = _context11.next) {
2550
3455
  case 0:
2551
3456
  return _context11.abrupt("return", this.api.put(this.baseURL + "/v1/index-snapshot", entry));
3457
+
2552
3458
  case 1:
2553
3459
  case "end":
2554
3460
  return _context11.stop();
@@ -2556,23 +3462,28 @@ var VaultService = /*#__PURE__*/function () {
2556
3462
  }
2557
3463
  }, _callee11, this);
2558
3464
  }));
3465
+
2559
3466
  function vaultIndexSnapshotPut(_x28) {
2560
3467
  return _vaultIndexSnapshotPut.apply(this, arguments);
2561
3468
  }
3469
+
2562
3470
  return vaultIndexSnapshotPut;
2563
- }() /**
2564
- * Retrieves the encrypted index from the vault for the requesting user
2565
- * @note index keys can be specified to narrow the scope of index being requested
2566
- * @param indexKeys accepted index fields determined by vault
2567
- * @param identifiers: an array of unique_hashes or consultation uuids used to identify an index entry
2568
- * @param timestamp the minimum timestamp that index entries were created
2569
- * @returns the encrypted index
2570
- */;
3471
+ }()
3472
+ /**
3473
+ * Retrieves the encrypted index from the vault for the requesting user
3474
+ * @note index keys can be specified to narrow the scope of index being requested
3475
+ * @param indexKeys accepted index fields determined by vault
3476
+ * @param identifiers: an array of unique_hashes or consultation uuids used to identify an index entry
3477
+ * @param timestamp the minimum timestamp that index entries were created
3478
+ * @returns the encrypted index
3479
+ */
3480
+ ;
3481
+
2571
3482
  _proto.vaultIndexGet =
2572
3483
  /*#__PURE__*/
2573
3484
  function () {
2574
- var _vaultIndexGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(indexKeys, identifiers, timestamp) {
2575
- return _regeneratorRuntime().wrap(function _callee12$(_context12) {
3485
+ var _vaultIndexGet = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/runtime_1.mark(function _callee12(indexKeys, identifiers, timestamp) {
3486
+ return runtime_1.wrap(function _callee12$(_context12) {
2576
3487
  while (1) {
2577
3488
  switch (_context12.prev = _context12.next) {
2578
3489
  case 0:
@@ -2583,6 +3494,7 @@ var VaultService = /*#__PURE__*/function () {
2583
3494
  timestamp: timestamp
2584
3495
  }
2585
3496
  }));
3497
+
2586
3498
  case 1:
2587
3499
  case "end":
2588
3500
  return _context12.stop();
@@ -2590,11 +3502,14 @@ var VaultService = /*#__PURE__*/function () {
2590
3502
  }
2591
3503
  }, _callee12, this);
2592
3504
  }));
3505
+
2593
3506
  function vaultIndexGet(_x29, _x30, _x31) {
2594
3507
  return _vaultIndexGet.apply(this, arguments);
2595
3508
  }
3509
+
2596
3510
  return vaultIndexGet;
2597
3511
  }();
3512
+
2598
3513
  return VaultService;
2599
3514
  }();
2600
3515
 
@@ -2607,7 +3522,10 @@ var WorkflowService = /*#__PURE__*/function () {
2607
3522
  * This function returns all workflows
2608
3523
  * @returns desired workflow
2609
3524
  */
3525
+
3526
+
2610
3527
  var _proto = WorkflowService.prototype;
3528
+
2611
3529
  _proto.getWorkflows = function getWorkflows() {
2612
3530
  return this.api.get(this.v1Url + "/workflows");
2613
3531
  }
@@ -2618,7 +3536,9 @@ var WorkflowService = /*#__PURE__*/function () {
2618
3536
  * @param locale (optional) The desired locale of the workflow (default: 'en')
2619
3537
  * @param createdAt (optional) The creation date of the workflow (also used for versionning)
2620
3538
  * @returns desired workflow
2621
- */;
3539
+ */
3540
+ ;
3541
+
2622
3542
  _proto.getWorkflow = function getWorkflow(id, locale, createdAt) {
2623
3543
  return this.api.get(this.v1Url + "/workflows/" + id, {
2624
3544
  params: {
@@ -2627,6 +3547,7 @@ var WorkflowService = /*#__PURE__*/function () {
2627
3547
  }
2628
3548
  });
2629
3549
  };
3550
+
2630
3551
  return WorkflowService;
2631
3552
  }();
2632
3553
 
@@ -2637,18 +3558,20 @@ var WorkflowService = /*#__PURE__*/function () {
2637
3558
  * @param useLocalStorage (default: true) if true store tokens into local storage (only for browsers)
2638
3559
  * @returns an instance of each services with a provided url
2639
3560
  */
3561
+
2640
3562
  var init = function init(services, authenticationCallback, useLocalStorage) {
2641
3563
  if (useLocalStorage === void 0) {
2642
3564
  useLocalStorage = true;
2643
3565
  }
3566
+
2644
3567
  var tellerBaseURL = services.tellerBaseURL,
2645
- practiceBaseURL = services.practiceBaseURL,
2646
- consultBaseURL = services.consultBaseURL,
2647
- vaultBaseURL = services.vaultBaseURL,
2648
- guardBaseURL = services.guardBaseURL,
2649
- searchBaseURL = services.searchBaseURL,
2650
- workflowBaseURL = services.workflowBaseURL,
2651
- diagnosisBaseURL = services.diagnosisBaseURL;
3568
+ practiceBaseURL = services.practiceBaseURL,
3569
+ consultBaseURL = services.consultBaseURL,
3570
+ vaultBaseURL = services.vaultBaseURL,
3571
+ guardBaseURL = services.guardBaseURL,
3572
+ searchBaseURL = services.searchBaseURL,
3573
+ workflowBaseURL = services.workflowBaseURL,
3574
+ diagnosisBaseURL = services.diagnosisBaseURL;
2652
3575
  var apiService = new APIService(useLocalStorage, undefined, authenticationCallback);
2653
3576
  return {
2654
3577
  apiService: apiService,