@ahoo-wang/fetcher-react 2.6.6 → 2.6.9

package/dist/index.es.js

@@ -1,176 +1,2147 @@
-import { useRef as w, useCallback as c, useEffect as v, useState as b, useMemo as L, useSyncExternalStore as x } from "react";
-import { fetcherRegistrar as C, getFetcher as F } from "@ahoo-wang/fetcher";
-function R() {
-  const t = w(!1), e = c(() => t.current, []);
-  return v(() => (t.current = !0, () => {
+import { useRef as ht, useCallback as _, useEffect as Jt, useState as C, useMemo as F, useSyncExternalStore as Le } from "react";
+import { fetcherRegistrar as ke, getFetcher as zt, CONTENT_TYPE_HEADER as xe, ContentTypeValues as at, FetcherError as Ce, HttpMethod as De, combineURLs as je, JsonResultExtractor as Ge, mergeRecordToMap as mt, mergeRequest as qe } from "@ahoo-wang/fetcher";
+function _t() {
+  const t = ht(!1), e = _(() => t.current, []);
+  return Jt(() => (t.current = !0, () => {
     t.current = !1;
   }), []), e;
 }
-function I(t) {
-  const e = w(t);
+function J(t) {
+  const e = ht(t);
   return e.current = t, e;
 }
-var y = /* @__PURE__ */ ((t) => (t.IDLE = "idle", t.LOADING = "loading", t.SUCCESS = "success", t.ERROR = "error", t))(y || {});
-function S(t) {
-  const [e, r] = b(
+var He = /* @__PURE__ */ ((t) => (t.IDLE = "idle", t.LOADING = "loading", t.SUCCESS = "success", t.ERROR = "error", t))(He || {});
+function Zt(t) {
+  const [e, r] = C(
     t?.initialStatus ?? "idle"
     /* IDLE */
-  ), [a, u] = b(void 0), [s, n] = b(void 0), o = R(), l = I(t), d = c(() => {
-    o() && (r(
+  ), [a, s] = C(void 0), [u, f] = C(void 0), E = _t(), m = J(t), S = _(() => {
+    E() && (r(
       "loading"
       /* LOADING */
-    ), n(void 0));
-  }, [o]), g = c(
-    async (i) => {
-      if (o()) {
-        u(i), r(
+    ), f(void 0));
+  }, [E]), O = _(
+    async (R) => {
+      if (E()) {
+        s(R), r(
           "success"
           /* SUCCESS */
-        ), n(void 0);
+        ), f(void 0);
         try {
-          await l.current?.onSuccess?.(i);
-        } catch (h) {
-          console.warn("PromiseState onSuccess callback error:", h);
+          await m.current?.onSuccess?.(R);
+        } catch (M) {
+          console.warn("PromiseState onSuccess callback error:", M);
         }
       }
     },
-    [o, l]
-  ), f = c(
-    async (i) => {
-      if (o()) {
-        n(i), r(
+    [E, m]
+  ), b = _(
+    async (R) => {
+      if (E()) {
+        f(R), r(
           "error"
           /* ERROR */
-        ), u(void 0);
+        ), s(void 0);
         try {
-          await l.current?.onError?.(i);
-        } catch (h) {
-          console.warn("PromiseState onError callback error:", h);
+          await m.current?.onError?.(R);
+        } catch (M) {
+          console.warn("PromiseState onError callback error:", M);
         }
       }
     },
-    [o, l]
-  ), E = c(() => {
-    o() && (r(
+    [E, m]
+  ), P = _(() => {
+    E() && (r(
       "idle"
       /* IDLE */
-    ), n(void 0), u(void 0));
-  }, [o]);
-  return L(
+    ), f(void 0), s(void 0));
+  }, [E]);
+  return F(
     () => ({
       status: e,
       loading: e === "loading",
       result: a,
-      error: s,
-      setLoading: d,
-      setSuccess: g,
-      setError: f,
-      setIdle: E
+      error: u,
+      setLoading: S,
+      setSuccess: O,
+      setError: b,
+      setIdle: P
     }),
-    [e, a, s, d, g, f, E]
+    [e, a, u, S, O, b, P]
   );
 }
-function m() {
-  const t = w(0), e = c(() => ++t.current, []), r = c(() => t.current, []), a = c((n) => n === t.current, []), u = c(() => {
+function Kt() {
+  const t = ht(0), e = _(() => ++t.current, []), r = _(() => t.current, []), a = _((f) => f === t.current, []), s = _(() => {
     t.current++;
-  }, []), s = c(() => {
+  }, []), u = _(() => {
     t.current = 0;
   }, []);
-  return L(() => ({
+  return F(() => ({
     generate: e,
     current: r,
     isLatest: a,
-    invalidate: u,
-    reset: s
-  }), [e, r, a, u, s]);
+    invalidate: s,
+    reset: u
+  }), [e, r, a, s, u]);
 }
-function O(t) {
-  const e = S(t), r = R(), a = m(), u = c(
-    async (n) => {
+function ot(t) {
+  const e = Zt(t), r = _t(), a = Kt(), s = _(
+    async (f) => {
       if (!r())
         throw new Error("Component is unmounted");
-      const o = a.generate();
+      const E = a.generate();
       e.setLoading();
       try {
-        const d = await (typeof n == "function" ? n() : n);
-        return r() && a.isLatest(o) && await e.setSuccess(d), d;
-      } catch (l) {
-        throw r() && a.isLatest(o) && await e.setError(l), l;
+        const S = await (typeof f == "function" ? f() : f);
+        return r() && a.isLatest(E) && await e.setSuccess(S), S;
+      } catch (m) {
+        if (r() && a.isLatest(E) && await e.setError(m), t?.propagateError)
+          throw m;
+        return m;
       }
     },
-    [e, r, a]
-  ), s = c(() => {
+    [e, r, a, t]
+  ), u = _(() => {
     r() && e.setIdle();
   }, [e, r]);
-  return L(
+  return F(
     () => ({
       loading: e.loading,
       result: e.result,
       error: e.error,
-      execute: u,
-      reset: s,
+      execute: s,
+      reset: u,
       status: e.status
     }),
-    [e.loading, e.result, e.error, u, s, e.status]
+    [e.loading, e.result, e.error, s, u, e.status]
   );
 }
-function q(t) {
-  const e = c(
-    (s) => t.addListener(s),
+function Mr(t) {
+  const e = _(
+    (u) => t.addListener(u),
     [t]
-  ), r = c(() => t.get(), [t]), a = x(e, r, r), u = c(
-    (s) => t.set(s),
+  ), r = _(() => t.get(), [t]), a = Le(e, r, r), s = _(
+    (u) => t.set(u),
     [t]
   );
-  return [a, u];
+  return [a, s];
 }
-function A(t) {
-  const { fetcher: e = C.default } = t || {}, r = S(t), [a, u] = b(
+function Ar(t) {
+  const { fetcher: e = ke.default } = t || {}, r = Zt(t), [a, s] = C(
     void 0
-  ), s = R(), n = w(), o = m(), l = I(t), d = F(e), g = c(
-    async (f) => {
-      n.current && n.current.abort(), n.current = f.abortController ?? new AbortController(), f.abortController = n.current;
-      const E = o.generate();
+  ), u = _t(), f = ht(), E = Kt(), m = J(t), S = zt(e), O = _(
+    async (b) => {
+      f.current && f.current.abort(), f.current = b.abortController ?? new AbortController(), b.abortController = f.current;
+      const P = E.generate();
       r.setLoading();
       try {
-        const i = await d.exchange(
-          f,
-          l.current
+        const R = await S.exchange(
+          b,
+          m.current
         );
-        s() && o.isLatest(E) && u(i);
-        const h = await i.extractResult();
-        s() && o.isLatest(E) && await r.setSuccess(h);
-      } catch (i) {
-        if (i instanceof Error && i.name === "AbortError") {
-          s() && r.setIdle();
+        u() && E.isLatest(P) && s(R);
+        const M = await R.extractResult();
+        u() && E.isLatest(P) && await r.setSuccess(M);
+      } catch (R) {
+        if (R instanceof Error && R.name === "AbortError") {
+          u() && r.setIdle();
           return;
         }
-        s() && o.isLatest(E) && await r.setError(i);
+        u() && E.isLatest(P) && await r.setError(R);
       } finally {
-        n.current === f.abortController && (n.current = void 0);
+        f.current === b.abortController && (f.current = void 0);
       }
     },
-    [d, s, l, r, o]
+    [S, u, m, r, E]
   );
-  return v(() => () => {
-    n.current?.abort(), n.current = void 0;
-  }, []), L(
+  return Jt(() => () => {
+    f.current?.abort(), f.current = void 0;
+  }, []), F(
     () => ({
       ...r,
       exchange: a,
-      execute: g
+      execute: O
+    }),
+    [r, a, O]
+  );
+}
+let Ue = class {
+  constructor() {
+    this.buffer = "";
+  }
+  /**
+   * Transform input string chunk by splitting it into lines.
+   *
+   * @param chunk Input string chunk
+   * @param controller Controller for controlling the transform stream
+   */
+  transform(e, r) {
+    try {
+      this.buffer += e;
+      const a = this.buffer.split(`
+`);
+      this.buffer = a.pop() || "";
+      for (const s of a)
+        r.enqueue(s);
+    } catch (a) {
+      r.error(a);
+    }
+  }
+  /**
+   * Flush remaining buffer when the stream ends.
+   *
+   * @param controller Controller for controlling the transform stream
+   */
+  flush(e) {
+    try {
+      this.buffer && e.enqueue(this.buffer);
+    } catch (r) {
+      e.error(r);
+    }
+  }
+};
+class $e extends TransformStream {
+  constructor() {
+    super(new Ue());
+  }
+}
+const nt = class {
+};
+nt.ID = "id", nt.RETRY = "retry", nt.EVENT = "event", nt.DATA = "data";
+let ft = nt;
+function We(t, e, r) {
+  switch (t) {
+    case ft.EVENT:
+      r.event = e;
+      break;
+    case ft.DATA:
+      r.data.push(e);
+      break;
+    case ft.ID:
+      r.id = e;
+      break;
+    case ft.RETRY: {
+      const a = parseInt(e, 10);
+      isNaN(a) || (r.retry = a);
+      break;
+    }
+  }
+}
+const Z = "message";
+let Fe = class {
+  constructor() {
+    this.currentEvent = {
+      event: Z,
+      id: void 0,
+      retry: void 0,
+      data: []
+    };
+  }
+  /**
+   * Transform input string chunk into ServerSentEvent object.
+   *
+   * @param chunk Input string chunk
+   * @param controller Controller for controlling the transform stream
+   */
+  transform(e, r) {
+    const a = this.currentEvent;
+    try {
+      if (e.trim() === "") {
+        a.data.length > 0 && (r.enqueue({
+          event: a.event || Z,
+          data: a.data.join(`
+`),
+          id: a.id || "",
+          retry: a.retry
+        }), a.event = Z, a.data = []);
+        return;
+      }
+      if (e.startsWith(":"))
+        return;
+      const s = e.indexOf(":");
+      let u, f;
+      s === -1 ? (u = e.toLowerCase(), f = "") : (u = e.substring(0, s).toLowerCase(), f = e.substring(s + 1), f.startsWith(" ") && (f = f.substring(1))), u = u.trim(), f = f.trim(), We(u, f, a);
+    } catch (s) {
+      r.error(
+        s instanceof Error ? s : new Error(String(s))
+      ), a.event = Z, a.id = void 0, a.retry = void 0, a.data = [];
+    }
+  }
+  /**
+   * Called when the stream ends, used to process remaining data.
+   *
+   * @param controller Controller for controlling the transform stream
+   */
+  flush(e) {
+    const r = this.currentEvent;
+    try {
+      r.data.length > 0 && e.enqueue({
+        event: r.event || Z,
+        data: r.data.join(`
+`),
+        id: r.id || "",
+        retry: r.retry
+      });
+    } catch (a) {
+      e.error(
+        a instanceof Error ? a : new Error(String(a))
+      );
+    } finally {
+      r.event = Z, r.id = void 0, r.retry = void 0, r.data = [];
+    }
+  }
+};
+class Qe extends TransformStream {
+  constructor() {
+    super(new Fe());
+  }
+}
+class it extends Ce {
+  /**
+   * Creates a new EventStreamConvertError instance.
+   * @param response - The Response object associated with the error
+   * @param errorMsg - Optional error message describing what went wrong during conversion
+   * @param cause - Optional underlying error that caused this error
+   */
+  constructor(e, r, a) {
+    super(r, a), this.response = e, this.name = "EventStreamConvertError", Object.setPrototypeOf(this, it.prototype);
+  }
+}
+function Ve(t) {
+  if (!t.body)
+    throw new it(t, "Response body is null");
+  return t.body.pipeThrough(new TextDecoderStream("utf-8")).pipeThrough(new $e()).pipeThrough(new Qe());
+}
+let Ye = class {
+  transform(e, r) {
+    const a = JSON.parse(e.data);
+    r.enqueue({
+      data: a,
+      event: e.event,
+      id: e.id,
+      retry: e.retry
+    });
+  }
+}, Be = class extends TransformStream {
+  constructor() {
+    super(new Ye());
+  }
+};
+function Xe(t) {
+  return t.pipeThrough(
+    new Be()
+  );
+}
+const pt = (t) => t.requiredResponse.requiredJsonEventStream();
+Object.defineProperty(Response.prototype, "contentType", {
+  get() {
+    return this.headers.get(xe);
+  }
+});
+Object.defineProperty(Response.prototype, "isEventStream", {
+  get() {
+    const t = this.contentType;
+    return t ? t.includes(at.TEXT_EVENT_STREAM) : !1;
+  }
+});
+Response.prototype.eventStream = function() {
+  return this.isEventStream ? Ve(this) : null;
+};
+Response.prototype.requiredEventStream = function() {
+  const t = this.eventStream();
+  if (!t)
+    throw new it(
+      this,
+      `Event stream is not available. Response content-type: [${this.contentType}]`
+    );
+  return t;
+};
+Response.prototype.jsonEventStream = function() {
+  const t = this.eventStream();
+  return t ? Xe(t) : null;
+};
+Response.prototype.requiredJsonEventStream = function() {
+  const t = this.jsonEventStream();
+  if (!t)
+    throw new it(
+      this,
+      `Event stream is not available. Response content-type: [${this.contentType}]`
+    );
+  return t;
+};
+class Je {
+  /**
+   * Creates a new ReadableStreamAsyncIterable instance.
+   * @param stream - The ReadableStream to wrap.
+   */
+  constructor(e) {
+    this.stream = e, this._locked = !0, this.reader = e.getReader();
+  }
+  /**
+   * Gets the lock status of the reader.
+   * @returns True if the reader is currently locked, false otherwise.
+   */
+  get locked() {
+    return this._locked;
+  }
+  /**
+   * Releases the reader lock if currently locked.
+   * This method safely releases the reader lock by catching any potential errors.
+   */
+  releaseLock() {
+    if (!this._locked) return !1;
+    this._locked = !1;
+    try {
+      return this.reader.releaseLock(), !0;
+    } catch (e) {
+      return console.debug("Failed to release reader lock:", e), !1;
+    }
+  }
+  /**
+   * Implements the AsyncIterable interface by returning this iterator.
+   * @returns The async iterator for this instance.
+   */
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+  /**
+   * Gets the next value from the stream.
+   * Reads the next chunk from the stream and returns it as an IteratorResult.
+   * If the stream is done, releases the lock and returns a done result.
+   * @returns A promise that resolves to an IteratorResult containing the next value or done status.
+   * @throws If an error occurs while reading from the stream.
+   */
+  async next() {
+    try {
+      const { done: e, value: r } = await this.reader.read();
+      return e ? (this.releaseLock(), { done: !0, value: void 0 }) : { done: !1, value: r };
+    } catch (e) {
+      throw this.releaseLock(), e;
+    }
+  }
+  /**
+   * Implements the return method of the async iterator.
+   * Cancels the stream reader and releases the lock.
+   * @returns A promise that resolves to a done IteratorResult.
+   */
+  async return() {
+    try {
+      await this.reader.cancel();
+    } catch (e) {
+      console.debug("Failed to cancel stream reader:", e);
+    } finally {
+      this.releaseLock();
+    }
+    return { done: !0, value: void 0 };
+  }
+  /**
+   * Implements the throw method of the async iterator.
+   * Releases the lock and returns a done result.
+   * @param error - The error to be thrown.
+   * @returns A promise that resolves to a done IteratorResult.
+   */
+  async throw(e) {
+    return console.debug("Throwing error:", e), this.releaseLock(), { done: !0, value: void 0 };
+  }
+}
+const ze = typeof ReadableStream.prototype[Symbol.asyncIterator] == "function";
+ze || (ReadableStream.prototype[Symbol.asyncIterator] = function() {
+  return new Je(this);
+});
+var Vt = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {}, Yt = {};
+/*! *****************************************************************************
+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 Bt;
+function Ze() {
+  if (Bt) return Yt;
+  Bt = 1;
+  var t;
+  return (function(e) {
+    (function(r) {
+      var a = typeof globalThis == "object" ? globalThis : typeof Vt == "object" ? Vt : typeof self == "object" ? self : typeof this == "object" ? this : m(), s = u(e);
+      typeof a.Reflect < "u" && (s = u(a.Reflect, s)), r(s, a), typeof a.Reflect > "u" && (a.Reflect = e);
+      function u(S, O) {
+        return function(b, P) {
+          Object.defineProperty(S, b, { configurable: !0, writable: !0, value: P }), O && O(b, P);
+        };
+      }
+      function f() {
+        try {
+          return Function("return this;")();
+        } catch {
+        }
+      }
+      function E() {
+        try {
+          return (0, eval)("(function() { return this; })()");
+        } catch {
+        }
+      }
+      function m() {
+        return f() || E();
+      }
+    })(function(r, a) {
+      var s = Object.prototype.hasOwnProperty, u = typeof Symbol == "function", f = u && typeof Symbol.toPrimitive < "u" ? Symbol.toPrimitive : "@@toPrimitive", E = u && typeof Symbol.iterator < "u" ? Symbol.iterator : "@@iterator", m = typeof Object.create == "function", S = { __proto__: [] } instanceof Array, O = !m && !S, b = {
+        // create an object in dictionary mode (a.k.a. "slow" mode in v8)
+        create: m ? function() {
+          return wt(/* @__PURE__ */ Object.create(null));
+        } : S ? function() {
+          return wt({ __proto__: null });
+        } : function() {
+          return wt({});
+        },
+        has: O ? function(n, o) {
+          return s.call(n, o);
+        } : function(n, o) {
+          return o in n;
+        },
+        get: O ? function(n, o) {
+          return s.call(n, o) ? n[o] : void 0;
+        } : function(n, o) {
+          return n[o];
+        }
+      }, P = Object.getPrototypeOf(Function), R = typeof Map == "function" && typeof Map.prototype.entries == "function" ? Map : Me(), M = typeof Set == "function" && typeof Set.prototype.entries == "function" ? Set : Ae(), tt = typeof WeakMap == "function" ? WeakMap : Ie(), G = u ? Symbol.for("@reflect-metadata:registry") : void 0, ut = ge(), It = Re(ut);
+      function ie(n, o, i, c) {
+        if (v(i)) {
+          if (!Gt(n))
+            throw new TypeError();
+          if (!qt(o))
+            throw new TypeError();
+          return ve(n, o);
+        } else {
+          if (!Gt(n))
+            throw new TypeError();
+          if (!N(o))
+            throw new TypeError();
+          if (!N(c) && !v(c) && !z(c))
+            throw new TypeError();
+          return z(c) && (c = void 0), i = W(i), Ee(n, o, i, c);
+        }
+      }
+      r("decorate", ie);
+      function se(n, o) {
+        function i(c, y) {
+          if (!N(c))
+            throw new TypeError();
+          if (!v(y) && !_e(y))
+            throw new TypeError();
+          kt(n, o, c, y);
+        }
+        return i;
+      }
+      r("metadata", se);
+      function ue(n, o, i, c) {
+        if (!N(i))
+          throw new TypeError();
+        return v(c) || (c = W(c)), kt(n, o, i, c);
+      }
+      r("defineMetadata", ue);
+      function ce(n, o, i) {
+        if (!N(o))
+          throw new TypeError();
+        return v(i) || (i = W(i)), Pt(n, o, i);
+      }
+      r("hasMetadata", ce);
+      function fe(n, o, i) {
+        if (!N(o))
+          throw new TypeError();
+        return v(i) || (i = W(i)), vt(n, o, i);
+      }
+      r("hasOwnMetadata", fe);
+      function de(n, o, i) {
+        if (!N(o))
+          throw new TypeError();
+        return v(i) || (i = W(i)), Nt(n, o, i);
+      }
+      r("getMetadata", de);
+      function le(n, o, i) {
+        if (!N(o))
+          throw new TypeError();
+        return v(i) || (i = W(i)), Lt(n, o, i);
+      }
+      r("getOwnMetadata", le);
+      function he(n, o) {
+        if (!N(n))
+          throw new TypeError();
+        return v(o) || (o = W(o)), xt(n, o);
+      }
+      r("getMetadataKeys", he);
+      function pe(n, o) {
+        if (!N(n))
+          throw new TypeError();
+        return v(o) || (o = W(o)), Ct(n, o);
+      }
+      r("getOwnMetadataKeys", pe);
+      function ye(n, o, i) {
+        if (!N(o))
+          throw new TypeError();
+        if (v(i) || (i = W(i)), !N(o))
+          throw new TypeError();
+        v(i) || (i = W(i));
+        var c = et(
+          o,
+          i,
+          /*Create*/
+          !1
+        );
+        return v(c) ? !1 : c.OrdinaryDeleteMetadata(n, o, i);
+      }
+      r("deleteMetadata", ye);
+      function ve(n, o) {
+        for (var i = n.length - 1; i >= 0; --i) {
+          var c = n[i], y = c(o);
+          if (!v(y) && !z(y)) {
+            if (!qt(y))
+              throw new TypeError();
+            o = y;
+          }
+        }
+        return o;
+      }
+      function Ee(n, o, i, c) {
+        for (var y = n.length - 1; y >= 0; --y) {
+          var A = n[y], L = A(o, i, c);
+          if (!v(L) && !z(L)) {
+            if (!N(L))
+              throw new TypeError();
+            c = L;
+          }
+        }
+        return c;
+      }
+      function Pt(n, o, i) {
+        var c = vt(n, o, i);
+        if (c)
+          return !0;
+        var y = Tt(o);
+        return z(y) ? !1 : Pt(n, y, i);
+      }
+      function vt(n, o, i) {
+        var c = et(
+          o,
+          i,
+          /*Create*/
+          !1
+        );
+        return v(c) ? !1 : jt(c.OrdinaryHasOwnMetadata(n, o, i));
+      }
+      function Nt(n, o, i) {
+        var c = vt(n, o, i);
+        if (c)
+          return Lt(n, o, i);
+        var y = Tt(o);
+        if (!z(y))
+          return Nt(n, y, i);
+      }
+      function Lt(n, o, i) {
+        var c = et(
+          o,
+          i,
+          /*Create*/
+          !1
+        );
+        if (!v(c))
+          return c.OrdinaryGetOwnMetadata(n, o, i);
+      }
+      function kt(n, o, i, c) {
+        var y = et(
+          i,
+          c,
+          /*Create*/
+          !0
+        );
+        y.OrdinaryDefineOwnMetadata(n, o, i, c);
+      }
+      function xt(n, o) {
+        var i = Ct(n, o), c = Tt(n);
+        if (c === null)
+          return i;
+        var y = xt(c, o);
+        if (y.length <= 0)
+          return i;
+        if (i.length <= 0)
+          return y;
+        for (var A = new M(), L = [], T = 0, d = i; T < d.length; T++) {
+          var l = d[T], h = A.has(l);
+          h || (A.add(l), L.push(l));
+        }
+        for (var p = 0, w = y; p < w.length; p++) {
+          var l = w[p], h = A.has(l);
+          h || (A.add(l), L.push(l));
+        }
+        return L;
+      }
+      function Ct(n, o) {
+        var i = et(
+          n,
+          o,
+          /*create*/
+          !1
+        );
+        return i ? i.OrdinaryOwnMetadataKeys(n, o) : [];
+      }
+      function Dt(n) {
+        if (n === null)
+          return 1;
+        switch (typeof n) {
+          case "undefined":
+            return 0;
+          case "boolean":
+            return 2;
+          case "string":
+            return 3;
+          case "symbol":
+            return 4;
+          case "number":
+            return 5;
+          case "object":
+            return n === null ? 1 : 6;
+          default:
+            return 6;
+        }
+      }
+      function v(n) {
+        return n === void 0;
+      }
+      function z(n) {
+        return n === null;
+      }
+      function Te(n) {
+        return typeof n == "symbol";
+      }
+      function N(n) {
+        return typeof n == "object" ? n !== null : typeof n == "function";
+      }
+      function we(n, o) {
+        switch (Dt(n)) {
+          case 0:
+            return n;
+          case 1:
+            return n;
+          case 2:
+            return n;
+          case 3:
+            return n;
+          case 4:
+            return n;
+          case 5:
+            return n;
+        }
+        var i = "string", c = Ht(n, f);
+        if (c !== void 0) {
+          var y = c.call(n, i);
+          if (N(y))
+            throw new TypeError();
+          return y;
+        }
+        return me(n);
+      }
+      function me(n, o) {
+        var i, c, y;
+        {
+          var A = n.toString;
+          if (ct(A)) {
+            var c = A.call(n);
+            if (!N(c))
+              return c;
+          }
+          var i = n.valueOf;
+          if (ct(i)) {
+            var c = i.call(n);
+            if (!N(c))
+              return c;
+          }
+        }
+        throw new TypeError();
+      }
+      function jt(n) {
+        return !!n;
+      }
+      function Se(n) {
+        return "" + n;
+      }
+      function W(n) {
+        var o = we(n);
+        return Te(o) ? o : Se(o);
+      }
+      function Gt(n) {
+        return Array.isArray ? Array.isArray(n) : n instanceof Object ? n instanceof Array : Object.prototype.toString.call(n) === "[object Array]";
+      }
+      function ct(n) {
+        return typeof n == "function";
+      }
+      function qt(n) {
+        return typeof n == "function";
+      }
+      function _e(n) {
+        switch (Dt(n)) {
+          case 3:
+            return !0;
+          case 4:
+            return !0;
+          default:
+            return !1;
+        }
+      }
+      function Et(n, o) {
+        return n === o || n !== n && o !== o;
+      }
+      function Ht(n, o) {
+        var i = n[o];
+        if (i != null) {
+          if (!ct(i))
+            throw new TypeError();
+          return i;
+        }
+      }
+      function Ut(n) {
+        var o = Ht(n, E);
+        if (!ct(o))
+          throw new TypeError();
+        var i = o.call(n);
+        if (!N(i))
+          throw new TypeError();
+        return i;
+      }
+      function $t(n) {
+        return n.value;
+      }
+      function Wt(n) {
+        var o = n.next();
+        return o.done ? !1 : o;
+      }
+      function Ft(n) {
+        var o = n.return;
+        o && o.call(n);
+      }
+      function Tt(n) {
+        var o = Object.getPrototypeOf(n);
+        if (typeof n != "function" || n === P || o !== P)
+          return o;
+        var i = n.prototype, c = i && Object.getPrototypeOf(i);
+        if (c == null || c === Object.prototype)
+          return o;
+        var y = c.constructor;
+        return typeof y != "function" || y === n ? o : y;
+      }
+      function be() {
+        var n;
+        !v(G) && typeof a.Reflect < "u" && !(G in a.Reflect) && typeof a.Reflect.defineMetadata == "function" && (n = Oe(a.Reflect));
+        var o, i, c, y = new tt(), A = {
+          registerProvider: L,
+          getProvider: d,
+          setProvider: h
+        };
+        return A;
+        function L(p) {
+          if (!Object.isExtensible(A))
+            throw new Error("Cannot add provider to a frozen registry.");
+          switch (!0) {
+            case n === p:
+              break;
+            case v(o):
+              o = p;
+              break;
+            case o === p:
+              break;
+            case v(i):
+              i = p;
+              break;
+            case i === p:
+              break;
+            default:
+              c === void 0 && (c = new M()), c.add(p);
+              break;
+          }
+        }
+        function T(p, w) {
+          if (!v(o)) {
+            if (o.isProviderFor(p, w))
+              return o;
+            if (!v(i)) {
+              if (i.isProviderFor(p, w))
+                return o;
+              if (!v(c))
+                for (var g = Ut(c); ; ) {
+                  var I = Wt(g);
+                  if (!I)
+                    return;
+                  var U = $t(I);
+                  if (U.isProviderFor(p, w))
+                    return Ft(g), U;
+                }
+            }
+          }
+          if (!v(n) && n.isProviderFor(p, w))
+            return n;
+        }
+        function d(p, w) {
+          var g = y.get(p), I;
+          return v(g) || (I = g.get(w)), v(I) && (I = T(p, w), v(I) || (v(g) && (g = new R(), y.set(p, g)), g.set(w, I))), I;
+        }
+        function l(p) {
+          if (v(p))
+            throw new TypeError();
+          return o === p || i === p || !v(c) && c.has(p);
+        }
+        function h(p, w, g) {
+          if (!l(g))
+            throw new Error("Metadata provider not registered.");
+          var I = d(p, w);
+          if (I !== g) {
+            if (!v(I))
+              return !1;
+            var U = y.get(p);
+            v(U) && (U = new R(), y.set(p, U)), U.set(w, g);
+          }
+          return !0;
+        }
+      }
+      function ge() {
+        var n;
+        return !v(G) && N(a.Reflect) && Object.isExtensible(a.Reflect) && (n = a.Reflect[G]), v(n) && (n = be()), !v(G) && N(a.Reflect) && Object.isExtensible(a.Reflect) && Object.defineProperty(a.Reflect, G, {
+          enumerable: !1,
+          configurable: !1,
+          writable: !1,
+          value: n
+        }), n;
+      }
+      function Re(n) {
+        var o = new tt(), i = {
+          isProviderFor: function(l, h) {
+            var p = o.get(l);
+            return v(p) ? !1 : p.has(h);
+          },
+          OrdinaryDefineOwnMetadata: L,
+          OrdinaryHasOwnMetadata: y,
+          OrdinaryGetOwnMetadata: A,
+          OrdinaryOwnMetadataKeys: T,
+          OrdinaryDeleteMetadata: d
+        };
+        return ut.registerProvider(i), i;
+        function c(l, h, p) {
+          var w = o.get(l), g = !1;
+          if (v(w)) {
+            if (!p)
+              return;
+            w = new R(), o.set(l, w), g = !0;
+          }
+          var I = w.get(h);
+          if (v(I)) {
+            if (!p)
+              return;
+            if (I = new R(), w.set(h, I), !n.setProvider(l, h, i))
+              throw w.delete(h), g && o.delete(l), new Error("Wrong provider for target.");
+          }
+          return I;
+        }
+        function y(l, h, p) {
+          var w = c(
+            h,
+            p,
+            /*Create*/
+            !1
+          );
+          return v(w) ? !1 : jt(w.has(l));
+        }
+        function A(l, h, p) {
+          var w = c(
+            h,
+            p,
+            /*Create*/
+            !1
+          );
+          if (!v(w))
+            return w.get(l);
+        }
+        function L(l, h, p, w) {
+          var g = c(
+            p,
+            w,
+            /*Create*/
+            !0
+          );
+          g.set(l, h);
+        }
+        function T(l, h) {
+          var p = [], w = c(
+            l,
+            h,
+            /*Create*/
+            !1
+          );
+          if (v(w))
+            return p;
+          for (var g = w.keys(), I = Ut(g), U = 0; ; ) {
+            var Qt = Wt(I);
+            if (!Qt)
+              return p.length = U, p;
+            var Pe = $t(Qt);
+            try {
+              p[U] = Pe;
+            } catch (Ne) {
+              try {
+                Ft(I);
+              } finally {
+                throw Ne;
+              }
+            }
+            U++;
+          }
+        }
+        function d(l, h, p) {
+          var w = c(
+            h,
+            p,
+            /*Create*/
+            !1
+          );
+          if (v(w) || !w.delete(l))
+            return !1;
+          if (w.size === 0) {
+            var g = o.get(h);
+            v(g) || (g.delete(p), g.size === 0 && o.delete(g));
+          }
+          return !0;
+        }
+      }
+      function Oe(n) {
+        var o = n.defineMetadata, i = n.hasOwnMetadata, c = n.getOwnMetadata, y = n.getOwnMetadataKeys, A = n.deleteMetadata, L = new tt(), T = {
+          isProviderFor: function(d, l) {
+            var h = L.get(d);
+            return !v(h) && h.has(l) ? !0 : y(d, l).length ? (v(h) && (h = new M(), L.set(d, h)), h.add(l), !0) : !1;
+          },
+          OrdinaryDefineOwnMetadata: o,
+          OrdinaryHasOwnMetadata: i,
+          OrdinaryGetOwnMetadata: c,
+          OrdinaryOwnMetadataKeys: y,
+          OrdinaryDeleteMetadata: A
+        };
+        return T;
+      }
+      function et(n, o, i) {
+        var c = ut.getProvider(n, o);
+        if (!v(c))
+          return c;
+        if (i) {
+          if (ut.setProvider(n, o, It))
+            return It;
+          throw new Error("Illegal state.");
+        }
+      }
+      function Me() {
+        var n = {}, o = [], i = (
+          /** @class */
+          (function() {
+            function T(d, l, h) {
+              this._index = 0, this._keys = d, this._values = l, this._selector = h;
+            }
+            return T.prototype["@@iterator"] = function() {
+              return this;
+            }, T.prototype[E] = function() {
+              return this;
+            }, T.prototype.next = function() {
+              var d = this._index;
+              if (d >= 0 && d < this._keys.length) {
+                var l = this._selector(this._keys[d], this._values[d]);
+                return d + 1 >= this._keys.length ? (this._index = -1, this._keys = o, this._values = o) : this._index++, { value: l, done: !1 };
+              }
+              return { value: void 0, done: !0 };
+            }, T.prototype.throw = function(d) {
+              throw this._index >= 0 && (this._index = -1, this._keys = o, this._values = o), d;
+            }, T.prototype.return = function(d) {
+              return this._index >= 0 && (this._index = -1, this._keys = o, this._values = o), { value: d, done: !0 };
+            }, T;
+          })()
+        ), c = (
+          /** @class */
+          (function() {
+            function T() {
+              this._keys = [], this._values = [], this._cacheKey = n, this._cacheIndex = -2;
+            }
+            return Object.defineProperty(T.prototype, "size", {
+              get: function() {
+                return this._keys.length;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), T.prototype.has = function(d) {
+              return this._find(
+                d,
+                /*insert*/
+                !1
+              ) >= 0;
+            }, T.prototype.get = function(d) {
+              var l = this._find(
+                d,
+                /*insert*/
+                !1
+              );
+              return l >= 0 ? this._values[l] : void 0;
+            }, T.prototype.set = function(d, l) {
+              var h = this._find(
+                d,
+                /*insert*/
+                !0
+              );
+              return this._values[h] = l, this;
+            }, T.prototype.delete = function(d) {
+              var l = this._find(
+                d,
+                /*insert*/
+                !1
+              );
+              if (l >= 0) {
+                for (var h = this._keys.length, p = l + 1; p < h; p++)
+                  this._keys[p - 1] = this._keys[p], this._values[p - 1] = this._values[p];
+                return this._keys.length--, this._values.length--, Et(d, this._cacheKey) && (this._cacheKey = n, this._cacheIndex = -2), !0;
+              }
+              return !1;
+            }, T.prototype.clear = function() {
+              this._keys.length = 0, this._values.length = 0, this._cacheKey = n, this._cacheIndex = -2;
+            }, T.prototype.keys = function() {
+              return new i(this._keys, this._values, y);
+            }, T.prototype.values = function() {
+              return new i(this._keys, this._values, A);
+            }, T.prototype.entries = function() {
+              return new i(this._keys, this._values, L);
+            }, T.prototype["@@iterator"] = function() {
+              return this.entries();
+            }, T.prototype[E] = function() {
+              return this.entries();
+            }, T.prototype._find = function(d, l) {
+              if (!Et(this._cacheKey, d)) {
+                this._cacheIndex = -1;
+                for (var h = 0; h < this._keys.length; h++)
+                  if (Et(this._keys[h], d)) {
+                    this._cacheIndex = h;
+                    break;
+                  }
+              }
+              return this._cacheIndex < 0 && l && (this._cacheIndex = this._keys.length, this._keys.push(d), this._values.push(void 0)), this._cacheIndex;
+            }, T;
+          })()
+        );
+        return c;
+        function y(T, d) {
+          return T;
+        }
+        function A(T, d) {
+          return d;
+        }
+        function L(T, d) {
+          return [T, d];
+        }
+      }
+      function Ae() {
+        var n = (
+          /** @class */
+          (function() {
+            function o() {
+              this._map = new R();
+            }
+            return Object.defineProperty(o.prototype, "size", {
+              get: function() {
+                return this._map.size;
+              },
+              enumerable: !0,
+              configurable: !0
+            }), o.prototype.has = function(i) {
+              return this._map.has(i);
+            }, o.prototype.add = function(i) {
+              return this._map.set(i, i), this;
+            }, o.prototype.delete = function(i) {
+              return this._map.delete(i);
+            }, o.prototype.clear = function() {
+              this._map.clear();
+            }, o.prototype.keys = function() {
+              return this._map.keys();
+            }, o.prototype.values = function() {
+              return this._map.keys();
+            }, o.prototype.entries = function() {
+              return this._map.entries();
+            }, o.prototype["@@iterator"] = function() {
+              return this.keys();
+            }, o.prototype[E] = function() {
+              return this.keys();
+            }, o;
+          })()
+        );
+        return n;
+      }
+      function Ie() {
+        var n = 16, o = b.create(), i = c();
+        return (
+          /** @class */
+          (function() {
+            function d() {
+              this._key = c();
+            }
+            return d.prototype.has = function(l) {
+              var h = y(
+                l,
+                /*create*/
+                !1
+              );
+              return h !== void 0 ? b.has(h, this._key) : !1;
+            }, d.prototype.get = function(l) {
+              var h = y(
+                l,
+                /*create*/
+                !1
+              );
+              return h !== void 0 ? b.get(h, this._key) : void 0;
+            }, d.prototype.set = function(l, h) {
+              var p = y(
+                l,
+                /*create*/
+                !0
+              );
+              return p[this._key] = h, this;
+            }, d.prototype.delete = function(l) {
+              var h = y(
+                l,
+                /*create*/
+                !1
+              );
+              return h !== void 0 ? delete h[this._key] : !1;
+            }, d.prototype.clear = function() {
+              this._key = c();
+            }, d;
+          })()
+        );
+        function c() {
+          var d;
+          do
+            d = "@@WeakMap@@" + T();
+          while (b.has(o, d));
+          return o[d] = !0, d;
+        }
+        function y(d, l) {
+          if (!s.call(d, i)) {
+            if (!l)
+              return;
+            Object.defineProperty(d, i, { value: b.create() });
+          }
+          return d[i];
+        }
+        function A(d, l) {
+          for (var h = 0; h < l; ++h)
+            d[h] = Math.random() * 255 | 0;
+          return d;
+        }
+        function L(d) {
+          if (typeof Uint8Array == "function") {
+            var l = new Uint8Array(d);
+            return typeof crypto < "u" ? crypto.getRandomValues(l) : typeof msCrypto < "u" ? msCrypto.getRandomValues(l) : A(l, d), l;
+          }
+          return A(new Array(d), d);
+        }
+        function T() {
+          var d = L(n);
+          d[6] = d[6] & 79 | 64, d[8] = d[8] & 191 | 128;
+          for (var l = "", h = 0; h < n; ++h) {
+            var p = d[h];
+            (h === 4 || h === 6 || h === 8) && (l += "-"), p < 16 && (l += "0"), l += p.toString(16).toLowerCase();
+          }
+          return l;
+        }
+      }
+      function wt(n) {
+        return n.__ = void 0, delete n.__, n;
+      }
+    });
+  })(t || (t = {})), Yt;
+}
+Ze();
+const te = Symbol("endpoint:metadata");
+function bt(t, e, r = {}) {
+  return function(a, s) {
+    const u = {
+      method: t,
+      path: e,
+      ...r
+    };
+    Reflect.defineMetadata(
+      te,
+      u,
+      a,
+      s
+    );
+  };
+}
+function q(t = "", e = {}) {
+  return bt(De.POST, t, e);
+}
+var gt = /* @__PURE__ */ ((t) => (t.EXCHANGE = "Exchange", t.RESULT = "Result", t))(gt || {});
+const Ke = "__decorator_target__", tr = "__decorator_metadata__";
+let er = class {
+  /**
+   * Creates a new RequestExecutor instance.
+   * @param target - The target object that the method is called on.
+   *                 This can contain a custom fetcher instance in its 'fetcher' property.
+   * @param metadata - The function metadata containing all request information
+   */
+  constructor(e, r) {
+    this.target = e, this.metadata = r;
+  }
+  /**
+     * 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.
+     * It handles the complete request lifecycle from parameter processing to
+     * response extraction.
+     *
+  
+     * @param args - The runtime arguments passed to the decorated method.
+     *               These are mapped to request components based on parameter decorators.
+     * @returns A Promise that resolves to the extracted result based on the configured result extractor.
+     *          By default, this is the Response object, but can be customized to return
+     *          parsed JSON, the raw exchange object, or any other transformed result.
+     *
+     * @example
+     * ```typescript
+     * // Given a decorated service method:
+     * class UserService {
+     *   @get('/users/{id}')
+     *   getUser(@path('id') id: number): Promise<Response> {
+     *     // This method body is replaced by the executor at runtime
+     *   }
+     * }
+     *
+     * // When calling:
+     * const userService = new UserService();
+     * const response = await userService.getUser(123);
+     *
+     * // The execute method will:
+     * // 1. Resolve the path to '/users/123'
+     * // 2. Create a request with method 'GET'
+     * // 3. Execute the request using the configured fetcher
+     * // 4. Return the Response object
+     * ```
+     */
+  async execute(e) {
+    const r = this.metadata.fetcher, a = this.metadata.resolveExchangeInit(e);
+    a.attributes?.set(Ke, this.target), a.attributes?.set(
+      tr,
+      this.metadata
+    );
+    const s = this.metadata.resolveResultExtractor(), u = this.metadata.resolveEndpointReturnType(), f = await r.exchange(a.request, {
+      resultExtractor: s,
+      attributes: a.attributes
+    });
+    return u === gt.EXCHANGE ? f : await f.extractResult();
+  }
+};
+const rt = /* @__PURE__ */ new WeakMap();
+function rr(t) {
+  if (typeof t != "function")
+    throw new TypeError("Expected a function");
+  if (rt.has(t))
+    return rt.get(t);
+  try {
+    const e = t.toString().trim(), r = or(e);
+    if (!ar(r)) {
+      const s = [];
+      return rt.set(t, s), s;
+    }
+    const a = ir(r);
+    return rt.set(t, a), a;
+  } catch {
+    const e = [];
+    return rt.set(t, e), e;
+  }
+}
+function nr(t, e, r, a) {
+  if (a)
+    return a;
+  try {
+    const s = t[e];
+    if (s && typeof s == "function") {
+      const u = rr(s);
+      if (r < u.length)
+        return u[r];
+    }
+  } catch {
+  }
+}
+function ar(t) {
+  return t != null && t.trim() !== "";
+}
+function or(t) {
+  if (t.startsWith("(")) {
+    const a = Xt(t, 0);
+    return a === -1 ? "" : t.substring(1, a);
+  }
+  const e = t.indexOf("(");
+  if (e === -1) return "";
+  const r = Xt(t, e);
+  return r === -1 ? "" : t.substring(e + 1, r);
+}
+function Xt(t, e) {
+  let r = 1;
+  for (let a = e + 1; a < t.length; a++) {
+    const s = t[a];
+    if (s === "(")
+      r++;
+    else if (s === ")" && (r--, r === 0))
+      return a;
+  }
+  return -1;
+}
+function ir(t) {
+  return t.split(",").map(sr).filter(ur).map(cr);
+}
+function sr(t) {
+  return t.trim();
+}
+function ur(t) {
+  return t.length > 0;
+}
+function cr(t) {
+  let e = fr(t);
+  return e = dr(e), e.trim();
+}
+function fr(t) {
+  const e = t.indexOf("=");
+  return e !== -1 ? t.substring(0, e) : t;
+}
+function dr(t) {
+  const e = t.indexOf(":");
+  return e !== -1 ? t.substring(0, e) : t;
+}
+var X = /* @__PURE__ */ ((t) => (t.PATH = "path", t.QUERY = "query", t.HEADER = "header", t.BODY = "body", t.REQUEST = "request", t.ATTRIBUTE = "attribute", t))(X || {});
+const St = Symbol("parameter:metadata");
+function Rt(t, e = "") {
+  return function(r, a, s) {
+    const u = nr(
+      r,
+      a,
+      s,
+      e
+    ), f = Reflect.getMetadata(St, r, a) || /* @__PURE__ */ new Map(), E = {
+      type: t,
+      name: u,
+      index: s
+    };
+    f.set(s, E), Reflect.defineMetadata(
+      St,
+      f,
+      r,
+      a
+    );
+  };
+}
+function H() {
+  return Rt(
+    "body"
+    /* BODY */
+  );
+}
+function ee() {
+  return Rt(
+    "request"
+    /* REQUEST */
+  );
+}
+function j(t = "") {
+  return Rt("attribute", t);
+}
+let re = class {
+  /**
+   * 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(e, r, a, s) {
+    this.name = e, this.api = r, this.endpoint = a, this.parameters = s;
+  }
+  /**
+   * 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() {
+    return zt(this.endpoint.fetcher ?? this.api.fetcher);
+  }
+  /**
+   * Resolves the complete path by combining base path and endpoint path
+   *
+   * @param parameterPath - Optional path parameter to use instead of endpoint path
+   * @returns The combined URL path
+   */
+  resolvePath(e) {
+    const r = this.endpoint.basePath || this.api.basePath || "", a = e || this.endpoint.path || "";
+    return je(r, a);
+  }
+  /**
+   * 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;
+  }
+  resolveResultExtractor() {
+    return this.endpoint.resultExtractor || this.api.resultExtractor || Ge;
+  }
+  resolveAttributes() {
+    const e = mt(this.api.attributes);
+    return mt(this.endpoint.attributes, e);
+  }
+  resolveEndpointReturnType() {
+    return this.endpoint.returnType || this.api.returnType || gt.RESULT;
+  }
+  /**
+   * 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. It handles various parameter types including:
+   * - Path parameters (@path decorator)
+   * - Query parameters (@query decorator)
+   * - Header parameters (@header decorator)
+   * - Body parameter (@body decorator)
+   * - Complete request object (@request decorator)
+   * - AbortSignal for request cancellation
+   *
+   * The method uses mergeRequest to combine the endpoint-specific configuration
+   * with the parameter-provided request object, where the parameter request
+   * takes precedence over endpoint configuration.
+   *
+   * @param args - The runtime arguments passed to the method
+   * @returns A FetcherRequest object with all request configuration
+   *
+   * @example
+   * ```typescript
+   * // For a method decorated like:
+   * @get('/users/{id}')
+   * getUser(
+   *   @path('id') id: number,
+   *   @query('include') include: string,
+   *   @header('Authorization') auth: string
+   * ): Promise<Response>
+   *
+   * // Calling with: getUser(123, 'profile', 'Bearer token')
+   * // Would produce a request with:
+   * // {
+   * //   method: 'GET',
+   * //   urlParams: {
+   * //     path: { id: 123 },
+   * //     query: { include: 'profile' }
+   * //   },
+   * //   headers: {
+   * //     'Authorization': 'Bearer token',
+   * //     ...apiHeaders,
+   * //     ...endpointHeaders
+   * //   }
+   * // }
+   * ```
+   */
+  resolveExchangeInit(e) {
+    const r = {}, a = {}, s = {
+      ...this.api.headers,
+      ...this.endpoint.headers
+    };
+    let u, f, E, m = {};
+    const S = this.resolveAttributes();
+    e.forEach((M, tt) => {
+      if (M instanceof AbortSignal) {
+        f = M;
+        return;
+      }
+      if (M instanceof AbortController) {
+        E = M;
+        return;
+      }
+      const G = this.parameters.get(tt);
+      if (G)
+        switch (G.type) {
+          case X.PATH:
+            this.processPathParam(G, M, r);
+            break;
+          case X.QUERY:
+            this.processQueryParam(G, M, a);
+            break;
+          case X.HEADER:
+            this.processHeaderParam(G, M, s);
+            break;
+          case X.BODY:
+            u = M;
+            break;
+          case X.REQUEST:
+            m = this.processRequestParam(M);
+            break;
+          case X.ATTRIBUTE:
+            this.processAttributeParam(G, M, S);
+            break;
+        }
+    });
+    const O = {
+      path: r,
+      query: a
+    }, b = {
+      method: this.endpoint.method,
+      urlParams: O,
+      headers: s,
+      body: u,
+      timeout: this.resolveTimeout(),
+      signal: f,
+      abortController: E
+    }, P = qe(
+      b,
+      m
+    ), R = m.path;
+    return P.url = this.resolvePath(R), {
+      request: P,
+      attributes: S
+    };
+  }
+  processHttpParam(e, r, a) {
+    if (r == null)
+      return;
+    if (typeof r == "object") {
+      Object.entries(r).forEach(([u, f]) => {
+        a[u] = f;
+      });
+      return;
+    }
+    const s = e.name || `param${e.index}`;
+    a[s] = r;
+  }
+  processPathParam(e, r, a) {
+    this.processHttpParam(e, r, a);
+  }
+  processQueryParam(e, r, a) {
+    this.processHttpParam(e, r, a);
+  }
+  processHeaderParam(e, r, a) {
+    this.processHttpParam(e, r, a);
+  }
+  /**
+   * Processes a request parameter value.
+   *
+   * This method handles the @request() decorator parameter by casting
+   * the provided value to a FetcherRequest. The @request() decorator
+   * allows users to pass a complete FetcherRequest object to customize
+   * the request configuration.
+   *
+   * @param value - The value provided for the @request() parameter
+   * @returns The value cast to FetcherRequest type
+   *
+   * @example
+   * ```typescript
+   * @post('/users')
+   * createUsers(@request() request: FetcherRequest): Promise<Response>
+   *
+   * // Usage:
+   * const customRequest: FetcherRequest = {
+   *   headers: { 'X-Custom': 'value' },
+   *   timeout: 5000
+   * };
+   * await service.createUsers(customRequest);
+   * ```
+   */
+  processRequestParam(e) {
+    if (!e)
+      return {};
+    const r = e;
+    return {
+      ...r,
+      headers: r.headers || {},
+      urlParams: r.urlParams || { path: {}, query: {} }
+    };
+  }
+  processAttributeParam(e, r, a) {
+    if (typeof r == "object" || r instanceof Map) {
+      mt(r, a);
+      return;
+    }
+    e.name && r !== void 0 && a.set(e.name, r);
+  }
+};
+const lr = Symbol("api:metadata");
+function hr(t, e, r) {
+  const a = t.prototype[e];
+  if (e === "constructor" || typeof a != "function")
+    return;
+  const s = Reflect.getMetadata(
+    te,
+    t.prototype,
+    e
+  );
+  if (!s)
+    return;
+  const u = Reflect.getMetadata(
+    St,
+    t.prototype,
+    e
+  ) || /* @__PURE__ */ new Map(), f = new re(
+    e,
+    r,
+    s,
+    u
+  );
+  t.prototype[e] = async function(...E) {
+    return await pr(
+      this,
+      f
+    ).execute(E);
+  };
+}
+function pr(t, e) {
+  let r = t.requestExecutors;
+  r || (r = /* @__PURE__ */ new Map(), t.requestExecutors = r);
+  let a = r.get(e.name);
+  if (a)
+    return a;
+  const s = t.apiMetadata, u = {
+    ...e.api,
+    ...s
+  };
+  return a = new er(
+    t,
+    new re(
+      e.name,
+      u,
+      e.endpoint,
+      e.parameters
+    )
+  ), r.set(e.name, a), a;
+}
+function Ot(t = "", e = {}) {
+  return function(r) {
+    const a = {
+      basePath: t,
+      ...e
+    };
+    return Reflect.defineMetadata(lr, a, r), Object.getOwnPropertyNames(r.prototype).forEach((s) => {
+      hr(r, s, a);
+    }), r;
+  };
+}
+let yr = class extends Error {
+  constructor() {
+    super("Implementation will be generated automatically."), this.name = "AutoGenerated";
+  }
+};
+const D = (...t) => new yr();
+var vr = Object.defineProperty, Er = Object.getOwnPropertyDescriptor, Mt = (t, e, r, a) => {
+  for (var s = a > 1 ? void 0 : a ? Er(e, r) : e, u = t.length - 1, f; u >= 0; u--)
+    (f = t[u]) && (s = (a ? f(e, r, s) : f(s)) || s);
+  return a && s && vr(e, r, s), s;
+}, dt = (t, e) => (r, a) => e(r, a, t);
+let lt = class {
+  constructor(t) {
+    this.apiMetadata = t;
+  }
+  send(t, e) {
+    throw D(t, e);
+  }
+  sendAndWaitStream(t, e) {
+    throw D(t, e);
+  }
+};
+Mt([
+  bt(),
+  dt(0, ee()),
+  dt(1, j())
+], lt.prototype, "send", 1);
+Mt([
+  bt(void 0, void 0, {
+    headers: { Accept: at.TEXT_EVENT_STREAM },
+    resultExtractor: pt
+  }),
+  dt(0, ee()),
+  dt(1, j())
+], lt.prototype, "sendAndWaitStream", 1);
+lt = Mt([
+  Ot()
+], lt);
+var ne = /* @__PURE__ */ ((t) => (t.AND = "AND", t.OR = "OR", t.NOR = "NOR", t.ID = "ID", t.IDS = "IDS", t.AGGREGATE_ID = "AGGREGATE_ID", t.AGGREGATE_IDS = "AGGREGATE_IDS", t.TENANT_ID = "TENANT_ID", t.OWNER_ID = "OWNER_ID", t.DELETED = "DELETED", t.ALL = "ALL", t.EQ = "EQ", t.NE = "NE", t.GT = "GT", t.LT = "LT", t.GTE = "GTE", t.LTE = "LTE", t.CONTAINS = "CONTAINS", t.IN = "IN", t.NOT_IN = "NOT_IN", t.BETWEEN = "BETWEEN", t.ALL_IN = "ALL_IN", t.STARTS_WITH = "STARTS_WITH", t.ENDS_WITH = "ENDS_WITH", t.ELEM_MATCH = "ELEM_MATCH", t.NULL = "NULL", t.NOT_NULL = "NOT_NULL", t.TRUE = "TRUE", t.FALSE = "FALSE", t.EXISTS = "EXISTS", t.TODAY = "TODAY", t.BEFORE_TODAY = "BEFORE_TODAY", t.TOMORROW = "TOMORROW", t.THIS_WEEK = "THIS_WEEK", t.NEXT_WEEK = "NEXT_WEEK", t.LAST_WEEK = "LAST_WEEK", t.THIS_MONTH = "THIS_MONTH", t.LAST_MONTH = "LAST_MONTH", t.RECENT_DAYS = "RECENT_DAYS", t.EARLIER_DAYS = "EARLIER_DAYS", t.RAW = "RAW", t))(ne || {});
+function At() {
+  return {
+    operator: ne.ALL
+  };
+}
+const ae = {
+  index: 1,
+  size: 10
+};
+function Tr({
+  condition: t = At(),
+  projection: e,
+  sort: r
+} = {}) {
+  return {
+    condition: t,
+    projection: e,
+    sort: r
+  };
+}
+function wr({
+  condition: t = At(),
+  projection: e,
+  sort: r,
+  limit: a = ae.size
+} = {}) {
+  return {
+    condition: t,
+    projection: e,
+    sort: r,
+    limit: a
+  };
+}
+function mr({
+  condition: t = At(),
+  projection: e,
+  sort: r,
+  pagination: a = ae
+} = {}) {
+  return {
+    condition: t,
+    projection: e,
+    sort: r,
+    pagination: a
+  };
+}
+const Y = class {
+};
+Y.EVENT_STREAM_RESOURCE_NAME = "event", Y.COUNT = `${Y.EVENT_STREAM_RESOURCE_NAME}/count`, Y.LIST = `${Y.EVENT_STREAM_RESOURCE_NAME}/list`, Y.PAGED = `${Y.EVENT_STREAM_RESOURCE_NAME}/paged`;
+let yt = Y;
+var Sr = Object.defineProperty, _r = Object.getOwnPropertyDescriptor, st = (t, e, r, a) => {
+  for (var s = a > 1 ? void 0 : a ? _r(e, r) : e, u = t.length - 1, f; u >= 0; u--)
+    (f = t[u]) && (s = (a ? f(e, r, s) : f(s)) || s);
+  return a && s && Sr(e, r, s), s;
+}, B = (t, e) => (r, a) => e(r, a, t);
+let K = class {
+  /**
+   * Creates a new EventStreamQueryClient instance.
+   */
+  constructor(t) {
+    this.apiMetadata = t;
+  }
+  count(t, e) {
+    throw D(t, e);
+  }
+  list(t, e) {
+    throw D(t, e);
+  }
+  listStream(t, e) {
+    throw D(t, e);
+  }
+  paged(t, e) {
+    throw D(t, e);
+  }
+};
+st([
+  q(yt.COUNT),
+  B(0, H()),
+  B(1, j())
+], K.prototype, "count", 1);
+st([
+  q(yt.LIST),
+  B(0, H()),
+  B(1, j())
+], K.prototype, "list", 1);
+st([
+  q(yt.LIST, {
+    headers: { Accept: at.TEXT_EVENT_STREAM },
+    resultExtractor: pt
+  }),
+  B(0, H()),
+  B(1, j())
+], K.prototype, "listStream", 1);
+st([
+  q(yt.PAGED),
+  B(0, H()),
+  B(1, j())
+], K.prototype, "paged", 1);
+K = st([
+  Ot()
+], K);
+const x = class {
+};
+x.SNAPSHOT_RESOURCE_NAME = "snapshot", x.COUNT = `${x.SNAPSHOT_RESOURCE_NAME}/count`, x.LIST = `${x.SNAPSHOT_RESOURCE_NAME}/list`, x.LIST_STATE = `${x.LIST}/state`, x.PAGED = `${x.SNAPSHOT_RESOURCE_NAME}/paged`, x.PAGED_STATE = `${x.PAGED}/state`, x.SINGLE = `${x.SNAPSHOT_RESOURCE_NAME}/single`, x.SINGLE_STATE = `${x.SINGLE}/state`;
+let V = x;
+var br = Object.defineProperty, gr = Object.getOwnPropertyDescriptor, Q = (t, e, r, a) => {
+  for (var s = a > 1 ? void 0 : a ? gr(e, r) : e, u = t.length - 1, f; u >= 0; u--)
+    (f = t[u]) && (s = (a ? f(e, r, s) : f(s)) || s);
+  return a && s && br(e, r, s), s;
+}, k = (t, e) => (r, a) => e(r, a, t);
+let $ = class {
+  /**
+   * Creates a new SnapshotQueryClient instance.
+   */
+  constructor(t) {
+    this.apiMetadata = t;
+  }
+  count(t, e) {
+    throw D(t, e);
+  }
+  list(t, e) {
+    throw D(t, e);
+  }
+  listStream(t, e) {
+    throw D(t, e);
+  }
+  listState(t, e) {
+    throw D(t, e);
+  }
+  listStateStream(t, e) {
+    throw D(t, e);
+  }
+  paged(t, e) {
+    throw D(t, e);
+  }
+  pagedState(t, e) {
+    throw D(t, e);
+  }
+  single(t, e) {
+    throw D(t, e);
+  }
+  singleState(t, e) {
+    throw D(t, e);
+  }
+};
+Q([
+  q(V.COUNT),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "count", 1);
+Q([
+  q(V.LIST),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "list", 1);
+Q([
+  q(V.LIST, {
+    headers: { Accept: at.TEXT_EVENT_STREAM },
+    resultExtractor: pt
+  }),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "listStream", 1);
+Q([
+  q(V.LIST_STATE),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "listState", 1);
+Q([
+  q(V.LIST_STATE, {
+    headers: { Accept: at.TEXT_EVENT_STREAM },
+    resultExtractor: pt
+  }),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "listStateStream", 1);
+Q([
+  q(V.PAGED),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "paged", 1);
+Q([
+  q(V.PAGED_STATE),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "pagedState", 1);
+Q([
+  q(V.SINGLE),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "single", 1);
+Q([
+  q(V.SINGLE_STATE),
+  k(0, H()),
+  k(1, j())
+], $.prototype, "singleState", 1);
+$ = Q([
+  Ot()
+], $);
+function qr(t) {
+  const { initialQuery: e } = t, r = ot(t), [a, s] = C(e.condition), [u, f] = C(e.pagination), [E, m] = C(e.projection), [S, O] = C(e.sort), b = J(t), P = _(async () => {
+    const M = mr({
+      condition: a,
+      pagination: u,
+      projection: E,
+      sort: S
+    });
+    return b.current.query(
+      M,
+      b.current.attributes
+    );
+  }, [a, E, u, S, b]), R = _(() => r.execute(P), [r, P]);
+  return F(() => ({
+    ...r,
+    execute: R,
+    setCondition: s,
+    setProjection: m,
+    setPagination: f,
+    setSort: O
+  }), [
+    r,
+    R,
+    s,
+    m,
+    f,
+    O
+  ]);
+}
+function Hr(t) {
+  const { initialQuery: e } = t, r = ot(t), [a, s] = C(e.condition), [u, f] = C(e.projection), [E, m] = C(e.sort), S = J(t), O = _(async () => {
+    const P = Tr({
+      condition: a,
+      projection: u,
+      sort: E
+    });
+    return S.current.query(
+      P,
+      S.current.attributes
+    );
+  }, [a, u, E, S]), b = _(() => r.execute(O), [r, O]);
+  return F(() => ({
+    ...r,
+    execute: b,
+    setCondition: s,
+    setProjection: f,
+    setSort: m
+  }), [r, b, s, f, m]);
+}
+function Ur(t) {
+  const { initialCondition: e } = t, r = ot(t), [a, s] = C(e), u = J(t), f = _(async () => u.current.count(
+    a,
+    u.current.attributes
+  ), [a, u]), E = _(() => r.execute(f), [r, f]);
+  return F(
+    () => ({
+      ...r,
+      execute: E,
+      setCondition: s
+    }),
+    [r, E, s]
+  );
+}
+function oe(t) {
+  const { initialQuery: e } = t, [r, a] = C(e.condition), [s, u] = C(e.projection), [f, E] = C(e.sort), [m, S] = C(e.limit), O = _(() => wr({
+    condition: r,
+    projection: s,
+    sort: f,
+    limit: m
+  }), [r, s, f, m]);
+  return F(
+    () => ({
+      condition: r,
+      projection: s,
+      sort: f,
+      limit: m,
+      setCondition: a,
+      setProjection: u,
+      setSort: E,
+      setLimit: S,
+      buildQuery: O
+    }),
+    [
+      r,
+      s,
+      f,
+      m,
+      a,
+      u,
+      E,
+      S,
+      O
+    ]
+  );
+}
+function $r(t) {
+  const e = ot(t), r = oe({ initialQuery: t.initialQuery }), a = J(t), s = _(async () => {
+    const f = r.buildQuery();
+    return a.current.list(
+      f,
+      a.current.attributes
+    );
+  }, [r, a]), u = _(() => e.execute(s), [e, s]);
+  return F(
+    () => ({
+      ...e,
+      execute: u,
+      setCondition: r.setCondition,
+      setProjection: r.setProjection,
+      setSort: r.setSort,
+      setLimit: r.setLimit
+    }),
+    [
+      e,
+      u,
+      r.setCondition,
+      r.setProjection,
+      r.setSort,
+      r.setLimit
+    ]
+  );
+}
+function Wr(t) {
+  const e = ot(t), r = oe({ initialQuery: t.initialQuery }), a = J(t), s = _(async () => {
+    const f = r.buildQuery();
+    return a.current.listStream(
+      f,
+      a.current.attributes
+    );
+  }, [r, a]), u = _(() => e.execute(s), [e, s]);
+  return F(
+    () => ({
+      ...e,
+      execute: u,
+      setCondition: r.setCondition,
+      setProjection: r.setProjection,
+      setSort: r.setSort,
+      setLimit: r.setLimit
     }),
-    [r, a, g]
+    [
+      e,
+      u,
+      r.setCondition,
+      r.setProjection,
+      r.setSort,
+      r.setLimit
+    ]
   );
 }
 export {
-  y as PromiseStatus,
-  O as useExecutePromise,
-  A as useFetcher,
-  q as useKeyStorage,
-  I as useLatest,
-  R as useMounted,
-  S as usePromiseState,
-  m as useRequestId
+  He as PromiseStatus,
+  Ur as useCountQuery,
+  ot as useExecutePromise,
+  Ar as useFetcher,
+  Mr as useKeyStorage,
+  J as useLatest,
+  $r as useListQuery,
+  Wr as useListStreamQuery,
+  _t as useMounted,
+  qr as usePagedQuery,
+  Zt as usePromiseState,
+  Kt as useRequestId,
+  Hr as useSingleQuery
 };
 //# sourceMappingURL=index.es.js.map