@ahoo-wang/fetcher-decorator 0.5.0

package/dist/index.es.js

@@ -0,0 +1,1141 @@
+import { HttpMethod as R, defaultFetcherName as Ye, fetcherRegistrar as Ve, combineURLs as Be } from "@ahoo-wang/fetcher";
+var le = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, he = {};
+/*! *****************************************************************************
+Copyright (C) Microsoft. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+var ve;
+function Le() {
+  if (ve) return he;
+  ve = 1;
+  var a;
+  return (function(f) {
+    (function(d) {
+      var l = typeof globalThis == "object" ? globalThis : typeof le == "object" ? le : typeof self == "object" ? self : typeof this == "object" ? this : I(), p = O(f);
+      typeof l.Reflect < "u" && (p = O(l.Reflect, p)), d(p, l), typeof l.Reflect > "u" && (l.Reflect = f);
+      function O(A, j) {
+        return function(k, C) {
+          Object.defineProperty(A, k, { configurable: !0, writable: !0, value: C }), j && j(k, C);
+        };
+      }
+      function m() {
+        try {
+          return Function("return this;")();
+        } catch {
+        }
+      }
+      function E() {
+        try {
+          return (0, eval)("(function() { return this; })()");
+        } catch {
+        }
+      }
+      function I() {
+        return m() || E();
+      }
+    })(function(d, l) {
+      var p = Object.prototype.hasOwnProperty, O = typeof Symbol == "function", m = O && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", E = O && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", I = typeof Object.create == "function", A = { __proto__: [] } instanceof Array, j = !I && !A, k = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: I ? function() {
+          return z(/* @__PURE__ */ Object.create(null));
+        } : A ? function() {
+          return z({ __proto__: null });
+        } : function() {
+          return z({});
+        },
+        has: j ? function(e, t) {
+          return p.call(e, t);
+        } : function(e, t) {
+          return t in e;
+        },
+        get: j ? function(e, t) {
+          return p.call(e, t) ? e[t] : void 0;
+        } : function(e, t) {
+          return e[t];
+        }
+      }, C = Object.getPrototypeOf(Function), G = typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : He(), N = typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : Fe(), Y = typeof WeakMap == "function" ? WeakMap : Ue(), S = O ? Symbol.for("@reflect-metadata:registry") : void 0, F = Ce(), Z = Ge(F);
+      function we(e, t, r, n) {
+        if (h(r)) {
+          if (!ae(e))
+            throw new TypeError();
+          if (!ie(t))
+            throw new TypeError();
+          return ke(e, t);
+        } else {
+          if (!ae(e))
+            throw new TypeError();
+          if (!g(t))
+            throw new TypeError();
+          if (!g(n) && !h(n) && !D(n))
+            throw new TypeError();
+          return D(n) && (n = void 0), r = T(r), Re(e, t, r, n);
+        }
+      }
+      d("decorate", we);
+      function _e(e, t) {
+        function r(n, c) {
+          if (!g(n))
+            throw new TypeError();
+          if (!h(c) && !De(c))
+            throw new TypeError();
+          K(e, t, n, c);
+        }
+        return r;
+      }
+      d("metadata", _e);
+      function Me(e, t, r, n) {
+        if (!g(r))
+          throw new TypeError();
+        return h(n) || (n = T(n)), K(e, t, r, n);
+      }
+      d("defineMetadata", Me);
+      function me(e, t, r) {
+        if (!g(t))
+          throw new TypeError();
+        return h(r) || (r = T(r)), J(e, t, r);
+      }
+      d("hasMetadata", me);
+      function ge(e, t, r) {
+        if (!g(t))
+          throw new TypeError();
+        return h(r) || (r = T(r)), V(e, t, r);
+      }
+      d("hasOwnMetadata", ge);
+      function be(e, t, r) {
+        if (!g(t))
+          throw new TypeError();
+        return h(r) || (r = T(r)), X(e, t, r);
+      }
+      d("getMetadata", be);
+      function Oe(e, t, r) {
+        if (!g(t))
+          throw new TypeError();
+        return h(r) || (r = T(r)), $(e, t, r);
+      }
+      d("getOwnMetadata", Oe);
+      function Ee(e, t) {
+        if (!g(e))
+          throw new TypeError();
+        return h(t) || (t = T(t)), ee(e, t);
+      }
+      d("getMetadataKeys", Ee);
+      function Pe(e, t) {
+        if (!g(e))
+          throw new TypeError();
+        return h(t) || (t = T(t)), te(e, t);
+      }
+      d("getOwnMetadataKeys", Pe);
+      function Te(e, t, r) {
+        if (!g(t))
+          throw new TypeError();
+        if (h(r) || (r = T(r)), !g(t))
+          throw new TypeError();
+        h(r) || (r = T(r));
+        var n = q(
+          t,
+          r,
+          /*Create*/
+          !1
+        );
+        return h(n) ? !1 : n.OrdinaryDeleteMetadata(e, t, r);
+      }
+      d("deleteMetadata", Te);
+      function ke(e, t) {
+        for (var r = e.length - 1; r >= 0; --r) {
+          var n = e[r], c = n(t);
+          if (!h(c) && !D(c)) {
+            if (!ie(c))
+              throw new TypeError();
+            t = c;
+          }
+        }
+        return t;
+      }
+      function Re(e, t, r, n) {
+        for (var c = e.length - 1; c >= 0; --c) {
+          var _ = e[c], b = _(t, r, n);
+          if (!h(b) && !D(b)) {
+            if (!g(b))
+              throw new TypeError();
+            n = b;
+          }
+        }
+        return n;
+      }
+      function J(e, t, r) {
+        var n = V(e, t, r);
+        if (n)
+          return !0;
+        var c = L(t);
+        return D(c) ? !1 : J(e, c, r);
+      }
+      function V(e, t, r) {
+        var n = q(
+          t,
+          r,
+          /*Create*/
+          !1
+        );
+        return h(n) ? !1 : ne(n.OrdinaryHasOwnMetadata(e, t, r));
+      }
+      function X(e, t, r) {
+        var n = V(e, t, r);
+        if (n)
+          return $(e, t, r);
+        var c = L(t);
+        if (!D(c))
+          return X(e, c, r);
+      }
+      function $(e, t, r) {
+        var n = q(
+          t,
+          r,
+          /*Create*/
+          !1
+        );
+        if (!h(n))
+          return n.OrdinaryGetOwnMetadata(e, t, r);
+      }
+      function K(e, t, r, n) {
+        var c = q(
+          r,
+          n,
+          /*Create*/
+          !0
+        );
+        c.OrdinaryDefineOwnMetadata(e, t, r, n);
+      }
+      function ee(e, t) {
+        var r = te(e, t), n = L(e);
+        if (n === null)
+          return r;
+        var c = ee(n, t);
+        if (c.length <= 0)
+          return r;
+        if (r.length <= 0)
+          return c;
+        for (var _ = new N(), b = [], v = 0, i = r; v < i.length; v++) {
+          var o = i[v], u = _.has(o);
+          u || (_.add(o), b.push(o));
+        }
+        for (var s = 0, y = c; s < y.length; s++) {
+          var o = y[s], u = _.has(o);
+          u || (_.add(o), b.push(o));
+        }
+        return b;
+      }
+      function te(e, t) {
+        var r = q(
+          e,
+          t,
+          /*create*/
+          !1
+        );
+        return r ? r.OrdinaryOwnMetadataKeys(e, t) : [];
+      }
+      function re(e) {
+        if (e === null)
+          return 1;
+        switch (typeof e) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return e === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function h(e) {
+        return e === void 0;
+      }
+      function D(e) {
+        return e === null;
+      }
+      function xe(e) {
+        return typeof e == "symbol";
+      }
+      function g(e) {
+        return typeof e == "object" ? e !== null : typeof e == "function";
+      }
+      function Ie(e, t) {
+        switch (re(e)) {
+          case 0:
+            return e;
+          case 1:
+            return e;
+          case 2:
+            return e;
+          case 3:
+            return e;
+          case 4:
+            return e;
+          case 5:
+            return e;
+        }
+        var r = "string", n = oe(e, m);
+        if (n !== void 0) {
+          var c = n.call(e, r);
+          if (g(c))
+            throw new TypeError();
+          return c;
+        }
+        return Ae(e);
+      }
+      function Ae(e, t) {
+        var r, n, c;
+        {
+          var _ = e.toString;
+          if (U(_)) {
+            var n = _.call(e);
+            if (!g(n))
+              return n;
+          }
+          var r = e.valueOf;
+          if (U(r)) {
+            var n = r.call(e);
+            if (!g(n))
+              return n;
+          }
+        }
+        throw new TypeError();
+      }
+      function ne(e) {
+        return !!e;
+      }
+      function Se(e) {
+        return "" + e;
+      }
+      function T(e) {
+        var t = Ie(e);
+        return xe(t) ? t : Se(t);
+      }
+      function ae(e) {
+        return Array.isArray ? Array.isArray(e) : e instanceof Object ? e instanceof Array : Object.prototype.toString.call(e) === "[object Array]";
+      }
+      function U(e) {
+        return typeof e == "function";
+      }
+      function ie(e) {
+        return typeof e == "function";
+      }
+      function De(e) {
+        switch (re(e)) {
+          case 3:
+            return !0;
+          case 4:
+            return !0;
+          default:
+            return !1;
+        }
+      }
+      function B(e, t) {
+        return e === t || e !== e && t !== t;
+      }
+      function oe(e, t) {
+        var r = e[t];
+        if (r != null) {
+          if (!U(r))
+            throw new TypeError();
+          return r;
+        }
+      }
+      function ue(e) {
+        var t = oe(e, E);
+        if (!U(t))
+          throw new TypeError();
+        var r = t.call(e);
+        if (!g(r))
+          throw new TypeError();
+        return r;
+      }
+      function fe(e) {
+        return e.value;
+      }
+      function se(e) {
+        var t = e.next();
+        return t.done ? !1 : t;
+      }
+      function ce(e) {
+        var t = e.return;
+        t && t.call(e);
+      }
+      function L(e) {
+        var t = Object.getPrototypeOf(e);
+        if (typeof e != "function" || e === C || t !== C)
+          return t;
+        var r = e.prototype, n = r && Object.getPrototypeOf(r);
+        if (n == null || n === Object.prototype)
+          return t;
+        var c = n.constructor;
+        return typeof c != "function" || c === e ? t : c;
+      }
+      function je() {
+        var e;
+        !h(S) && typeof l.Reflect < "u" && !(S in l.Reflect) && typeof l.Reflect.defineMetadata == "function" && (e = qe(l.Reflect));
+        var t, r, n, c = new Y(), _ = {
+          registerProvider: b,
+          getProvider: i,
+          setProvider: u
+        };
+        return _;
+        function b(s) {
+          if (!Object.isExtensible(_))
+            throw new Error("Cannot add provider to a frozen registry.");
+          switch (!0) {
+            case e === s:
+              break;
+            case h(t):
+              t = s;
+              break;
+            case t === s:
+              break;
+            case h(r):
+              r = s;
+              break;
+            case r === s:
+              break;
+            default:
+              n === void 0 && (n = new N()), n.add(s);
+              break;
+          }
+        }
+        function v(s, y) {
+          if (!h(t)) {
+            if (t.isProviderFor(s, y))
+              return t;
+            if (!h(r)) {
+              if (r.isProviderFor(s, y))
+                return t;
+              if (!h(n))
+                for (var w = ue(n); ; ) {
+                  var M = se(w);
+                  if (!M)
+                    return;
+                  var P = fe(M);
+                  if (P.isProviderFor(s, y))
+                    return ce(w), P;
+                }
+            }
+          }
+          if (!h(e) && e.isProviderFor(s, y))
+            return e;
+        }
+        function i(s, y) {
+          var w = c.get(s), M;
+          return h(w) || (M = w.get(y)), h(M) && (M = v(s, y), h(M) || (h(w) && (w = new G(), c.set(s, w)), w.set(y, M))), M;
+        }
+        function o(s) {
+          if (h(s))
+            throw new TypeError();
+          return t === s || r === s || !h(n) && n.has(s);
+        }
+        function u(s, y, w) {
+          if (!o(w))
+            throw new Error("Metadata provider not registered.");
+          var M = i(s, y);
+          if (M !== w) {
+            if (!h(M))
+              return !1;
+            var P = c.get(s);
+            h(P) && (P = new G(), c.set(s, P)), P.set(y, w);
+          }
+          return !0;
+        }
+      }
+      function Ce() {
+        var e;
+        return !h(S) && g(l.Reflect) && Object.isExtensible(l.Reflect) && (e = l.Reflect[S]), h(e) && (e = je()), !h(S) && g(l.Reflect) && Object.isExtensible(l.Reflect) && Object.defineProperty(l.Reflect, S, {
+          enumerable: !1,
+          configurable: !1,
+          writable: !1,
+          value: e
+        }), e;
+      }
+      function Ge(e) {
+        var t = new Y(), r = {
+          isProviderFor: function(o, u) {
+            var s = t.get(o);
+            return h(s) ? !1 : s.has(u);
+          },
+          OrdinaryDefineOwnMetadata: b,
+          OrdinaryHasOwnMetadata: c,
+          OrdinaryGetOwnMetadata: _,
+          OrdinaryOwnMetadataKeys: v,
+          OrdinaryDeleteMetadata: i
+        };
+        return F.registerProvider(r), r;
+        function n(o, u, s) {
+          var y = t.get(o), w = !1;
+          if (h(y)) {
+            if (!s)
+              return;
+            y = new G(), t.set(o, y), w = !0;
+          }
+          var M = y.get(u);
+          if (h(M)) {
+            if (!s)
+              return;
+            if (M = new G(), y.set(u, M), !e.setProvider(o, u, r))
+              throw y.delete(u), w && t.delete(o), new Error("Wrong provider for target.");
+          }
+          return M;
+        }
+        function c(o, u, s) {
+          var y = n(
+            u,
+            s,
+            /*Create*/
+            !1
+          );
+          return h(y) ? !1 : ne(y.has(o));
+        }
+        function _(o, u, s) {
+          var y = n(
+            u,
+            s,
+            /*Create*/
+            !1
+          );
+          if (!h(y))
+            return y.get(o);
+        }
+        function b(o, u, s, y) {
+          var w = n(
+            s,
+            y,
+            /*Create*/
+            !0
+          );
+          w.set(o, u);
+        }
+        function v(o, u) {
+          var s = [], y = n(
+            o,
+            u,
+            /*Create*/
+            !1
+          );
+          if (h(y))
+            return s;
+          for (var w = y.keys(), M = ue(w), P = 0; ; ) {
+            var de = se(M);
+            if (!de)
+              return s.length = P, s;
+            var We = fe(de);
+            try {
+              s[P] = We;
+            } catch (Ne) {
+              try {
+                ce(M);
+              } finally {
+                throw Ne;
+              }
+            }
+            P++;
+          }
+        }
+        function i(o, u, s) {
+          var y = n(
+            u,
+            s,
+            /*Create*/
+            !1
+          );
+          if (h(y) || !y.delete(o))
+            return !1;
+          if (y.size === 0) {
+            var w = t.get(u);
+            h(w) || (w.delete(s), w.size === 0 && t.delete(w));
+          }
+          return !0;
+        }
+      }
+      function qe(e) {
+        var t = e.defineMetadata, r = e.hasOwnMetadata, n = e.getOwnMetadata, c = e.getOwnMetadataKeys, _ = e.deleteMetadata, b = new Y(), v = {
+          isProviderFor: function(i, o) {
+            var u = b.get(i);
+            return !h(u) && u.has(o) ? !0 : c(i, o).length ? (h(u) && (u = new N(), b.set(i, u)), u.add(o), !0) : !1;
+          },
+          OrdinaryDefineOwnMetadata: t,
+          OrdinaryHasOwnMetadata: r,
+          OrdinaryGetOwnMetadata: n,
+          OrdinaryOwnMetadataKeys: c,
+          OrdinaryDeleteMetadata: _
+        };
+        return v;
+      }
+      function q(e, t, r) {
+        var n = F.getProvider(e, t);
+        if (!h(n))
+          return n;
+        if (r) {
+          if (F.setProvider(e, t, Z))
+            return Z;
+          throw new Error("Illegal state.");
+        }
+      }
+      function He() {
+        var e = {}, t = [], r = (
+          /** @class */
+          (function() {
+            function v(i, o, u) {
+              this._index = 0, this._keys = i, this._values = o, this._selector = u;
+            }
+            return v.prototype["@@iterator"] = function() {
+              return this;
+            }, v.prototype[E] = function() {
+              return this;
+            }, v.prototype.next = function() {
+              var i = this._index;
+              if (i >= 0 && i < this._keys.length) {
+                var o = this._selector(this._keys[i], this._values[i]);
+                return i + 1 >= this._keys.length ? (this._index = -1, this._keys = t, this._values = t) : this._index++, { value: o, done: !1 };
+              }
+              return { value: void 0, done: !0 };
+            }, v.prototype.throw = function(i) {
+              throw this._index >= 0 && (this._index = -1, this._keys = t, this._values = t), i;
+            }, v.prototype.return = function(i) {
+              return this._index >= 0 && (this._index = -1, this._keys = t, this._values = t), { value: i, done: !0 };
+            }, v;
+          })()
+        ), n = (
+          /** @class */
+          (function() {
+            function v() {
+              this._keys = [], this._values = [], this._cacheKey = e, this._cacheIndex = -2;
+            }
+            return Object.defineProperty(v.prototype, "size", {
+              get: function() {
+                return this._keys.length;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), v.prototype.has = function(i) {
+              return this._find(
+                i,
+                /*insert*/
+                !1
+              ) >= 0;
+            }, v.prototype.get = function(i) {
+              var o = this._find(
+                i,
+                /*insert*/
+                !1
+              );
+              return o >= 0 ? this._values[o] : void 0;
+            }, v.prototype.set = function(i, o) {
+              var u = this._find(
+                i,
+                /*insert*/
+                !0
+              );
+              return this._values[u] = o, this;
+            }, v.prototype.delete = function(i) {
+              var o = this._find(
+                i,
+                /*insert*/
+                !1
+              );
+              if (o >= 0) {
+                for (var u = this._keys.length, s = o + 1; s < u; s++)
+                  this._keys[s - 1] = this._keys[s], this._values[s - 1] = this._values[s];
+                return this._keys.length--, this._values.length--, B(i, this._cacheKey) && (this._cacheKey = e, this._cacheIndex = -2), !0;
+              }
+              return !1;
+            }, v.prototype.clear = function() {
+              this._keys.length = 0, this._values.length = 0, this._cacheKey = e, this._cacheIndex = -2;
+            }, v.prototype.keys = function() {
+              return new r(this._keys, this._values, c);
+            }, v.prototype.values = function() {
+              return new r(this._keys, this._values, _);
+            }, v.prototype.entries = function() {
+              return new r(this._keys, this._values, b);
+            }, v.prototype["@@iterator"] = function() {
+              return this.entries();
+            }, v.prototype[E] = function() {
+              return this.entries();
+            }, v.prototype._find = function(i, o) {
+              if (!B(this._cacheKey, i)) {
+                this._cacheIndex = -1;
+                for (var u = 0; u < this._keys.length; u++)
+                  if (B(this._keys[u], i)) {
+                    this._cacheIndex = u;
+                    break;
+                  }
+              }
+              return this._cacheIndex < 0 && o && (this._cacheIndex = this._keys.length, this._keys.push(i), this._values.push(void 0)), this._cacheIndex;
+            }, v;
+          })()
+        );
+        return n;
+        function c(v, i) {
+          return v;
+        }
+        function _(v, i) {
+          return i;
+        }
+        function b(v, i) {
+          return [v, i];
+        }
+      }
+      function Fe() {
+        var e = (
+          /** @class */
+          (function() {
+            function t() {
+              this._map = new G();
+            }
+            return Object.defineProperty(t.prototype, "size", {
+              get: function() {
+                return this._map.size;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), t.prototype.has = function(r) {
+              return this._map.has(r);
+            }, t.prototype.add = function(r) {
+              return this._map.set(r, r), this;
+            }, t.prototype.delete = function(r) {
+              return this._map.delete(r);
+            }, t.prototype.clear = function() {
+              this._map.clear();
+            }, t.prototype.keys = function() {
+              return this._map.keys();
+            }, t.prototype.values = function() {
+              return this._map.keys();
+            }, t.prototype.entries = function() {
+              return this._map.entries();
+            }, t.prototype["@@iterator"] = function() {
+              return this.keys();
+            }, t.prototype[E] = function() {
+              return this.keys();
+            }, t;
+          })()
+        );
+        return e;
+      }
+      function Ue() {
+        var e = 16, t = k.create(), r = n();
+        return (
+          /** @class */
+          (function() {
+            function i() {
+              this._key = n();
+            }
+            return i.prototype.has = function(o) {
+              var u = c(
+                o,
+                /*create*/
+                !1
+              );
+              return u !== void 0 ? k.has(u, this._key) : !1;
+            }, i.prototype.get = function(o) {
+              var u = c(
+                o,
+                /*create*/
+                !1
+              );
+              return u !== void 0 ? k.get(u, this._key) : void 0;
+            }, i.prototype.set = function(o, u) {
+              var s = c(
+                o,
+                /*create*/
+                !0
+              );
+              return s[this._key] = u, this;
+            }, i.prototype.delete = function(o) {
+              var u = c(
+                o,
+                /*create*/
+                !1
+              );
+              return u !== void 0 ? delete u[this._key] : !1;
+            }, i.prototype.clear = function() {
+              this._key = n();
+            }, i;
+          })()
+        );
+        function n() {
+          var i;
+          do
+            i = "@@WeakMap@@" + v();
+          while (k.has(t, i));
+          return t[i] = !0, i;
+        }
+        function c(i, o) {
+          if (!p.call(i, r)) {
+            if (!o)
+              return;
+            Object.defineProperty(i, r, { value: k.create() });
+          }
+          return i[r];
+        }
+        function _(i, o) {
+          for (var u = 0; u < o; ++u)
+            i[u] = Math.random() * 255 | 0;
+          return i;
+        }
+        function b(i) {
+          if (typeof Uint8Array == "function") {
+            var o = new Uint8Array(i);
+            return typeof crypto < "u" ? crypto.getRandomValues(o) : typeof msCrypto < "u" ? msCrypto.getRandomValues(o) : _(o, i), o;
+          }
+          return _(new Array(i), i);
+        }
+        function v() {
+          var i = b(e);
+          i[6] = i[6] & 79 | 64, i[8] = i[8] & 191 | 128;
+          for (var o = "", u = 0; u < e; ++u) {
+            var s = i[u];
+            (u === 4 || u === 6 || u === 8) && (o += "-"), s < 16 && (o += "0"), o += s.toString(16).toLowerCase();
+          }
+          return o;
+        }
+      }
+      function z(e) {
+        return e.__ = void 0, delete e.__, e;
+      }
+    });
+  })(a || (a = {})), he;
+}
+Le();
+const pe = Symbol("endpoint:metadata");
+function x(a, f = "", d = {}) {
+  return function(l, p) {
+    const O = {
+      method: a,
+      path: f,
+      ...d
+    };
+    Reflect.defineMetadata(
+      pe,
+      O,
+      l,
+      p
+    );
+  };
+}
+function st(a = "", f = {}) {
+  return x(R.GET, a, f);
+}
+function ct(a = "", f = {}) {
+  return x(R.POST, a, f);
+}
+function dt(a = "", f = {}) {
+  return x(R.PUT, a, f);
+}
+function lt(a = "", f = {}) {
+  return x(R.DELETE, a, f);
+}
+function ht(a = "", f = {}) {
+  return x(R.PATCH, a, f);
+}
+function vt(a = "", f = {}) {
+  return x(R.HEAD, a, f);
+}
+function yt(a = "", f = {}) {
+  return x(R.OPTIONS, a, f);
+}
+function ze(a) {
+  if (typeof a != "function")
+    throw new TypeError("Expected a function");
+  try {
+    const f = a.toString().trim(), d = Je(f);
+    return Ze(d) ? Xe(d) : [];
+  } catch {
+    return [];
+  }
+}
+function Qe(a, f, d, l) {
+  if (l)
+    return l;
+  try {
+    const p = a[f];
+    if (p) {
+      const O = ze(p);
+      if (d < O.length)
+        return O[d];
+    }
+  } catch {
+  }
+}
+function Ze(a) {
+  return a != null && a.trim() !== "";
+}
+function Je(a) {
+  if (a.startsWith("(")) {
+    const l = ye(a, 0);
+    return l === -1 ? "" : a.substring(1, l);
+  }
+  const f = a.indexOf("(");
+  if (f === -1) return "";
+  const d = ye(a, f);
+  return d === -1 ? "" : a.substring(f + 1, d);
+}
+function ye(a, f) {
+  let d = 1;
+  for (let l = f + 1; l < a.length; l++) {
+    const p = a[l];
+    if (p === "(")
+      d++;
+    else if (p === ")" && (d--, d === 0))
+      return l;
+  }
+  return -1;
+}
+function Xe(a) {
+  return a.split(",").map($e).filter(Ke).map(et);
+}
+function $e(a) {
+  return a.trim();
+}
+function Ke(a) {
+  return a.length > 0;
+}
+function et(a) {
+  let f = tt(a);
+  return f = rt(f), f.trim();
+}
+function tt(a) {
+  const f = a.indexOf("=");
+  return f !== -1 ? a.substring(0, f) : a;
+}
+function rt(a) {
+  const f = a.indexOf(":");
+  return f !== -1 ? a.substring(0, f) : a;
+}
+var H = /* @__PURE__ */ ((a) => (a.PATH = "path", a.QUERY = "query", a.HEADER = "header", a.BODY = "body", a))(H || {});
+const Q = Symbol("parameter:metadata");
+function W(a, f = "") {
+  return function(d, l, p) {
+    const O = Qe(
+      d,
+      l,
+      p,
+      f
+    ), m = Reflect.getMetadata(Q, d, l) || [];
+    m.push({
+      type: a,
+      name: O,
+      index: p
+    }), Reflect.defineMetadata(
+      Q,
+      m,
+      d,
+      l
+    );
+  };
+}
+function pt(a = "") {
+  return W("path", a);
+}
+function wt(a = "") {
+  return W("query", a);
+}
+function _t(a = "") {
+  return W("header", a);
+}
+function Mt() {
+  return W(
+    "body"
+    /* BODY */
+  );
+}
+class nt {
+  /**
+   * Creates a new FunctionMetadata instance
+   *
+   * @param name - The name of the function
+   * @param api - API-level metadata
+   * @param endpoint - Endpoint-level metadata
+   * @param parameters - Parameter metadata array
+   */
+  constructor(f, d, l, p) {
+    this.name = f, this.api = d, this.endpoint = l, this.parameters = p;
+  }
+  /**
+   * Gets the fetcher instance to use for this function
+   *
+   * Returns the fetcher specified in the endpoint metadata, or the API metadata,
+   * or falls back to the default fetcher if none is specified.
+   *
+   * @returns The fetcher instance
+   */
+  get fetcher() {
+    const f = this.endpoint.fetcher || this.api.fetcher || Ye;
+    return Ve.requiredGet(f);
+  }
+  /**
+   * Resolves the request configuration from the method arguments
+   *
+   * This method processes the runtime arguments according to the parameter metadata
+   * and constructs a FetcherRequest object with path parameters, query parameters,
+   * headers, body, and timeout.
+   *
+   * @param args - The runtime arguments passed to the method
+   * @returns A FetcherRequest object with all request configuration
+   */
+  resolveRequest(f) {
+    const d = {}, l = {}, p = {
+      ...this.api.headers,
+      ...this.endpoint.headers
+    };
+    let O = null;
+    return this.parameters.forEach((m) => {
+      const E = f[m.index];
+      switch (m.type) {
+        case H.PATH:
+          m.name ? d[m.name] = E : d["param" + m.index] = E;
+          break;
+        case H.QUERY:
+          m.name ? l[m.name] = E : l["param" + m.index] = E;
+          break;
+        case H.HEADER:
+          m.name && E !== void 0 && (p[m.name] = String(E));
+          break;
+        case H.BODY:
+          O = E;
+          break;
+      }
+    }), {
+      pathParams: d,
+      queryParams: l,
+      headers: p,
+      body: O,
+      timeout: this.resolveTimeout()
+    };
+  }
+  /**
+   * Resolves the full path for the request
+   *
+   * Combines the base path from API metadata with the endpoint path
+   * from endpoint metadata to create the complete path.
+   *
+   * @returns The full path for the request
+   */
+  resolvePath() {
+    const f = this.endpoint.basePath || this.api.basePath || "", d = this.endpoint.path || "";
+    return Be(f, d);
+  }
+  /**
+   * Resolves the timeout for the request
+   *
+   * Returns the timeout specified in the endpoint metadata, or the API metadata,
+   * or undefined if no timeout is specified.
+   *
+   * @returns The timeout value in milliseconds, or undefined
+   */
+  resolveTimeout() {
+    return this.endpoint.timeout || this.api.timeout;
+  }
+}
+class at {
+  /**
+   * Creates a new RequestExecutor instance
+   *
+   * @param metadata - The function metadata containing all request information
+   */
+  constructor(f) {
+    this.metadata = f;
+  }
+  /**
+   * Executes the HTTP request
+   *
+   * This method resolves the path and request configuration from the metadata
+   * and arguments, then executes the request using the configured fetcher.
+   *
+   * @param args - The runtime arguments passed to the method
+   * @returns A Promise that resolves to the Response
+   */
+  async execute(f) {
+    const d = this.metadata.resolvePath(), l = this.metadata.resolveRequest(f);
+    return await this.metadata.fetcher.fetch(d, l);
+  }
+}
+const it = Symbol("api:metadata");
+function ot(a, f, d) {
+  const l = a.prototype[f];
+  if (f === "constructor" || typeof l != "function")
+    return;
+  const p = Reflect.getMetadata(
+    pe,
+    a.prototype,
+    f
+  );
+  if (!p)
+    return;
+  const O = Reflect.getMetadata(
+    Q,
+    a.prototype,
+    f
+  ) || [], m = new nt(
+    f,
+    d,
+    p,
+    O
+  ), E = new at(m);
+  a.prototype[f] = function(...I) {
+    return E.execute(I);
+  };
+}
+function mt(a = "", f = {}) {
+  return function(d) {
+    const l = {
+      basePath: a,
+      ...f
+    };
+    Reflect.defineMetadata(it, l, d), Object.getOwnPropertyNames(d.prototype).forEach((p) => {
+      ot(d, p, l);
+    });
+  };
+}
+class ut extends Error {
+  constructor() {
+    super("Implementation will be generated automatically."), this.name = "AutoGenerated";
+  }
+}
+const gt = () => new ut();
+export {
+  it as API_METADATA_KEY,
+  ut as AutoGenerated,
+  pe as ENDPOINT_METADATA_KEY,
+  nt as FunctionMetadata,
+  Q as PARAMETER_METADATA_KEY,
+  H as ParameterType,
+  at as RequestExecutor,
+  mt as api,
+  gt as autoGeneratedError,
+  Mt as body,
+  lt as del,
+  x as endpoint,
+  st as get,
+  Qe as getParameterName,
+  ze as getParameterNames,
+  vt as head,
+  _t as header,
+  yt as options,
+  W as parameter,
+  ht as patch,
+  pt as path,
+  ct as post,
+  dt as put,
+  wt as query
+};