@dbmx/toasts 0.0.122 → 0.0.123

package/esm/index-FCPRKLj2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-FCPRKLj2.js","sources":["../src/index.js"],"sourcesContent":["import { lazy } from 'react'\n\nconst importPath = '@dbmx/toasts'\nconst type = importPath\nconst tag = 'toast'\n\nconst toasts = [\n  {\n    id: 'sdmxDatagrid',\n    importPath,\n    type,\n    tag,\n    name: 'SDMX Datagrid',\n    tech: 'react',\n    description:\n      'SDMX, which stands for Statistical Data and Metadata eXchange, is an international initiative that aims at standardising and modernising (\"industrialising\") the mechanisms and processes for the exchange of statistical data and metadata among international organisations and their member countries.',\n    component: lazy(async () => {\n      const obj = await import('./components/SdmxDatagrid/index.jsx')\n      return typeof obj.default === 'function' ? obj : obj.default\n    }),\n    image: '/images/toasts/sdmx_datagrid.png', // TODO\n    props: {\n      endpoint: {\n        type: 'url',\n        required: true,\n      },\n      resourceType: {\n        type: 'select',\n        required: true,\n        defaultValue: 'dataflow',\n        data: [\n          { value: 'dataflow', label: 'Dataflow' },\n          { value: 'datastructure', label: 'DataStructure' },\n          { value: 'dataproviderscheme', label: 'DataProvider' },\n        ],\n      },\n      agencyID: {\n        type: 'string',\n        required: true,\n        defaultValue: '*',\n      },\n      id: {\n        type: 'string',\n        required: true,\n      },\n      version: {\n        type: 'string',\n        required: true,\n        defaultValue: '~',\n      },\n    },\n  },\n  {\n    id: 'helloWorld',\n    importPath: '@dbmx/webComponents',\n    type: '@dbmx/webComponents',\n    tag: 'hello-world',\n    name: 'Hello World',\n    tech: 'web-component',\n    description: 'web component demonstration',\n    component: () => import('./webComponents/HelloWorld/index.js'),\n    image: 'https://ui.mantine.dev/_next/static/media/comments-light.9c0747c0.svg',\n    props: {\n      name: {\n        type: 'string',\n        required: true,\n        default: 'test',\n      },\n    },\n  },\n]\n\nexport default toasts\n"],"names":["importPath","type","tag","toasts","id","name","tech","description","component","lazy","_asyncToGenerator","_regeneratorRuntime","mark","_callee","obj","wrap","_callee$","_context","prev","next","sent","abrupt","stop","image","props","endpoint","required","resourceType","defaultValue","data","value","label","agencyID","version"],"mappings":"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"}

package/esm/index-Mh78z9aW.js

@@ -0,0 +1,562 @@
+import { lazy } from 'react';
+
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw new Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: !0
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+            return next.value = t, next.done = !0, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+          } else {
+            if (!u) throw new Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+      args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(undefined);
+    });
+  };
+}
+function _defineProperty(obj, key, value) {
+  key = _toPropertyKey(key);
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function () {};
+      return {
+        s: F,
+        n: function () {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function (e) {
+          throw e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function () {
+      it = it.call(o);
+    },
+    n: function () {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function (e) {
+      didErr = true;
+      err = e;
+    },
+    f: function () {
+      try {
+        if (!normalCompletion && it.return != null) it.return();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+var importPath = '@dbmx/toasts';
+var type = importPath;
+var tag = 'toast';
+var toasts = [{
+  id: 'sdmxDatagrid',
+  importPath: importPath,
+  type: type,
+  tag: tag,
+  name: 'SDMX Datagrid',
+  description: 'SDMX, which stands for Statistical Data and Metadata eXchange, is an international initiative that aims at standardising and modernising ("industrialising") the mechanisms and processes for the exchange of statistical data and metadata among international organisations and their member countries.',
+  component: /*#__PURE__*/lazy( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var obj;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          _context.next = 2;
+          return import('./index-gBe37Ynf.js');
+        case 2:
+          obj = _context.sent;
+          return _context.abrupt("return", typeof obj["default"] === 'function' ? obj : obj["default"]);
+        case 4:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }))),
+  image: '/images/toasts/sdmx_datagrid.png',
+  // TODO
+  props: {
+    endpoint: {
+      type: 'url',
+      required: true
+    },
+    resourceType: {
+      type: 'select',
+      required: true,
+      defaultValue: 'dataflow',
+      data: [{
+        value: 'dataflow',
+        label: 'Dataflow'
+      }, {
+        value: 'datastructure',
+        label: 'DataStructure'
+      }, {
+        value: 'dataproviderscheme',
+        label: 'DataProvider'
+      }]
+    },
+    agencyID: {
+      type: 'string',
+      required: true,
+      defaultValue: '*'
+    },
+    id: {
+      type: 'string',
+      required: true
+    },
+    version: {
+      type: 'string',
+      required: true,
+      defaultValue: '~'
+    }
+  }
+}];
+
+export { _asyncToGenerator as _, _regeneratorRuntime as a, _createForOfIteratorHelper as b, _objectSpread2 as c, _defineProperty as d, _slicedToArray as e, _toConsumableArray as f, toasts as t };
+//# sourceMappingURL=index-Mh78z9aW.js.map

package/esm/index-Mh78z9aW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-Mh78z9aW.js","sources":["../src/index.js"],"sourcesContent":["import { lazy } from 'react'\n\nconst importPath = '@dbmx/toasts'\nconst type = importPath\nconst tag = 'toast'\n\nconst toasts = [\n  {\n    id: 'sdmxDatagrid',\n    importPath,\n    type,\n    tag,\n    name: 'SDMX Datagrid',\n    description:\n      'SDMX, which stands for Statistical Data and Metadata eXchange, is an international initiative that aims at standardising and modernising (\"industrialising\") the mechanisms and processes for the exchange of statistical data and metadata among international organisations and their member countries.',\n    component: lazy(async () => {\n      const obj = await import('./components/SdmxDatagrid/index.jsx')\n      return typeof obj.default === 'function' ? obj : obj.default\n    }),\n    image: '/images/toasts/sdmx_datagrid.png', // TODO\n    props: {\n      endpoint: {\n        type: 'url',\n        required: true,\n      },\n      resourceType: {\n        type: 'select',\n        required: true,\n        defaultValue: 'dataflow',\n        data: [\n          { value: 'dataflow', label: 'Dataflow' },\n          { value: 'datastructure', label: 'DataStructure' },\n          { value: 'dataproviderscheme', label: 'DataProvider' },\n        ],\n      },\n      agencyID: {\n        type: 'string',\n        required: true,\n        defaultValue: '*',\n      },\n      id: {\n        type: 'string',\n        required: true,\n      },\n      version: {\n        type: 'string',\n        required: true,\n        defaultValue: '~',\n      },\n    },\n  },\n]\n\nexport default toasts\n"],"names":["importPath","type","tag","toasts","id","name","description","component","lazy","_asyncToGenerator","_regeneratorRuntime","mark","_callee","obj","wrap","_callee$","_context","prev","next","sent","abrupt","stop","image","props","endpoint","required","resourceType","defaultValue","data","value","label","agencyID","version"],"mappings":"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"}