@cedvict/http-guardian 0.0.1-next.0 → 0.0.1-next.10

package/dist/index.js

@@ -1,16 +1,14 @@
 // src/internal/compose.ts
 function composeGuards(guards, terminal) {
-  return (ctx) => {
-    let idx = -1;
-    const dispatch = (i, c) => {
-      if (i <= idx) return Promise.reject(new Error("composeGuards: next() called multiple times"));
-      idx = i;
-      const guard = guards[i];
-      if (!guard) return terminal(c);
-      return guard(c, (nextCtx) => dispatch(i + 1, nextCtx));
-    };
-    return dispatch(0, ctx);
-  };
+  if (!guards.length) return terminal;
+  return (ctx) => dispatch(0, ctx);
+  function dispatch(i, c) {
+    const guard = guards[i];
+    if (!guard) return terminal(c);
+    return Promise.resolve(
+      guard(c, (nextCtx) => dispatch(i + 1, nextCtx ?? c))
+    );
+  }
 }
 
 // src/internal/url.ts
@@ -36,6 +34,34 @@ function sanitizeHeaderValue(v) {
   if (/[\r\n]/.test(v)) return null;
   return v;
 }
+function base64Encode(input) {
+  if (typeof globalThis.btoa === "function") return globalThis.btoa(input);
+  const B = globalThis.Buffer;
+  if (typeof B?.from === "function") return B.from(input, "utf8").toString("base64");
+  throw new Error("No base64 encoder available in this runtime");
+}
+function isUnsafeMethod(m) {
+  const u = m.toUpperCase();
+  return u !== "GET" && u !== "HEAD" && u !== "OPTIONS";
+}
+function sameOrigin(url, baseOrigin) {
+  if (!baseOrigin) return true;
+  try {
+    return new URL(url).origin === baseOrigin;
+  } catch {
+    return true;
+  }
+}
+function isAllowedOrigin(url, baseOrigin, allowed) {
+  if (!allowed) return sameOrigin(url, baseOrigin);
+  if (typeof allowed === "function") return !!allowed(url);
+  try {
+    const origin = new URL(url).origin;
+    return allowed.includes(origin);
+  } catch {
+    return true;
+  }
+}
 function authGuard(auth) {
   return async (ctx, next) => {
     if (ctx.noAuth) return next(ctx);
@@ -43,6 +69,9 @@ function authGuard(auth) {
     if (auth.mode === "bearer") {
       const token = await auth.getToken();
       if (token) {
+        if (!isAllowedOrigin(ctx.url, ctx.baseOrigin, auth.allowedOrigins)) {
+          return next(ctx);
+        }
         const headerName = auth.headerName ?? "Authorization";
         const prefix = auth.prefix ?? "Bearer";
         const safe = sanitizeHeaderValue(`${prefix} ${token}`);
@@ -50,8 +79,36 @@ function authGuard(auth) {
       }
       return next(ctx);
     }
+    if (auth.mode === "basic") {
+      const cred = await auth.getCredentials();
+      if (cred) {
+        if (!isAllowedOrigin(ctx.url, ctx.baseOrigin, auth.allowedOrigins)) {
+          return next(ctx);
+        }
+        const headerName = auth.headerName ?? "Authorization";
+        const prefix = auth.prefix ?? "Basic";
+        const raw = typeof cred === "string" ? cred : `${cred.username}:${cred.password}`;
+        const safe = sanitizeHeaderValue(`${prefix} ${base64Encode(raw)}`);
+        if (safe) ctx.headers.set(headerName, safe);
+      }
+      return next(ctx);
+    }
+    if (auth.mode === "apiKey") {
+      const key = await auth.getKey();
+      if (key) {
+        if (!isAllowedOrigin(ctx.url, ctx.baseOrigin, auth.allowedOrigins)) {
+          return next(ctx);
+        }
+        const headerName = auth.headerName ?? "X-API-Key";
+        const prefix = auth.prefix ?? "";
+        const value = prefix ? `${prefix} ${key}` : key;
+        const safe = sanitizeHeaderValue(value);
+        if (safe) ctx.headers.set(headerName, safe);
+      }
+      return next(ctx);
+    }
     ctx.credentials = auth.credentials ?? "include";
-    if (auth.csrf) {
+    if (auth.csrf && isUnsafeMethod(ctx.method)) {
       const csrf = await auth.csrf.getToken();
       if (csrf) ctx.headers.set(auth.csrf.headerName, csrf);
     }
@@ -59,6 +116,84 @@ function authGuard(auth) {
   };
 }
 
+// src/internal/headersPolyfill.ts
+function norm(name) {
+  return String(name).toLowerCase();
+}
+var HeadersPolyfill = class {
+  map = /* @__PURE__ */ new Map();
+  constructor(init) {
+    if (!init) return;
+    if (typeof init.forEach === "function" && typeof init.get === "function") {
+      init.forEach((v, k) => this.set(k, v));
+      return;
+    }
+    if (Symbol.iterator in Object(init)) {
+      for (const [k, v] of init) this.append(k, v);
+      return;
+    }
+    for (const [k, v] of Object.entries(init)) {
+      this.set(k, String(v));
+    }
+  }
+  get(name) {
+    const hit = this.map.get(norm(name));
+    return hit ? hit.value : null;
+  }
+  has(name) {
+    return this.map.has(norm(name));
+  }
+  set(name, value) {
+    this.map.set(norm(name), { name, value: String(value) });
+  }
+  append(name, value) {
+    const key = norm(name);
+    const prev = this.map.get(key);
+    if (!prev) {
+      this.map.set(key, { name, value: String(value) });
+      return;
+    }
+    this.map.set(key, { name: prev.name, value: `${prev.value}, ${String(value)}` });
+  }
+  delete(name) {
+    this.map.delete(norm(name));
+  }
+  forEach(cb) {
+    for (const { name, value } of this.map.values()) cb(value, name);
+  }
+  entries() {
+    const it = this.map.values();
+    return {
+      [Symbol.iterator]() {
+        return this;
+      },
+      next() {
+        const n = it.next();
+        if (n.done) return { done: true, value: void 0 };
+        return { done: false, value: [n.value.name, n.value.value] };
+      }
+    };
+  }
+  /** Convert to HeadersInit that any fetch can consume. */
+  toObject() {
+    const out = {};
+    for (const { name, value } of this.map.values()) out[name] = value;
+    return out;
+  }
+};
+function createHeaders(init) {
+  if (typeof globalThis.Headers === "function") {
+    return new globalThis.Headers(init);
+  }
+  return new HeadersPolyfill(init);
+}
+function toFetchHeaders(headers) {
+  if (typeof globalThis.Headers === "function" && headers instanceof globalThis.Headers) {
+    return headers;
+  }
+  return headers.toObject();
+}
+
 // src/internal/stableStringify.ts
 function stableStringify(value) {
   return JSON.stringify(sortValue(value));
@@ -164,37 +299,82 @@ var ParseError = class extends Error {
   }
   name = "ParseError";
 };
+var ILLEGAL_INVOCATION_HINT = `Detected a browser fetch invocation error ("Illegal invocation"). This usually happens when passing a detached reference to window.fetch. Fix by configuring the client with fetch: (input, init) => window.fetch(input, init) or fetch: window.fetch.bind(window).`;
 
 // src/client/httpClient.ts
+function isIllegalInvocation(err) {
+  const msg = String(err?.message ?? err);
+  return /Illegal invocation/i.test(msg);
+}
+function normalizeFetch(f) {
+  const bound = f.bind ? f.bind(globalThis) : f;
+  return ((input, init) => bound(input, init));
+}
+function getDefaultFetch() {
+  if (typeof globalThis.fetch === "function") return globalThis.fetch;
+  throw new Error(
+    "No global fetch detected. Provide a fetch implementation via createHttpClient({ fetch }) or run in an environment that supports fetch (Node >= 18 / modern browsers)."
+  );
+}
 var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
-function createHttpClient(opts) {
-  const cache = opts.cache;
+function createHttpClient(options) {
+  const draft = { ...options };
+  if (draft.plugins?.length) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of draft.plugins) {
+      if (!p || !p.name || typeof p.apply !== "function") continue;
+      if (seen.has(p.name)) continue;
+      seen.add(p.name);
+      p.apply(draft);
+    }
+  }
+  const resolvedFetch = (() => {
+    if (draft.fetch) return normalizeFetch(draft.fetch);
+    let lastRef = null;
+    let lastBound = null;
+    return ((input, init) => {
+      const cur = getDefaultFetch();
+      if (cur !== lastRef || !lastBound) {
+        lastRef = cur;
+        lastBound = normalizeFetch(cur);
+      }
+      return lastBound(input, init);
+    });
+  })();
+  const cache = draft.cache;
   const inFlight = new InFlight();
-  const defaultNotifier = opts.notifier ?? consoleNotifier;
-  const shouldNotify = opts.defaults?.shouldNotify ?? ((r) => !r.ok);
-  const baseGuards = [authGuard(opts.auth), ...opts.guards ?? []];
+  const defaultNotifier = draft.notifier ?? consoleNotifier;
+  const shouldNotify = draft.defaults?.shouldNotify ?? ((r) => !r.ok);
+  const baseGuards = [authGuard(draft.auth), ...draft.guards ?? []];
   async function terminal(ctx) {
     const controller = ctx.timeoutMs ? new AbortController() : void 0;
     const timeout = ctx.timeoutMs ? setTimeout(() => controller?.abort(new TimeoutError()), ctx.timeoutMs) : void 0;
     try {
       const init = {
         method: ctx.method,
-        headers: ctx.headers,
+        headers: toFetchHeaders(ctx.headers),
         ...ctx.body !== void 0 ? { body: ctx.body } : {},
         ...ctx.signal ? { signal: controller ? anySignal([ctx.signal, controller.signal]) : ctx.signal } : controller ? { signal: controller.signal } : {},
         ...ctx.credentials !== void 0 ? { credentials: ctx.credentials } : {},
         ...ctx.redirect !== void 0 ? { redirect: ctx.redirect } : {}
       };
-      return await ctx._fetch(ctx.url, init);
+      try {
+        return await ctx._fetch(ctx.url, init);
+      } catch (err) {
+        if (isIllegalInvocation(err) && typeof globalThis.fetch === "function") {
+          return await globalThis.fetch(ctx.url, init);
+        }
+        throw err;
+      }
     } finally {
       if (timeout) clearTimeout(timeout);
     }
   }
   const pipeline = composeGuards(baseGuards, terminal);
   async function request(method, path, ro) {
-    const requestUrl = withQuery(joinUrl(opts.baseUrl, path), ro?.query);
-    const headers = new Headers();
-    if (opts.defaults?.headers) for (const [k, v] of Object.entries(opts.defaults.headers)) headers.set(k, v);
+    const requestUrl = withQuery(joinUrl(draft.baseUrl, path), ro?.query);
+    const headers = createHeaders();
+    if (draft.defaults?.headers) for (const [k, v] of Object.entries(draft.defaults.headers)) headers.set(k, v);
     if (ro?.headers) {
       for (const [k, v] of Object.entries(ro.headers)) if (v !== void 0) headers.set(k, v);
     }
@@ -212,19 +392,31 @@ function createHttpClient(opts) {
     } else {
       if (!headers.has("accept")) headers.set("accept", "application/json");
     }
-    const timeoutMs = ro?.timeoutMs ?? opts.defaults?.timeoutMs;
+    const timeoutMs = ro?.timeoutMs ?? draft.defaults?.timeoutMs;
     const notifier = ro?.notifier ?? defaultNotifier;
+    const emit = (event) => {
+      const redact = notifier.redact;
+      const n = notifier.notify?.bind(notifier) ?? defaultNotifier.notify.bind(defaultNotifier);
+      return n(redact ? redact(event) : event);
+    };
     const cacheOpts = ro?.cache;
     const wantsCache = method === "GET" && !!cache && !!cacheOpts;
     const dedupe = cacheOpts?.dedupe ?? true;
     const canDedupeWrite = method !== "GET" && !!ro?.idempotencyKey;
-    const inflightKey = (wantsCache || canDedupeWrite) && dedupe ? makeCacheKey({ method, url: requestUrl, headers, ...method === "GET" ? {} : { body: bodyForKey }, ...ro?.idempotencyKey !== void 0 ? { idempotencyKey: ro.idempotencyKey } : {}, ...cacheOpts?.key !== void 0 ? { keyOverride: cacheOpts.key } : {} }) : void 0;
+    const inflightKey = (wantsCache || canDedupeWrite) && dedupe ? makeCacheKey({
+      method,
+      url: requestUrl,
+      headers,
+      ...method === "GET" ? {} : { body: bodyForKey },
+      ...ro?.idempotencyKey !== void 0 ? { idempotencyKey: ro.idempotencyKey } : {},
+      ...cacheOpts?.key !== void 0 ? { keyOverride: cacheOpts.key } : {}
+    }) : void 0;
     if (inflightKey) {
       const existing = inFlight.get(inflightKey);
       if (existing) {
         try {
           const stored = await existing;
-          return asClientResult(stored, requestUrl, opts, ro, notifier, shouldNotify);
+          return asClientResult(stored, requestUrl, draft, ro, notifier, shouldNotify, emit);
         } catch {
         }
       }
@@ -246,7 +438,8 @@ function createHttpClient(opts) {
         }
       }
       const res = await fetchWithRedirects({
-        opts,
+        opts: draft,
+        resolvedFetch,
         pipeline,
         method,
         url: requestUrl,
@@ -260,13 +453,18 @@ function createHttpClient(opts) {
       const envelope = { kind: "network", url: res.url || requestUrl, status: res.status, headers: res.headers, raw };
       if (wantsCache && cacheOpts && res.ok) {
         const key = inflightKey;
-        cache.set(key, { expiresAt: Date.now() + cacheOpts.ttlMs, value: raw, ...cacheOpts.tags ? { tags: cacheOpts.tags } : {} });
+        cache.set(key, {
+          expiresAt: Date.now() + cacheOpts.ttlMs,
+          value: raw,
+          ...cacheOpts.tags ? { tags: cacheOpts.tags } : {}
+        });
       }
       return envelope;
       async function refreshInBackground(key) {
         try {
           const res2 = await fetchWithRedirects({
-            opts,
+            opts: draft,
+            resolvedFetch,
             pipeline,
             method,
             url: requestUrl,
@@ -278,7 +476,11 @@ function createHttpClient(opts) {
           });
           if (!res2.ok) return;
           const raw2 = await decodeResponse(res2);
-          cache.set(key, { expiresAt: Date.now() + cacheOpts.ttlMs, value: raw2, ...cacheOpts.tags ? { tags: cacheOpts.tags } : {} });
+          cache.set(key, {
+            expiresAt: Date.now() + cacheOpts.ttlMs,
+            value: raw2,
+            ...cacheOpts.tags ? { tags: cacheOpts.tags } : {}
+          });
         } catch {
         }
       }
@@ -286,10 +488,13 @@ function createHttpClient(opts) {
     if (inflightKey) inFlight.set(inflightKey, promise);
     try {
       const stored = await promise;
-      return asClientResult(stored, requestUrl, opts, ro, notifier, shouldNotify);
+      return asClientResult(stored, requestUrl, draft, ro, notifier, shouldNotify, emit);
     } catch (e) {
-      const err = e instanceof TimeoutError ? e : new NetworkError("Network request failed", e);
-      if (shouldNotify({ ok: false, status: 0 })) notifier.notify({ type: "network-error", level: "error", title: "Network error", message: err.message, url: requestUrl });
+      const err = e instanceof TimeoutError ? e : new NetworkError(
+        isIllegalInvocation(e) ? `Network request failed. ${ILLEGAL_INVOCATION_HINT}` : "Network request failed",
+        e
+      );
+      if (shouldNotify({ ok: false, status: 0 })) emit({ type: "network-error", level: "error", title: "Network error", message: err.message, url: requestUrl });
       return { ok: false, status: 0, headers: new Headers(), errors: [{ message: err.message, details: e }], raw: null, url: requestUrl };
     }
   }
@@ -321,7 +526,19 @@ async function fetchWithRedirects(args) {
     );
     if (!REDIRECT_STATUSES.has(res.status)) return res;
     const loc = res.headers.get("location");
-    if (!loc) throw new RedirectError("Redirect without Location header", currentUrl);
+    if (!loc) {
+      return args.pipeline(
+        makeCtx(
+          {
+            ...args,
+            url: currentUrl,
+            method,
+            ...body !== void 0 ? { body } : {}
+          },
+          "follow"
+        )
+      );
+    }
     const nextUrl = new URL(loc, currentUrl).toString();
     const decision = policy.onRedirect?.({ fromUrl: currentUrl, toUrl: nextUrl, status: res.status, hop, method });
     if (decision?.action === "deny") throw new RedirectError(decision.reason ?? "Redirect denied by policy", currentUrl, nextUrl);
@@ -341,18 +558,38 @@ async function fetchWithRedirects(args) {
 }
 function stripAuthOnCrossOriginRedirect(opts, initialUrl, toUrl, headers) {
   try {
-    if (opts.auth.mode !== "bearer") return;
     const initialOrigin = new URL(initialUrl).origin;
     const toOrigin = new URL(toUrl).origin;
-    if (initialOrigin !== toOrigin) {
+    if (initialOrigin === toOrigin) return;
+    if (opts.auth.mode === "bearer") {
+      const headerName = opts.auth.headerName ?? "Authorization";
+      headers.delete(headerName);
+      return;
+    }
+    if (opts.auth.mode === "basic") {
       const headerName = opts.auth.headerName ?? "Authorization";
       headers.delete(headerName);
+      return;
+    }
+    if (opts.auth.mode === "apiKey") {
+      const headerName = opts.auth.headerName ?? "X-API-Key";
+      headers.delete(headerName);
+      return;
     }
   } catch {
   }
 }
 function makeCtx(args, redirect) {
+  const baseOrigin = (() => {
+    try {
+      return new URL(args.opts.baseUrl).origin;
+    } catch {
+      return "";
+    }
+  })();
   return {
+    baseUrl: args.opts.baseUrl,
+    baseOrigin,
     method: args.method,
     url: args.url,
     headers: args.headers,
@@ -363,10 +600,11 @@ function makeCtx(args, redirect) {
     attempt: 0,
     auth: args.opts.auth,
     redirect,
-    _fetch: args.opts.fetch ?? fetch
+    _fetch: args.resolvedFetch
   };
 }
 async function decodeResponse(res) {
+  if (res.status === 204) return null;
   const ct = res.headers.get("content-type") ?? "";
   if (ct.includes("application/json")) {
     try {
@@ -381,10 +619,10 @@ async function decodeResponse(res) {
     throw new ParseError("Failed to read response body", void 0, e);
   }
 }
-function asClientResult(envelope, requestUrl, opts, ro, notifier, shouldNotify) {
+function asClientResult(envelope, requestUrl, opts, ro, notifier, shouldNotify, emit) {
   if (envelope?.kind === "cache-miss") {
     const errors2 = [{ message: "Cache miss" }];
-    if (shouldNotify({ ok: false, status: 0 })) notifier.notify({ type: "http-error", level: "warning", title: "Cache", message: "Cache miss", status: 0, errors: errors2, url: requestUrl });
+    if (shouldNotify({ ok: false, status: 0 })) emit({ type: "http-error", level: "warning", title: "Cache", message: "Cache miss", status: 0, errors: errors2, url: requestUrl });
     return { ok: false, status: 0, headers: new Headers(), errors: errors2, raw: envelope.raw, url: requestUrl };
   }
   const status = envelope.status ?? 0;
@@ -399,17 +637,24 @@ function asClientResult(envelope, requestUrl, opts, ro, notifier, shouldNotify)
       return { ok: true, status, headers: resHeaders, data, raw, url: finalUrl };
     } catch (e) {
       const msg2 = e instanceof Error ? e.message : "Schema parse failed";
-      if (shouldNotify({ ok: false, status })) notifier.notify({ type: "parse-error", level: "error", title: "Parse error", message: msg2, url: finalUrl });
+      if (shouldNotify({ ok: false, status })) emit({ type: "parse-error", level: "error", title: "Parse error", message: msg2, url: finalUrl });
       return { ok: false, status, headers: resHeaders, errors: [{ message: msg2, details: e }], raw, url: finalUrl };
     }
   }
   const errors = opts.parser.getErrors(raw, status);
   const msg = errors[0]?.message ?? (status ? `HTTP ${status}` : "Request failed");
-  if (shouldNotify({ ok: false, status })) notifier.notify({ type: "http-error", level: status >= 500 ? "error" : "warning", title: "Request failed", message: msg, status, errors, url: finalUrl });
+  if (shouldNotify({ ok: false, status })) emit({ type: "http-error", level: status >= 500 ? "error" : "warning", title: "Request failed", message: msg, status, errors, url: finalUrl });
   return { ok: false, status, headers: resHeaders, errors, raw, url: finalUrl };
 }
 function anySignal(signals) {
   const valid = signals.filter(Boolean);
+  const any = AbortSignal.any;
+  if (any) {
+    try {
+      return any(valid);
+    } catch {
+    }
+  }
   const controller = new AbortController();
   const onAbort = () => controller.abort();
   for (const s of valid) {
@@ -425,7 +670,8 @@ function bearerAuth(getToken, opts) {
     mode: "bearer",
     getToken,
     ...opts?.headerName !== void 0 ? { headerName: opts.headerName } : {},
-    ...opts?.prefix !== void 0 ? { prefix: opts.prefix } : {}
+    ...opts?.prefix !== void 0 ? { prefix: opts.prefix } : {},
+    ...opts?.allowedOrigins !== void 0 ? { allowedOrigins: opts.allowedOrigins } : {}
   };
 }
 function cookieAuth(opts) {
@@ -435,6 +681,24 @@ function cookieAuth(opts) {
     ...opts?.csrf !== void 0 ? { csrf: opts.csrf } : {}
   };
 }
+function basicAuth(getCredentials, opts) {
+  return {
+    mode: "basic",
+    getCredentials,
+    ...opts?.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts?.prefix !== void 0 ? { prefix: opts.prefix } : {},
+    ...opts?.allowedOrigins !== void 0 ? { allowedOrigins: opts.allowedOrigins } : {}
+  };
+}
+function apiKeyAuth(getKey, opts) {
+  return {
+    mode: "apiKey",
+    getKey,
+    ...opts?.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts?.prefix !== void 0 ? { prefix: opts.prefix } : {},
+    ...opts?.allowedOrigins !== void 0 ? { allowedOrigins: opts.allowedOrigins } : {}
+  };
+}
 function noAuth() {
   return { mode: "none" };
 }
@@ -459,6 +723,515 @@ function retryGuard(opts) {
   };
 }
 
+// src/guards/cookieSafeRefreshGuard.ts
+var REFRESH_FLAG = "__hg_is_refresh__";
+var RETRY_FLAG = "__hg_refresh_retry__";
+function isReplayableBody(body) {
+  if (body == null) return true;
+  if (typeof body === "string") return true;
+  if (typeof Blob !== "undefined" && body instanceof Blob) return true;
+  if (typeof FormData !== "undefined" && body instanceof FormData) return true;
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return true;
+  if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) return true;
+  if (typeof Uint8Array !== "undefined" && body instanceof Uint8Array) return true;
+  return false;
+}
+function normalizePath(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    const q = url.indexOf("?");
+    const h = url.indexOf("#");
+    const cut = Math.min(q === -1 ? url.length : q, h === -1 ? url.length : h);
+    return url.slice(0, cut);
+  }
+}
+function parseRetryAfterMs(headers) {
+  const ra = headers.get("retry-after");
+  if (!ra) return null;
+  const seconds = Number(ra);
+  if (!Number.isNaN(seconds) && seconds >= 0) return seconds * 1e3;
+  const date = Date.parse(ra);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return null;
+}
+function isAbsoluteUrl(u) {
+  try {
+    void new URL(u);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cookieSafeRefreshGuard(opts) {
+  const trigger = new Set(opts.triggerStatuses ?? [401, 419]);
+  const maxRetry = opts.maxRetry ?? 1;
+  const honorRetryAfter = opts.honorRetryAfter ?? true;
+  let refreshPromise = null;
+  let refreshCooldownUntil = 0;
+  return async (ctx, next) => {
+    const anyCtx = ctx;
+    if (anyCtx[REFRESH_FLAG]) return next(ctx);
+    const path = normalizePath(ctx.url);
+    if (opts.excludePaths?.includes(path)) return next(ctx);
+    if (ctx.noAuth) return next(ctx);
+    const refreshPathNorm = normalizePath(resolveRefreshUrl(ctx, opts.refreshPath));
+    if (path === refreshPathNorm) return next(ctx);
+    if (honorRetryAfter && refreshCooldownUntil > Date.now()) {
+      return next(ctx);
+    }
+    const res = await next(ctx);
+    if (!trigger.has(res.status)) return res;
+    if (opts.shouldRefresh && !opts.shouldRefresh(ctx, res.status)) return res;
+    const alreadyRetried = Number(anyCtx[RETRY_FLAG] ?? 0);
+    if (alreadyRetried >= maxRetry) return res;
+    if (!isReplayableBody(ctx.body)) return res;
+    const decision = await (refreshPromise ??= doRefresh(ctx, next).finally(() => {
+      refreshPromise = null;
+    }));
+    if (!decision.ok) {
+      opts.onRefreshFailed?.({
+        url: ctx.url,
+        ...decision.reason !== void 0 ? { reason: decision.reason } : {},
+        ...decision.status !== void 0 ? { status: decision.status } : {}
+      });
+      return res;
+    }
+    opts.onRefreshSuccess?.({ url: ctx.url });
+    const retryCtx = Object.assign({}, ctx, { attempt: ctx.attempt + 1 });
+    retryCtx[RETRY_FLAG] = alreadyRetried + 1;
+    await applyCookieAuth(retryCtx);
+    return next(retryCtx);
+  };
+  async function doRefresh(originalCtx, next) {
+    if (honorRetryAfter && refreshCooldownUntil > Date.now()) {
+      return { ok: false, reason: "Refresh cooldown active" };
+    }
+    const refreshUrl = resolveRefreshUrl(originalCtx, opts.refreshPath);
+    const refreshCtx = {
+      ...originalCtx,
+      url: refreshUrl,
+      method: opts.refreshMethod ?? "POST",
+      // Un refresh n’a en général pas besoin du body original
+      ...Object.prototype.hasOwnProperty.call(originalCtx, "body") ? { body: void 0 } : {},
+      attempt: 0
+    };
+    refreshCtx[REFRESH_FLAG] = true;
+    refreshCtx[RETRY_FLAG] = 0;
+    await applyCookieAuth(refreshCtx);
+    try {
+      const res = await next(refreshCtx);
+      if (res.status === 429 && honorRetryAfter) {
+        const ms = parseRetryAfterMs(res.headers);
+        refreshCooldownUntil = Date.now() + (ms ?? 3e4);
+        return { ok: false, reason: "Refresh rate-limited (429)", status: 429 };
+      }
+      if (!res.ok) {
+        return { ok: false, reason: `Refresh failed (HTTP ${res.status})`, status: res.status };
+      }
+      return { ok: true };
+    } catch (e) {
+      return { ok: false, reason: e instanceof Error ? e.message : "Refresh exception" };
+    }
+  }
+  function resolveRefreshUrl(ctx, refreshPath) {
+    if (isAbsoluteUrl(refreshPath)) return refreshPath;
+    return joinUrl(ctx.baseUrl, refreshPath);
+  }
+  async function applyCookieAuth(ctx) {
+    if (ctx.noAuth) return;
+    const auth = ctx.auth;
+    if (!auth || auth.mode !== "cookie") return;
+    if (ctx.credentials === void 0) {
+      ctx.credentials = auth.credentials ?? "include";
+    }
+    if (auth.csrf) {
+      const hn = auth.csrf.headerName;
+      if (!ctx.headers.has(hn)) {
+        const t = await auth.csrf.getToken();
+        if (t != null && String(t) !== "") ctx.headers.set(hn, String(t));
+      }
+    }
+  }
+}
+
+// src/guards/bearerRefreshGuard.ts
+var REFRESH_FLAG2 = "__hg_bearer_refresh_in_flight__";
+var RETRY_FLAG2 = "__hg_bearer_refresh_retry__";
+function isReplayableBody2(body) {
+  if (body == null) return true;
+  if (typeof body === "string") return true;
+  if (typeof Blob !== "undefined" && body instanceof Blob) return true;
+  if (typeof FormData !== "undefined" && body instanceof FormData) return true;
+  if (typeof URLSearchParams !== "undefined" && body instanceof URLSearchParams) return true;
+  if (typeof ArrayBuffer !== "undefined" && body instanceof ArrayBuffer) return true;
+  if (typeof Uint8Array !== "undefined" && body instanceof Uint8Array) return true;
+  return false;
+}
+function bearerRefreshGuard(opts) {
+  const trigger = new Set(opts.triggerStatuses ?? [401]);
+  const queueTimeoutMs = opts.queueTimeoutMs ?? 3e4;
+  let refreshPromise = null;
+  return async (ctx, next) => {
+    const anyCtx = ctx;
+    if (ctx.noAuth) return next(ctx);
+    if (ctx.auth.mode !== "bearer") return next(ctx);
+    if (opts.skipRefreshFor?.(ctx)) return next(ctx);
+    if (anyCtx[RETRY_FLAG2]) return next(ctx);
+    if (anyCtx[REFRESH_FLAG2]) return next(ctx);
+    const res = await next(ctx);
+    if (!trigger.has(res.status)) return res;
+    if (!isReplayableBody2(ctx.body)) return res;
+    try {
+      await withTimeout(
+        refreshPromise ??= runRefresh(opts).finally(() => {
+          refreshPromise = null;
+        }),
+        queueTimeoutMs
+      );
+    } catch {
+      return res;
+    }
+    const retryCtx = cloneCtxForReplay(ctx);
+    retryCtx[RETRY_FLAG2] = true;
+    await applyBearerAuth(retryCtx, ctx.auth);
+    return next(retryCtx);
+  };
+  async function runRefresh(o) {
+    try {
+      const tokens = await o.refreshFn();
+      if (o.onTokenRefreshed) await o.onTokenRefreshed(tokens);
+      return tokens;
+    } catch (e) {
+      if (o.onAuthFailed) {
+        try {
+          await o.onAuthFailed(e);
+        } catch {
+        }
+      }
+      throw e;
+    }
+  }
+}
+function cloneCtxForReplay(ctx) {
+  return Object.assign({}, ctx, { attempt: ctx.attempt + 1 });
+}
+async function applyBearerAuth(ctx, auth) {
+  const headerName = auth.headerName ?? "Authorization";
+  const prefix = auth.prefix ?? "Bearer";
+  const token = await auth.getToken();
+  if (token == null || token === "") {
+    ctx.headers.delete(headerName);
+    return;
+  }
+  ctx.headers.set(headerName, prefix ? `${prefix} ${token}` : String(token));
+}
+function withTimeout(p, ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return p;
+  return new Promise((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error(`bearerRefreshGuard: queue timeout after ${ms}ms`)), ms);
+    p.then(
+      (v) => {
+        clearTimeout(t);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(t);
+        reject(e);
+      }
+    );
+  });
+}
+
+// src/guards/csrfGuard.ts
+var DEFAULT_METHODS = ["POST", "PUT", "PATCH", "DELETE"];
+function readCookie(name) {
+  if (typeof document === "undefined") return null;
+  const cookieStr = document.cookie;
+  if (typeof cookieStr !== "string" || cookieStr.length === 0) return null;
+  const target = encodeURIComponent(name);
+  const parts = cookieStr.split(";");
+  for (const part of parts) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const k = part.slice(0, eq).trim();
+    if (k === name || k === target) {
+      return decodeURIComponent(part.slice(eq + 1).trim());
+    }
+  }
+  return null;
+}
+function csrfGuard(opts = {}) {
+  const headerName = opts.headerName ?? "X-CSRF-Token";
+  const methods = new Set((opts.applyTo ?? DEFAULT_METHODS).map((m) => m.toUpperCase()));
+  let cachedHeaderToken = null;
+  return async (ctx, next) => {
+    if (!methods.has(ctx.method)) return next(ctx);
+    if (ctx.headers.has(headerName)) {
+      const res2 = await next(ctx);
+      maybeReadResponseHeader(res2);
+      return res2;
+    }
+    const token = await resolveToken();
+    if (token != null && token !== "") {
+      ctx.headers.set(headerName, token);
+    }
+    const res = await next(ctx);
+    maybeReadResponseHeader(res);
+    return res;
+  };
+  async function resolveToken(_ctx) {
+    if (opts.tokenFromCookie) {
+      const t = readCookie(opts.tokenFromCookie);
+      if (t != null && t !== "") return t;
+    }
+    if (opts.tokenFromHeader && cachedHeaderToken != null) {
+      return cachedHeaderToken;
+    }
+    if (opts.tokenFromStorage) {
+      try {
+        const t = await opts.tokenFromStorage();
+        if (t != null && t !== "") return t;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  function maybeReadResponseHeader(res) {
+    if (!opts.tokenFromHeader) return;
+    try {
+      const v = res.headers?.get?.(opts.tokenFromHeader);
+      if (v != null && v !== "") cachedHeaderToken = v;
+    } catch {
+    }
+  }
+}
+
+// src/guards/correlationIdGuard.ts
+var CORRELATION_FLAG = "__hg_correlation_id__";
+function defaultGenerator() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") {
+    try {
+      return c.randomUUID();
+    } catch {
+    }
+  }
+  const ts = Date.now().toString(36);
+  const r1 = Math.floor(Math.random() * 4294967295).toString(36);
+  const r2 = Math.floor(Math.random() * 4294967295).toString(36);
+  return `${ts}-${r1}${r2}`;
+}
+function correlationIdGuard(opts = {}) {
+  const headerName = opts.headerName ?? "X-Correlation-Id";
+  const generator = opts.generator ?? defaultGenerator;
+  const readResponseHeader = opts.readResponseHeader ?? true;
+  return async (ctx, next) => {
+    const anyCtx = ctx;
+    let id = anyCtx[CORRELATION_FLAG] ?? void 0;
+    if (id == null) {
+      const existing = ctx.headers.get(headerName);
+      id = existing != null && existing !== "" ? existing : generator();
+      anyCtx[CORRELATION_FLAG] = id;
+    }
+    if (!ctx.headers.has(headerName)) {
+      ctx.headers.set(headerName, id);
+    }
+    if (!ctx.meta) ctx.meta = {};
+    if (!ctx.meta.correlationId) ctx.meta.correlationId = id;
+    const res = await next(ctx);
+    if (readResponseHeader) {
+      try {
+        const v = res.headers?.get?.(headerName);
+        if (v != null && v !== "") {
+          if (!ctx.meta) ctx.meta = {};
+          ctx.meta.correlationId = v;
+        }
+      } catch {
+      }
+    }
+    return res;
+  };
+}
+
+// src/guards/idempotencyGuard.ts
+var DEFAULT_METHODS2 = ["POST", "PUT", "PATCH"];
+var IDEMPOTENCY_FLAG = "__hg_idempotency_key__";
+function defaultGenerator2() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") {
+    try {
+      return c.randomUUID();
+    } catch {
+    }
+  }
+  const ts = Date.now().toString(36);
+  const r1 = Math.floor(Math.random() * 4294967295).toString(36);
+  const r2 = Math.floor(Math.random() * 4294967295).toString(36);
+  return `${ts}-${r1}${r2}`;
+}
+function idempotencyGuard(opts = {}) {
+  const headerName = opts.headerName ?? "X-Idempotency-Key";
+  const methods = new Set((opts.applyTo ?? DEFAULT_METHODS2).map((m) => m.toUpperCase()));
+  const generator = opts.generator ?? defaultGenerator2;
+  const respectExisting = opts.respectExisting ?? true;
+  return async (ctx, next) => {
+    if (!methods.has(ctx.method)) return next(ctx);
+    const anyCtx = ctx;
+    let key = anyCtx[IDEMPOTENCY_FLAG] ?? void 0;
+    if (key == null && respectExisting) {
+      const fromHeader = ctx.headers.get(headerName);
+      if (fromHeader != null && fromHeader !== "") {
+        key = fromHeader;
+      } else if (ctx.idempotencyKey != null && ctx.idempotencyKey !== "") {
+        key = ctx.idempotencyKey;
+      } else if (ctx.meta?.idempotencyKey != null && ctx.meta.idempotencyKey !== "") {
+        key = ctx.meta.idempotencyKey;
+      }
+    }
+    if (key == null) key = generator();
+    anyCtx[IDEMPOTENCY_FLAG] = key;
+    if (!ctx.headers.has(headerName)) ctx.headers.set(headerName, key);
+    if (!ctx.meta) ctx.meta = {};
+    if (!ctx.meta.idempotencyKey) ctx.meta.idempotencyKey = key;
+    return next(ctx);
+  };
+}
+
+// src/guards/unauthorizedGuard.ts
+function normalizePath2(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    const q = url.indexOf("?");
+    const h = url.indexOf("#");
+    const cut = Math.min(q === -1 ? url.length : q, h === -1 ? url.length : h);
+    return url.slice(0, cut);
+  }
+}
+function unauthorizedGuard(opts) {
+  const statuses = opts.statuses ?? [401, 419];
+  const ignoreNoAuth = opts.ignoreNoAuth ?? true;
+  const once = opts.once ?? true;
+  const cooldownMs = opts.cooldownMs ?? 250;
+  let locked = false;
+  let cooldownUntil = 0;
+  return async (ctx, next) => {
+    let res;
+    try {
+      res = await next(ctx);
+    } catch (e) {
+      throw e;
+    }
+    if (ignoreNoAuth && ctx.noAuth) return res;
+    const path = normalizePath2(ctx.url);
+    if (opts.excludePaths?.includes(path)) return res;
+    if (!statuses.includes(res.status)) return res;
+    if (opts.shouldHandle && !opts.shouldHandle(ctx, res.status)) return res;
+    const now = Date.now();
+    if (now < cooldownUntil) return res;
+    if (once) {
+      if (locked) return res;
+      locked = true;
+    }
+    try {
+      opts.onUnauthorized({ url: ctx.url, status: res.status });
+    } finally {
+      cooldownUntil = Date.now() + cooldownMs;
+      if (once) setTimeout(() => locked = false, cooldownMs);
+    }
+    return res;
+  };
+}
+
+// src/guards/instrumentGuard.ts
+var REFRESH_FLAG3 = "__hg_is_refresh__";
+var RETRY_FLAG3 = "__hg_refresh_retry__";
+function safeUrl(u) {
+  try {
+    const url = new URL(u);
+    return url.toString();
+  } catch {
+    return u;
+  }
+}
+function nowMs() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function headersToObject(h) {
+  if (!h) return {};
+  const out = {};
+  try {
+    h.forEach((v, k) => {
+      const key = String(k).toLowerCase();
+      if (key === "authorization" || key === "cookie" || key === "set-cookie" || key === "x-api-key" || key === "proxy-authorization") {
+        out[k] = "[REDACTED]";
+      } else {
+        out[k] = v;
+      }
+    });
+  } catch {
+  }
+  return out;
+}
+var __hg_req_seq = 0;
+function instrumentGuard(opts, guard) {
+  const log = opts.log ?? ((line, data) => data !== void 0 ? console.log(line, data) : console.log(line));
+  return async (ctx, next) => {
+    const id = ++__hg_req_seq;
+    const t0 = nowMs();
+    const url = safeUrl(ctx.url);
+    const method = ctx.method ?? "GET";
+    if (opts.include && !opts.include.test(url)) {
+      return guard(ctx, next);
+    }
+    if (opts.exclude && opts.exclude.test(url)) {
+      return guard(ctx, next);
+    }
+    const anyCtx = ctx;
+    const attempt = ctx.attempt ?? 0;
+    const isRefresh = Boolean(anyCtx[REFRESH_FLAG3]);
+    const retryCount = Number(anyCtx[RETRY_FLAG3] ?? 0);
+    const noAuth2 = Boolean(ctx.noAuth);
+    const baseLine = `[HG][#${id}][${opts.name}]`;
+    log(`${baseLine} \u25B6 start`, {
+      method,
+      url,
+      attempt,
+      retryCount,
+      isRefresh,
+      noAuth: noAuth2,
+      baseUrl: ctx.baseUrl,
+      ...opts.logInit ? {
+        credentials: ctx.credentials,
+        redirect: ctx.redirect,
+        headers: headersToObject(ctx.headers)
+      } : {},
+      ...opts.stack ? { stack: new Error().stack } : {}
+    });
+    try {
+      const res = await guard(ctx, next);
+      const dt = Math.round(nowMs() - t0);
+      log(`${baseLine} \u25C0 end (${dt}ms)`, {
+        status: res.status,
+        ok: res.ok,
+        url: res.url || url,
+        redirected: res.redirected,
+        location: res.headers?.get?.("location") ?? null,
+        retryAfter: res.headers?.get?.("retry-after") ?? null
+      });
+      return res;
+    } catch (e) {
+      const dt = Math.round(nowMs() - t0);
+      log(`${baseLine} \u2716 throw (${dt}ms)`, {
+        error: e instanceof Error ? { name: e.name, message: e.message, stack: e.stack } : e
+      });
+      throw e;
+    }
+  };
+}
+
 // src/cache/memoryCache.ts
 function memoryCache(opts) {
   const max = opts?.maxEntries ?? 1e3;
@@ -655,6 +1428,268 @@ function createApiParserGraphQL(opts) {
   });
 }
 
-export { NetworkError, ParseError, RedirectError, TimeoutError, alertNotifier, bearerAuth, consoleNotifier, cookieAuth, createApiParserGraphQL, createApiParserLaravel, createApiParserNest, createApiParserRestClassic, createHttpClient, createShapeParser, fromZod, memoryCache, noAuth, retryGuard, schema, tailwindAlertRenderer };
+// src/parsing/apiParserStructured.ts
+function isRecord(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function pickString(o, key) {
+  const v = o[key];
+  return typeof v === "string" ? v : void 0;
+}
+function createApiParserStructured(opts = {}) {
+  const exposeMeta = opts.exposeMeta ?? true;
+  const honorRetryableHint = opts.honorRetryableHint ?? true;
+  return createShapeParser({
+    isSuccess: (raw, status) => {
+      if (isRecord(raw) && "success" in raw) return raw["success"] === true;
+      return status >= 200 && status < 400;
+    },
+    getData: (raw) => {
+      if (isRecord(raw) && raw["success"] === true && "data" in raw) {
+        return raw["data"];
+      }
+      return raw;
+    },
+    getErrors: (raw, status) => {
+      if (!isRecord(raw)) {
+        return [{ message: status ? `HTTP ${status}` : "Request failed" }];
+      }
+      const env = raw;
+      const meta = isRecord(env["meta"]) ? env["meta"] : void 0;
+      const traceId = meta?.traceId;
+      const spanId = meta?.spanId;
+      const issues = Array.isArray(env["issues"]) ? env["issues"] : [];
+      const topMessage = pickString(env, "message");
+      const topCode = pickString(env, "code");
+      const topI18n = isRecord(env["i18n"]) ? env["i18n"] : void 0;
+      const baseDetails = (extra = {}) => ({
+        ...traceId !== void 0 ? { traceId } : {},
+        ...spanId !== void 0 ? { spanId } : {},
+        ...exposeMeta ? { envelope: env } : {},
+        ...extra
+      });
+      if (issues.length > 0) {
+        return issues.map((iss) => {
+          const message = iss.message ?? topMessage ?? (status ? `HTTP ${status}` : "Request failed");
+          const code = iss.code ?? topCode;
+          const issueDetails = baseDetails({
+            ...iss.category !== void 0 ? { category: iss.category } : {},
+            ...iss.severity !== void 0 ? { severity: iss.severity } : {},
+            ...honorRetryableHint && iss.retryable !== void 0 ? { retryable: iss.retryable } : {},
+            ...iss.i18n !== void 0 ? { i18n: iss.i18n } : topI18n !== void 0 ? { i18n: topI18n } : {}
+          });
+          return {
+            message,
+            ...code !== void 0 ? { code } : {},
+            ...iss.field !== void 0 ? { field: iss.field } : {},
+            details: issueDetails
+          };
+        });
+      }
+      const details = baseDetails({
+        ...topI18n !== void 0 ? { i18n: topI18n } : {}
+      });
+      return [
+        {
+          message: topMessage ?? (status ? `HTTP ${status}` : "Request failed"),
+          ...topCode !== void 0 ? { code: topCode } : {},
+          details
+        }
+      ];
+    }
+  });
+}
+
+// src/presets/presetBuilder.ts
+function createPresetBuilder(init) {
+  const state = {
+    baseUrl: init?.baseUrl ?? "",
+    parser: init?.parser ?? createApiParserRestClassic(),
+    auth: init?.auth ?? noAuth(),
+    ...init?.fetch ? { fetch: init.fetch } : {},
+    ...init?.notifier ? { notifier: init.notifier } : { notifier: consoleNotifier },
+    guards: []
+  };
+  function ensureBaseUrl() {
+    if (!state.baseUrl) throw new Error("presetBuilder: baseUrl is required");
+  }
+  const api = {
+    /** Set / override baseUrl */
+    baseUrl(baseUrl) {
+      state.baseUrl = baseUrl;
+      return api;
+    },
+    /** Set / override parser */
+    parser(parser) {
+      state.parser = parser;
+      return api;
+    },
+    /** Set / override fetch */
+    fetch(fetchImpl) {
+      state.fetch = fetchImpl;
+      return api;
+    },
+    /** Set / override notifier */
+    notifier(notifier) {
+      state.notifier = notifier;
+      return api;
+    },
+    /** Add guard(s) (preserves order) */
+    guards(...guards) {
+      state.guards = [...state.guards ?? [], ...guards];
+      return api;
+    },
+    /** Enable in-memory cache */
+    memoryCache(opts) {
+      state.cache = memoryCache(opts);
+      return api;
+    },
+    /** Low-level cache assignment */
+    cache(cache) {
+      if (cache === void 0) {
+        delete state.cache;
+      } else {
+        state.cache = cache;
+      }
+      return api;
+    },
+    /** Default headers / timeouts / notify policy */
+    defaults(defaults) {
+      state.defaults = { ...state.defaults ?? {}, ...defaults ?? {} };
+      return api;
+    },
+    /** Redirect policy */
+    redirects(redirects) {
+      if (redirects === void 0) {
+        delete state.redirects;
+      } else {
+        state.redirects = redirects;
+      }
+      return api;
+    },
+    /** Auth presets */
+    auth(auth) {
+      state.auth = auth;
+      return api;
+    },
+    bearer(getToken, opts) {
+      state.auth = bearerAuth(getToken, opts);
+      return api;
+    },
+    cookie(opts) {
+      state.auth = cookieAuth(opts);
+      return api;
+    },
+    basic(getCred, opts) {
+      state.auth = basicAuth(getCred, opts);
+      return api;
+    },
+    apiKey(getKey, opts) {
+      state.auth = apiKeyAuth(getKey, opts);
+      return api;
+    },
+    none() {
+      state.auth = noAuth();
+      return api;
+    },
+    /**
+     * Cookie refresh guard preset (only meaningful for cookie auth).
+     * You can still add it manually via `.guards(...)`.
+     */
+    cookieRefresh(opts) {
+      state.guards = [...state.guards ?? [], cookieSafeRefreshGuard(opts)];
+      return api;
+    },
+    /** Unauthorized handler preset (redirect/logout). */
+    unauthorized(opts) {
+      state.guards = [...state.guards ?? [], unauthorizedGuard(opts)];
+      return api;
+    },
+    /** Returns the final HttpClientOptions */
+    options() {
+      ensureBaseUrl();
+      return { ...state, guards: [...state.guards ?? []] };
+    },
+    /** Creates the http client */
+    create() {
+      ensureBaseUrl();
+      return createHttpClient(api.options());
+    }
+  };
+  return api;
+}
+function createSimpleClient(opts) {
+  return createPresetBuilder(opts).create();
+}
+function createBearerClient(opts) {
+  const bearerOpts = {
+    ...opts.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts.prefix !== void 0 ? { prefix: opts.prefix } : {}
+  };
+  return createPresetBuilder({
+    baseUrl: opts.baseUrl,
+    ...opts.parser ? { parser: opts.parser } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.notifier ? { notifier: opts.notifier } : {}
+  }).bearer(opts.getToken, Object.keys(bearerOpts).length ? bearerOpts : void 0).create();
+}
+function createCookieClient(opts) {
+  const b = createPresetBuilder({
+    baseUrl: opts.baseUrl,
+    ...opts.parser ? { parser: opts.parser } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.notifier ? { notifier: opts.notifier } : {}
+  }).cookie({
+    ...opts.credentials !== void 0 ? { credentials: opts.credentials } : {},
+    ...opts.csrf !== void 0 ? { csrf: opts.csrf } : {}
+  });
+  if (opts.refresh) b.cookieRefresh(opts.refresh);
+  return b.create();
+}
+function createBasicClient(opts) {
+  const basicOpts = {
+    ...opts.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts.prefix !== void 0 ? { prefix: opts.prefix } : {}
+  };
+  return createPresetBuilder({
+    baseUrl: opts.baseUrl,
+    ...opts.parser ? { parser: opts.parser } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.notifier ? { notifier: opts.notifier } : {}
+  }).basic(opts.getCredentials, Object.keys(basicOpts).length ? basicOpts : void 0).create();
+}
+function createApiKeyClient(opts) {
+  const apiKeyOpts = {
+    ...opts.headerName !== void 0 ? { headerName: opts.headerName } : {},
+    ...opts.prefix !== void 0 ? { prefix: opts.prefix } : {}
+  };
+  return createPresetBuilder({
+    baseUrl: opts.baseUrl,
+    ...opts.parser ? { parser: opts.parser } : {},
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.notifier ? { notifier: opts.notifier } : {}
+  }).apiKey(opts.getKey, Object.keys(apiKeyOpts).length ? apiKeyOpts : void 0).create();
+}
+
+// src/aliases.ts
+function createClient(opts) {
+  const parser = opts.parser ?? createApiParserRestClassic();
+  const auth = opts.auth ?? noAuth();
+  const notifier = opts.notifier ?? consoleNotifier;
+  const cfg = {
+    baseUrl: opts.baseUrl,
+    parser,
+    auth,
+    notifier,
+    ...opts.fetch ? { fetch: opts.fetch } : {},
+    ...opts.defaults ? { defaults: opts.defaults } : {},
+    ...opts.cache ? { cache: opts.cache } : {},
+    ...opts.redirects ? { redirects: opts.redirects } : {},
+    ...opts.guards ? { guards: opts.guards } : {}
+  };
+  return createHttpClient(cfg);
+}
+
+export { ILLEGAL_INVOCATION_HINT, NetworkError, ParseError, RedirectError, TimeoutError, alertNotifier, apiKeyAuth, basicAuth, bearerAuth, bearerRefreshGuard, consoleNotifier, cookieAuth, cookieSafeRefreshGuard, correlationIdGuard, createApiKeyClient, createApiParserGraphQL, createApiParserLaravel, createApiParserNest, createApiParserRestClassic, createApiParserStructured, createBasicClient, createBearerClient, createClient, createCookieClient, createHttpClient, createPresetBuilder, createShapeParser, createSimpleClient, csrfGuard, fromZod, idempotencyGuard, instrumentGuard, memoryCache, noAuth, retryGuard, schema, tailwindAlertRenderer, unauthorizedGuard };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map