@monerium/sdk 2.0.0-alpha → 2.0.0-alpha.10

package/dist/index.umd.js

@@ -0,0 +1,844 @@
+var Se = Object.defineProperty;
+var ke = (a, h, y) =>
+  h in a
+    ? Se(a, h, { enumerable: !0, configurable: !0, writable: !0, value: y })
+    : (a[h] = y);
+var J = (a, h, y) => (ke(a, typeof h != "symbol" ? h + "" : h, y), y),
+  X = (a, h, y) => {
+    if (!h.has(a)) throw TypeError("Cannot " + y);
+  };
+var D = (a, h, y) => (
+    X(a, h, "read from private field"), y ? y.call(a) : h.get(a)
+  ),
+  T = (a, h, y) => {
+    if (h.has(a))
+      throw TypeError("Cannot add the same private member more than once");
+    h instanceof WeakSet ? h.add(a) : h.set(a, y);
+  },
+  K = (a, h, y, E) => (
+    X(a, h, "write to private field"), E ? E.call(a, y) : h.set(a, y), y
+  );
+var k = (a, h, y) => (X(a, h, "access private method"), y);
+(function (a, h) {
+  typeof exports == "object" && typeof module < "u"
+    ? h(exports)
+    : typeof define == "function" && define.amd
+    ? define(["exports"], h)
+    : ((a = typeof globalThis < "u" ? globalThis : a || self),
+      h((a["monerium-sdk"] = {})));
+})(this, function (a) {
+  var U, $, j, A, I, ue, M, fe, q, le;
+  ("use strict");
+  const h = {
+    environments: {
+      production: {
+        api: "https://api.monerium.app",
+        web: "https://monerium.app",
+      },
+      sandbox: {
+        api: "https://api.monerium.dev",
+        web: "https://sandbox.monerium.dev",
+      },
+    },
+  };
+  var y =
+    typeof globalThis < "u"
+      ? globalThis
+      : typeof window < "u"
+      ? window
+      : typeof global < "u"
+      ? global
+      : typeof self < "u"
+      ? self
+      : {};
+  function E(t) {
+    if (t.__esModule) return t;
+    var n = t.default;
+    if (typeof n == "function") {
+      var o = function u() {
+        if (this instanceof u) {
+          var w = [null];
+          w.push.apply(w, arguments);
+          var v = Function.bind.apply(n, w);
+          return new v();
+        }
+        return n.apply(this, arguments);
+      };
+      o.prototype = n.prototype;
+    } else o = {};
+    return (
+      Object.defineProperty(o, "__esModule", { value: !0 }),
+      Object.keys(t).forEach(function (u) {
+        var w = Object.getOwnPropertyDescriptor(t, u);
+        Object.defineProperty(
+          o,
+          u,
+          w.get
+            ? w
+            : {
+                enumerable: !0,
+                get: function () {
+                  return t[u];
+                },
+              }
+        );
+      }),
+      o
+    );
+  }
+  var F = {},
+    de = {
+      get exports() {
+        return F;
+      },
+      set exports(t) {
+        F = t;
+      },
+    };
+  function pe(t) {
+    throw new Error(
+      'Could not dynamically require "' +
+        t +
+        '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.'
+    );
+  }
+  var L = {},
+    he = {
+      get exports() {
+        return L;
+      },
+      set exports(t) {
+        L = t;
+      },
+    };
+  const ve = E(
+    Object.freeze(
+      Object.defineProperty(
+        { __proto__: null, default: {} },
+        Symbol.toStringTag,
+        { value: "Module" }
+      )
+    )
+  );
+  var Q;
+  function V() {
+    return (
+      Q ||
+        ((Q = 1),
+        (function (t, n) {
+          (function (o, u) {
+            t.exports = u();
+          })(y, function () {
+            var o =
+              o ||
+              (function (u, w) {
+                var v;
+                if (
+                  (typeof window < "u" && window.crypto && (v = window.crypto),
+                  typeof self < "u" && self.crypto && (v = self.crypto),
+                  typeof globalThis < "u" &&
+                    globalThis.crypto &&
+                    (v = globalThis.crypto),
+                  !v &&
+                    typeof window < "u" &&
+                    window.msCrypto &&
+                    (v = window.msCrypto),
+                  !v && typeof y < "u" && y.crypto && (v = y.crypto),
+                  !v && typeof pe == "function")
+                )
+                  try {
+                    v = ve;
+                  } catch {}
+                var H = function () {
+                    if (v) {
+                      if (typeof v.getRandomValues == "function")
+                        try {
+                          return v.getRandomValues(new Uint32Array(1))[0];
+                        } catch {}
+                      if (typeof v.randomBytes == "function")
+                        try {
+                          return v.randomBytes(4).readInt32LE();
+                        } catch {}
+                    }
+                    throw new Error(
+                      "Native crypto module could not be used to get secure random number."
+                    );
+                  },
+                  R =
+                    Object.create ||
+                    (function () {
+                      function e() {}
+                      return function (r) {
+                        var s;
+                        return (
+                          (e.prototype = r),
+                          (s = new e()),
+                          (e.prototype = null),
+                          s
+                        );
+                      };
+                    })(),
+                  c = {},
+                  x = (c.lib = {}),
+                  m = (x.Base = (function () {
+                    return {
+                      extend: function (e) {
+                        var r = R(this);
+                        return (
+                          e && r.mixIn(e),
+                          (!r.hasOwnProperty("init") || this.init === r.init) &&
+                            (r.init = function () {
+                              r.$super.init.apply(this, arguments);
+                            }),
+                          (r.init.prototype = r),
+                          (r.$super = this),
+                          r
+                        );
+                      },
+                      create: function () {
+                        var e = this.extend();
+                        return e.init.apply(e, arguments), e;
+                      },
+                      init: function () {},
+                      mixIn: function (e) {
+                        for (var r in e)
+                          e.hasOwnProperty(r) && (this[r] = e[r]);
+                        e.hasOwnProperty("toString") &&
+                          (this.toString = e.toString);
+                      },
+                      clone: function () {
+                        return this.init.prototype.extend(this);
+                      },
+                    };
+                  })()),
+                  d = (x.WordArray = m.extend({
+                    init: function (e, r) {
+                      (e = this.words = e || []),
+                        r != w
+                          ? (this.sigBytes = r)
+                          : (this.sigBytes = e.length * 4);
+                    },
+                    toString: function (e) {
+                      return (e || l).stringify(this);
+                    },
+                    concat: function (e) {
+                      var r = this.words,
+                        s = e.words,
+                        f = this.sigBytes,
+                        _ = e.sigBytes;
+                      if ((this.clamp(), f % 4))
+                        for (var B = 0; B < _; B++) {
+                          var C = (s[B >>> 2] >>> (24 - (B % 4) * 8)) & 255;
+                          r[(f + B) >>> 2] |= C << (24 - ((f + B) % 4) * 8);
+                        }
+                      else
+                        for (var S = 0; S < _; S += 4)
+                          r[(f + S) >>> 2] = s[S >>> 2];
+                      return (this.sigBytes += _), this;
+                    },
+                    clamp: function () {
+                      var e = this.words,
+                        r = this.sigBytes;
+                      (e[r >>> 2] &= 4294967295 << (32 - (r % 4) * 8)),
+                        (e.length = u.ceil(r / 4));
+                    },
+                    clone: function () {
+                      var e = m.clone.call(this);
+                      return (e.words = this.words.slice(0)), e;
+                    },
+                    random: function (e) {
+                      for (var r = [], s = 0; s < e; s += 4) r.push(H());
+                      return new d.init(r, e);
+                    },
+                  })),
+                  b = (c.enc = {}),
+                  l = (b.Hex = {
+                    stringify: function (e) {
+                      for (
+                        var r = e.words, s = e.sigBytes, f = [], _ = 0;
+                        _ < s;
+                        _++
+                      ) {
+                        var B = (r[_ >>> 2] >>> (24 - (_ % 4) * 8)) & 255;
+                        f.push((B >>> 4).toString(16)),
+                          f.push((B & 15).toString(16));
+                      }
+                      return f.join("");
+                    },
+                    parse: function (e) {
+                      for (var r = e.length, s = [], f = 0; f < r; f += 2)
+                        s[f >>> 3] |=
+                          parseInt(e.substr(f, 2), 16) << (24 - (f % 8) * 4);
+                      return new d.init(s, r / 2);
+                    },
+                  }),
+                  g = (b.Latin1 = {
+                    stringify: function (e) {
+                      for (
+                        var r = e.words, s = e.sigBytes, f = [], _ = 0;
+                        _ < s;
+                        _++
+                      ) {
+                        var B = (r[_ >>> 2] >>> (24 - (_ % 4) * 8)) & 255;
+                        f.push(String.fromCharCode(B));
+                      }
+                      return f.join("");
+                    },
+                    parse: function (e) {
+                      for (var r = e.length, s = [], f = 0; f < r; f++)
+                        s[f >>> 2] |=
+                          (e.charCodeAt(f) & 255) << (24 - (f % 4) * 8);
+                      return new d.init(s, r);
+                    },
+                  }),
+                  i = (b.Utf8 = {
+                    stringify: function (e) {
+                      try {
+                        return decodeURIComponent(escape(g.stringify(e)));
+                      } catch {
+                        throw new Error("Malformed UTF-8 data");
+                      }
+                    },
+                    parse: function (e) {
+                      return g.parse(unescape(encodeURIComponent(e)));
+                    },
+                  }),
+                  p = (x.BufferedBlockAlgorithm = m.extend({
+                    reset: function () {
+                      (this._data = new d.init()), (this._nDataBytes = 0);
+                    },
+                    _append: function (e) {
+                      typeof e == "string" && (e = i.parse(e)),
+                        this._data.concat(e),
+                        (this._nDataBytes += e.sigBytes);
+                    },
+                    _process: function (e) {
+                      var r,
+                        s = this._data,
+                        f = s.words,
+                        _ = s.sigBytes,
+                        B = this.blockSize,
+                        C = B * 4,
+                        S = _ / C;
+                      e
+                        ? (S = u.ceil(S))
+                        : (S = u.max((S | 0) - this._minBufferSize, 0));
+                      var W = S * B,
+                        O = u.min(W * 4, _);
+                      if (W) {
+                        for (var z = 0; z < W; z += B)
+                          this._doProcessBlock(f, z);
+                        (r = f.splice(0, W)), (s.sigBytes -= O);
+                      }
+                      return new d.init(r, O);
+                    },
+                    clone: function () {
+                      var e = m.clone.call(this);
+                      return (e._data = this._data.clone()), e;
+                    },
+                    _minBufferSize: 0,
+                  }));
+                x.Hasher = p.extend({
+                  cfg: m.extend(),
+                  init: function (e) {
+                    (this.cfg = this.cfg.extend(e)), this.reset();
+                  },
+                  reset: function () {
+                    p.reset.call(this), this._doReset();
+                  },
+                  update: function (e) {
+                    return this._append(e), this._process(), this;
+                  },
+                  finalize: function (e) {
+                    e && this._append(e);
+                    var r = this._doFinalize();
+                    return r;
+                  },
+                  blockSize: 16,
+                  _createHelper: function (e) {
+                    return function (r, s) {
+                      return new e.init(s).finalize(r);
+                    };
+                  },
+                  _createHmacHelper: function (e) {
+                    return function (r, s) {
+                      return new P.HMAC.init(e, s).finalize(r);
+                    };
+                  },
+                });
+                var P = (c.algo = {});
+                return c;
+              })(Math);
+            return o;
+          });
+        })(he)),
+      L
+    );
+  }
+  (function (t, n) {
+    (function (o, u) {
+      t.exports = u(V());
+    })(y, function (o) {
+      return (
+        (function () {
+          var u = o,
+            w = u.lib,
+            v = w.WordArray,
+            H = u.enc;
+          H.Base64url = {
+            stringify: function (c, x = !0) {
+              var m = c.words,
+                d = c.sigBytes,
+                b = x ? this._safe_map : this._map;
+              c.clamp();
+              for (var l = [], g = 0; g < d; g += 3)
+                for (
+                  var i = (m[g >>> 2] >>> (24 - (g % 4) * 8)) & 255,
+                    p = (m[(g + 1) >>> 2] >>> (24 - ((g + 1) % 4) * 8)) & 255,
+                    P = (m[(g + 2) >>> 2] >>> (24 - ((g + 2) % 4) * 8)) & 255,
+                    e = (i << 16) | (p << 8) | P,
+                    r = 0;
+                  r < 4 && g + r * 0.75 < d;
+                  r++
+                )
+                  l.push(b.charAt((e >>> (6 * (3 - r))) & 63));
+              var s = b.charAt(64);
+              if (s) for (; l.length % 4; ) l.push(s);
+              return l.join("");
+            },
+            parse: function (c, x = !0) {
+              var m = c.length,
+                d = x ? this._safe_map : this._map,
+                b = this._reverseMap;
+              if (!b) {
+                b = this._reverseMap = [];
+                for (var l = 0; l < d.length; l++) b[d.charCodeAt(l)] = l;
+              }
+              var g = d.charAt(64);
+              if (g) {
+                var i = c.indexOf(g);
+                i !== -1 && (m = i);
+              }
+              return R(c, m, b);
+            },
+            _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+            _safe_map:
+              "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+          };
+          function R(c, x, m) {
+            for (var d = [], b = 0, l = 0; l < x; l++)
+              if (l % 4) {
+                var g = m[c.charCodeAt(l - 1)] << ((l % 4) * 2),
+                  i = m[c.charCodeAt(l)] >>> (6 - (l % 4) * 2),
+                  p = g | i;
+                (d[b >>> 2] |= p << (24 - (b % 4) * 8)), b++;
+              }
+            return v.create(d, b);
+          }
+        })(),
+        o.enc.Base64url
+      );
+    });
+  })(de);
+  var N = {},
+    ge = {
+      get exports() {
+        return N;
+      },
+      set exports(t) {
+        N = t;
+      },
+    };
+  (function (t, n) {
+    (function (o, u) {
+      t.exports = u(V());
+    })(y, function (o) {
+      return (
+        (function (u) {
+          var w = o,
+            v = w.lib,
+            H = v.WordArray,
+            R = v.Hasher,
+            c = w.algo,
+            x = [],
+            m = [];
+          (function () {
+            function l(P) {
+              for (var e = u.sqrt(P), r = 2; r <= e; r++)
+                if (!(P % r)) return !1;
+              return !0;
+            }
+            function g(P) {
+              return ((P - (P | 0)) * 4294967296) | 0;
+            }
+            for (var i = 2, p = 0; p < 64; )
+              l(i) &&
+                (p < 8 && (x[p] = g(u.pow(i, 1 / 2))),
+                (m[p] = g(u.pow(i, 1 / 3))),
+                p++),
+                i++;
+          })();
+          var d = [],
+            b = (c.SHA256 = R.extend({
+              _doReset: function () {
+                this._hash = new H.init(x.slice(0));
+              },
+              _doProcessBlock: function (l, g) {
+                for (
+                  var i = this._hash.words,
+                    p = i[0],
+                    P = i[1],
+                    e = i[2],
+                    r = i[3],
+                    s = i[4],
+                    f = i[5],
+                    _ = i[6],
+                    B = i[7],
+                    C = 0;
+                  C < 64;
+                  C++
+                ) {
+                  if (C < 16) d[C] = l[g + C] | 0;
+                  else {
+                    var S = d[C - 15],
+                      W =
+                        ((S << 25) | (S >>> 7)) ^
+                        ((S << 14) | (S >>> 18)) ^
+                        (S >>> 3),
+                      O = d[C - 2],
+                      z =
+                        ((O << 15) | (O >>> 17)) ^
+                        ((O << 13) | (O >>> 19)) ^
+                        (O >>> 10);
+                    d[C] = W + d[C - 7] + z + d[C - 16];
+                  }
+                  var we = (s & f) ^ (~s & _),
+                    be = (p & P) ^ (p & e) ^ (P & e),
+                    Be =
+                      ((p << 30) | (p >>> 2)) ^
+                      ((p << 19) | (p >>> 13)) ^
+                      ((p << 10) | (p >>> 22)),
+                    xe =
+                      ((s << 26) | (s >>> 6)) ^
+                      ((s << 21) | (s >>> 11)) ^
+                      ((s << 7) | (s >>> 25)),
+                    ce = B + xe + we + m[C] + d[C],
+                    Ce = Be + be;
+                  (B = _),
+                    (_ = f),
+                    (f = s),
+                    (s = (r + ce) | 0),
+                    (r = e),
+                    (e = P),
+                    (P = p),
+                    (p = (ce + Ce) | 0);
+                }
+                (i[0] = (i[0] + p) | 0),
+                  (i[1] = (i[1] + P) | 0),
+                  (i[2] = (i[2] + e) | 0),
+                  (i[3] = (i[3] + r) | 0),
+                  (i[4] = (i[4] + s) | 0),
+                  (i[5] = (i[5] + f) | 0),
+                  (i[6] = (i[6] + _) | 0),
+                  (i[7] = (i[7] + B) | 0);
+              },
+              _doFinalize: function () {
+                var l = this._data,
+                  g = l.words,
+                  i = this._nDataBytes * 8,
+                  p = l.sigBytes * 8;
+                return (
+                  (g[p >>> 5] |= 128 << (24 - (p % 32))),
+                  (g[(((p + 64) >>> 9) << 4) + 14] = u.floor(i / 4294967296)),
+                  (g[(((p + 64) >>> 9) << 4) + 15] = i),
+                  (l.sigBytes = g.length * 4),
+                  this._process(),
+                  this._hash
+                );
+              },
+              clone: function () {
+                var l = R.clone.call(this);
+                return (l._hash = this._hash.clone()), l;
+              },
+            }));
+          (w.SHA256 = R._createHelper(b)),
+            (w.HmacSHA256 = R._createHmacHelper(b));
+        })(Math),
+        o.SHA256
+      );
+    });
+  })(ge);
+  var G = {},
+    ye = {
+      get exports() {
+        return G;
+      },
+      set exports(t) {
+        G = t;
+      },
+    };
+  (function (t, n) {
+    (function (o, u) {
+      t.exports = u(V());
+    })(y, function (o) {
+      return (
+        (function () {
+          if (typeof ArrayBuffer == "function") {
+            var u = o,
+              w = u.lib,
+              v = w.WordArray,
+              H = v.init,
+              R = (v.init = function (c) {
+                if (
+                  (c instanceof ArrayBuffer && (c = new Uint8Array(c)),
+                  (c instanceof Int8Array ||
+                    (typeof Uint8ClampedArray < "u" &&
+                      c instanceof Uint8ClampedArray) ||
+                    c instanceof Int16Array ||
+                    c instanceof Uint16Array ||
+                    c instanceof Int32Array ||
+                    c instanceof Uint32Array ||
+                    c instanceof Float32Array ||
+                    c instanceof Float64Array) &&
+                    (c = new Uint8Array(c.buffer, c.byteOffset, c.byteLength)),
+                  c instanceof Uint8Array)
+                ) {
+                  for (var x = c.byteLength, m = [], d = 0; d < x; d++)
+                    m[d >>> 2] |= c[d] << (24 - (d % 4) * 8);
+                  H.call(this, m, x);
+                } else H.apply(this, arguments);
+              });
+            R.prototype = v;
+          }
+        })(),
+        o.lib.WordArray
+      );
+    });
+  })(ye);
+  const me = {
+    name: "@monerium/sdk",
+    version: "2.0.0-alpha.10",
+    description: "Vite TypeScript library npm package template",
+    license: "ISC",
+    main: "dist/index.cjs.js",
+    module: "dist/index.es.js",
+    types: "dist/index.d.ts",
+    files: ["dist"],
+    engines: { node: "18.x" },
+    scripts: {
+      build:
+        "tsc && vite build && dts-bundle-generator --config ./dts-bundle-generator.config.ts",
+      clean: "rm -rf dist",
+      docs: "typedoc src/index.ts --out docs",
+      format: "prettier . --write",
+      lint: "eslint . --ext .ts",
+      prepare: "husky install",
+      prepublish: "yarn lint && yarn format && yarn test",
+      start: "vite --host --open",
+      test: "jest",
+      "test:coverage": "jest --coverage",
+      watch: "tsc && vite build --watch",
+    },
+    devDependencies: {
+      "@types/crypto-js": "^4.1.1",
+      "@types/jest": "^29.2.4",
+      "@types/node": "^18.11.18",
+      "@typescript-eslint/eslint-plugin": "^5.46.0",
+      "@typescript-eslint/parser": "^5.46.0",
+      "crypto-js": "^4.1.1",
+      "dts-bundle-generator": "^7.1.0",
+      eslint: "^8.29.0",
+      "eslint-config-prettier": "^8.5.0",
+      "eslint-plugin-jest": "^27.1.7",
+      "eslint-plugin-prettier": "^4.2.1",
+      husky: "^8.0.2",
+      jest: "^29.3.1",
+      prettier: "^2.8.1",
+      "ts-jest": "^29.0.3",
+      "ts-node": "^10.9.1",
+      tslib: "^2.4.1",
+      typedoc: "^0.23.23",
+      typescript: "^4.9.4",
+      vite: "^4.0.0",
+    },
+  };
+  class _e {
+    constructor(n = "sandbox") {
+      T(this, j);
+      T(this, I);
+      T(this, M);
+      T(this, q);
+      T(this, U, void 0);
+      T(this, $, void 0);
+      J(this, "codeVerifier");
+      J(this, "bearerProfile");
+      K(this, U, h.environments[n]);
+    }
+    async auth(n) {
+      let o;
+      if (k(this, I, ue).call(this, n))
+        o = { ...n, grant_type: "authorization_code" };
+      else if (k(this, M, fe).call(this, n))
+        o = { ...n, grant_type: "refresh_token" };
+      else if (k(this, q, le).call(this, n))
+        o = { ...n, grant_type: "client_credentials" };
+      else throw new Error("Authentication method could not be detected.");
+      (this.bearerProfile = await k(this, j, A).call(
+        this,
+        "post",
+        "auth/token",
+        new URLSearchParams(o),
+        !0
+      )),
+        K(this, $, `Bearer ${this.bearerProfile.access_token}`);
+    }
+    pkceRequest(n) {
+      this.codeVerifier = G.random(64).toString();
+      const o = F.stringify(N(this.codeVerifier)),
+        u = {
+          ...n,
+          code_challenge: o,
+          code_challenge_method: "S256",
+          response_type: "code",
+        };
+      return `${D(this, U).api}/auth?${new URLSearchParams(u)}`;
+    }
+    getAuthContext() {
+      return k(this, j, A).call(this, "get", "auth/context");
+    }
+    getProfile(n) {
+      return k(this, j, A).call(this, "get", `profiles/${n}`);
+    }
+    getBalances(n) {
+      return n
+        ? k(this, j, A).call(this, "get", `profiles/${n}/balances`)
+        : k(this, j, A).call(this, "get", "balances");
+    }
+    getOrders(n) {
+      const o = new URLSearchParams(n);
+      return k(this, j, A).call(this, "get", `orders?${o}`);
+    }
+    getOrder(n) {
+      return k(this, j, A).call(this, "get", `orders/${n}`);
+    }
+    getTokens() {
+      return k(this, j, A).call(this, "get", "tokens");
+    }
+    linkAddress(n, o) {
+      return k(this, j, A).call(
+        this,
+        "post",
+        `profiles/${n}/addresses`,
+        JSON.stringify(o)
+      );
+    }
+    placeOrder(n, o) {
+      return o
+        ? k(this, j, A).call(
+            this,
+            "post",
+            `profiles/${o}/orders`,
+            JSON.stringify(n)
+          )
+        : k(this, j, A).call(this, "post", "orders", JSON.stringify(n));
+    }
+    uploadSupportingDocument(n) {
+      const o = new URLSearchParams(n);
+      return k(this, j, A).call(
+        this,
+        "post",
+        "files/supporting-document",
+        o,
+        !0
+      );
+    }
+  }
+  (U = new WeakMap()),
+    ($ = new WeakMap()),
+    (j = new WeakSet()),
+    (A = async function (n, o, u, w) {
+      const v = await fetch(`${D(this, U).api}/${o}`, {
+          method: n,
+          headers: {
+            "Content-Type": `application/${
+              w ? "x-www-form-urlencoded" : "json"
+            }`,
+            Authorization: D(this, $) || "",
+            "user-agent":
+              "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36 sdk/" +
+              me.version,
+          },
+          body: u,
+        }),
+        H = await v.json();
+      if (v.ok) return H;
+      throw H;
+    }),
+    (I = new WeakSet()),
+    (ue = function (n) {
+      return n.code != null;
+    }),
+    (M = new WeakSet()),
+    (fe = function (n) {
+      return n.refresh_token != null;
+    }),
+    (q = new WeakSet()),
+    (le = function (n) {
+      return n.client_secret != null;
+    });
+  var Z = ((t) => (
+      (t.eur = "eur"), (t.usd = "usd"), (t.gbp = "gbp"), (t.isk = "isk"), t
+    ))(Z || {}),
+    Y = ((t) => ((t.corporate = "corporate"), (t.personal = "personal"), t))(
+      Y || {}
+    ),
+    ee = ((t) => ((t.read = "read"), (t.write = "write"), t))(ee || {}),
+    te = ((t) => (
+      (t.absent = "absent"),
+      (t.submitted = "submitted"),
+      (t.pending = "pending"),
+      (t.confirmed = "confirmed"),
+      t
+    ))(te || {}),
+    re = ((t) => (
+      (t.approved = "approved"),
+      (t.rejected = "rejected"),
+      (t.unknown = "unknown"),
+      t
+    ))(re || {}),
+    ne = ((t) => ((t.iban = "iban"), (t.scan = "scan"), t))(ne || {}),
+    ie = ((t) => (
+      (t.polygon = "polygon"),
+      (t.ethereum = "ethereum"),
+      (t.gnosis = "gnosis"),
+      t
+    ))(ie || {}),
+    se = ((t) => (
+      (t.mainnet = "mainnet"),
+      (t.chiado = "chiado"),
+      (t.goerli = "goerli"),
+      (t.mumbai = "mumbai"),
+      t
+    ))(se || {}),
+    oe = ((t) => ((t.redeem = "redeem"), (t.issue = "issue"), t))(oe || {}),
+    ae = ((t) => (
+      (t.placed = "placed"),
+      (t.pending = "pending"),
+      (t.processed = "processed"),
+      (t.rejected = "rejected"),
+      t
+    ))(ae || {});
+  (a.Chain = ie),
+    (a.Currency = Z),
+    (a.KYCOutcome = re),
+    (a.KYCState = te),
+    (a.MoneriumClient = _e),
+    (a.Network = se),
+    (a.OrderKind = oe),
+    (a.OrderState = ae),
+    (a.PaymentStandard = ne),
+    (a.Permission = ee),
+    (a.ProfileType = Y),
+    Object.defineProperty(a, Symbol.toStringTag, { value: "Module" });
+});
+//# sourceMappingURL=index.umd.js.map