@blimu/client 0.7.0 → 1.1.1

package/dist/index.mjs

@@ -1,20 +1,1280 @@
-import {
-  listAll,
-  paginate
-} from "./chunk-LZ27JJ4R.mjs";
-import {
-  AuthService
-} from "./chunk-YGEJFE6U.mjs";
-import {
-  EntitlementsService
-} from "./chunk-ENXZU3RF.mjs";
-import {
-  CoreClient,
-  FetchError
-} from "./chunk-ATZGLDGF.mjs";
-import {
-  schema_exports
-} from "./chunk-7SBLH5KM.mjs";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/@blimu/fetch/dist/index.js
+var __defProp2 = Object.defineProperty;
+var __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
+var FetchError = class _FetchError extends Error {
+  static {
+    __name(this, "FetchError");
+  }
+  status;
+  data;
+  headers;
+  constructor(message, status, data, headers) {
+    super(message), this.status = status, this.data = data, this.headers = headers;
+    this.name = "FetchError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _FetchError);
+    }
+  }
+};
+var ClientError = class extends FetchError {
+  static {
+    __name(this, "ClientError");
+  }
+  constructor(message, status, data, headers) {
+    super(message, status, data, headers);
+    this.name = "ClientError";
+  }
+};
+var ServerError = class extends FetchError {
+  static {
+    __name(this, "ServerError");
+  }
+  constructor(message, status, data, headers) {
+    super(message, status, data, headers);
+    this.name = "ServerError";
+  }
+};
+var BadRequestError = class extends ClientError {
+  static {
+    __name(this, "BadRequestError");
+  }
+  constructor(message = "Bad Request", data, headers) {
+    super(message, 400, data, headers);
+    this.name = "BadRequestError";
+  }
+};
+var UnauthorizedError = class extends ClientError {
+  static {
+    __name(this, "UnauthorizedError");
+  }
+  constructor(message = "Unauthorized", data, headers) {
+    super(message, 401, data, headers);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends ClientError {
+  static {
+    __name(this, "ForbiddenError");
+  }
+  constructor(message = "Forbidden", data, headers) {
+    super(message, 403, data, headers);
+    this.name = "ForbiddenError";
+  }
+};
+var NotFoundError = class extends ClientError {
+  static {
+    __name(this, "NotFoundError");
+  }
+  constructor(message = "Not Found", data, headers) {
+    super(message, 404, data, headers);
+    this.name = "NotFoundError";
+  }
+};
+var MethodNotAllowedError = class extends ClientError {
+  static {
+    __name(this, "MethodNotAllowedError");
+  }
+  constructor(message = "Method Not Allowed", data, headers) {
+    super(message, 405, data, headers);
+    this.name = "MethodNotAllowedError";
+  }
+};
+var ConflictError = class extends ClientError {
+  static {
+    __name(this, "ConflictError");
+  }
+  constructor(message = "Conflict", data, headers) {
+    super(message, 409, data, headers);
+    this.name = "ConflictError";
+  }
+};
+var UnprocessableEntityError = class extends ClientError {
+  static {
+    __name(this, "UnprocessableEntityError");
+  }
+  constructor(message = "Unprocessable Entity", data, headers) {
+    super(message, 422, data, headers);
+    this.name = "UnprocessableEntityError";
+  }
+};
+var TooManyRequestsError = class extends ClientError {
+  static {
+    __name(this, "TooManyRequestsError");
+  }
+  constructor(message = "Too Many Requests", data, headers) {
+    super(message, 429, data, headers);
+    this.name = "TooManyRequestsError";
+  }
+};
+var InternalServerError = class extends ServerError {
+  static {
+    __name(this, "InternalServerError");
+  }
+  constructor(message = "Internal Server Error", data, headers) {
+    super(message, 500, data, headers);
+    this.name = "InternalServerError";
+  }
+};
+var BadGatewayError = class extends ServerError {
+  static {
+    __name(this, "BadGatewayError");
+  }
+  constructor(message = "Bad Gateway", data, headers) {
+    super(message, 502, data, headers);
+    this.name = "BadGatewayError";
+  }
+};
+var ServiceUnavailableError = class extends ServerError {
+  static {
+    __name(this, "ServiceUnavailableError");
+  }
+  constructor(message = "Service Unavailable", data, headers) {
+    super(message, 503, data, headers);
+    this.name = "ServiceUnavailableError";
+  }
+};
+var GatewayTimeoutError = class extends ServerError {
+  static {
+    __name(this, "GatewayTimeoutError");
+  }
+  constructor(message = "Gateway Timeout", data, headers) {
+    super(message, 504, data, headers);
+    this.name = "GatewayTimeoutError";
+  }
+};
+function createFetchError(status, message, data, headers) {
+  const defaultMessage = message || `HTTP ${status}`;
+  switch (status) {
+    case 400:
+      return new BadRequestError(defaultMessage, data, headers);
+    case 401:
+      return new UnauthorizedError(defaultMessage, data, headers);
+    case 403:
+      return new ForbiddenError(defaultMessage, data, headers);
+    case 404:
+      return new NotFoundError(defaultMessage, data, headers);
+    case 405:
+      return new MethodNotAllowedError(defaultMessage, data, headers);
+    case 409:
+      return new ConflictError(defaultMessage, data, headers);
+    case 422:
+      return new UnprocessableEntityError(defaultMessage, data, headers);
+    case 429:
+      return new TooManyRequestsError(defaultMessage, data, headers);
+    // Generic 4xx
+    case 402:
+    case 406:
+    case 407:
+    case 408:
+    case 410:
+    case 411:
+    case 412:
+    case 413:
+    case 414:
+    case 415:
+    case 416:
+    case 417:
+    case 418:
+    case 421:
+    case 423:
+    case 424:
+    case 425:
+    case 426:
+    case 428:
+    case 431:
+    case 451:
+      return new ClientError(defaultMessage, status, data, headers);
+    // 5xx Server Errors
+    case 500:
+      return new InternalServerError(defaultMessage, data, headers);
+    case 502:
+      return new BadGatewayError(defaultMessage, data, headers);
+    case 503:
+      return new ServiceUnavailableError(defaultMessage, data, headers);
+    case 504:
+      return new GatewayTimeoutError(defaultMessage, data, headers);
+    // Generic 5xx
+    case 501:
+    case 505:
+    case 506:
+    case 507:
+    case 508:
+    case 510:
+    case 511:
+      return new ServerError(defaultMessage, status, data, headers);
+    default:
+      return new FetchError(defaultMessage, status, data, headers);
+  }
+}
+__name(createFetchError, "createFetchError");
+var HookRegistry = class {
+  static {
+    __name(this, "HookRegistry");
+  }
+  hooks = /* @__PURE__ */ new Map();
+  constructor(config) {
+    if (config) {
+      this.registerFromConfig(config);
+    }
+  }
+  /**
+  * Register hooks from a configuration object
+  */
+  registerFromConfig(config) {
+    for (const [stage, hooks] of Object.entries(config)) {
+      if (hooks && Array.isArray(hooks)) {
+        for (const hook of hooks) {
+          this.register(stage, hook);
+        }
+      }
+    }
+  }
+  /**
+  * Register a hook for a specific stage
+  */
+  register(stage, hook) {
+    if (!this.hooks.has(stage)) {
+      this.hooks.set(stage, []);
+    }
+    this.hooks.get(stage).push(hook);
+  }
+  /**
+  * Remove a specific hook from a stage
+  */
+  remove(stage, hook) {
+    const hooks = this.hooks.get(stage);
+    if (!hooks) {
+      return false;
+    }
+    const index = hooks.indexOf(hook);
+    if (index === -1) {
+      return false;
+    }
+    hooks.splice(index, 1);
+    return true;
+  }
+  /**
+  * Clear all hooks for a specific stage, or all hooks if no stage is provided
+  */
+  clear(stage) {
+    if (stage) {
+      this.hooks.delete(stage);
+    } else {
+      this.hooks.clear();
+    }
+  }
+  /**
+  * Get all hooks for a specific stage
+  */
+  get(stage) {
+    return this.hooks.get(stage) || [];
+  }
+  /**
+  * Execute all hooks for a specific stage in registration order
+  */
+  async execute(stage, context) {
+    const hooks = this.get(stage);
+    for (const hook of hooks) {
+      await hook(context);
+    }
+  }
+  /**
+  * Check if any hooks are registered for a stage
+  */
+  has(stage) {
+    return this.hooks.has(stage) && this.hooks.get(stage).length > 0;
+  }
+};
+var exponentialStrategy = /* @__PURE__ */ __name((attempt, baseBackoffMs) => {
+  return baseBackoffMs * Math.pow(2, attempt);
+}, "exponentialStrategy");
+var linearStrategy = /* @__PURE__ */ __name((attempt, baseBackoffMs) => {
+  return baseBackoffMs * (attempt + 1);
+}, "linearStrategy");
+function getRetryStrategy(strategy) {
+  if (typeof strategy === "function") {
+    return strategy;
+  }
+  switch (strategy) {
+    case "exponential":
+      return exponentialStrategy;
+    case "linear":
+      return linearStrategy;
+    default:
+      return exponentialStrategy;
+  }
+}
+__name(getRetryStrategy, "getRetryStrategy");
+function calculateRetryDelay(attempt, strategy, baseBackoffMs) {
+  const strategyFn = getRetryStrategy(strategy);
+  return strategyFn(attempt, baseBackoffMs);
+}
+__name(calculateRetryDelay, "calculateRetryDelay");
+async function* parseSSEStream(response) {
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, {
+        stream: true
+      });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      let currentEvent = {};
+      for (const line of lines) {
+        if (line.trim() === "") {
+          if (currentEvent.data !== void 0) {
+            yield currentEvent.data;
+          }
+          currentEvent = {};
+          continue;
+        }
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1) continue;
+        const field = line.substring(0, colonIndex).trim();
+        const value2 = line.substring(colonIndex + 1).trim();
+        if (field === "data") {
+          currentEvent.data = currentEvent.data ? currentEvent.data + "\n" + value2 : value2;
+        } else if (field === "event") {
+          currentEvent.type = value2;
+        } else if (field === "id") {
+          currentEvent.id = value2;
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const lines = buffer.split("\n");
+      let currentEvent = {};
+      for (const line of lines) {
+        if (line.trim() === "" && currentEvent.data !== void 0) {
+          yield currentEvent.data;
+          currentEvent = {};
+          continue;
+        }
+        const colonIndex = line.indexOf(":");
+        if (colonIndex !== -1) {
+          const field = line.substring(0, colonIndex).trim();
+          const value = line.substring(colonIndex + 1).trim();
+          if (field === "data") {
+            currentEvent.data = currentEvent.data ? currentEvent.data + "\n" + value : value;
+          }
+        }
+      }
+      if (currentEvent.data !== void 0) {
+        yield currentEvent.data;
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+__name(parseSSEStream, "parseSSEStream");
+async function* parseNDJSONStream(response) {
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, {
+        stream: true
+      });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed === "") continue;
+        try {
+          const parsed = JSON.parse(trimmed);
+          yield parsed;
+        } catch (error) {
+          console.warn("Skipping invalid JSON line:", trimmed);
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        const parsed = JSON.parse(buffer.trim());
+        yield parsed;
+      } catch (error) {
+        console.warn("Skipping invalid JSON in buffer:", buffer.trim());
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+__name(parseNDJSONStream, "parseNDJSONStream");
+async function* parseChunkedStream(response) {
+  if (!response.body) {
+    return;
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, {
+        stream: true
+      });
+      yield chunk;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+__name(parseChunkedStream, "parseChunkedStream");
+function isBrowser() {
+  return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined";
+}
+__name(isBrowser, "isBrowser");
+function isNode() {
+  return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+}
+__name(isNode, "isNode");
+function encodeBase64(str) {
+  if (isBrowser()) {
+    if (typeof btoa !== "undefined") {
+      return btoa(str);
+    }
+    throw new Error("btoa is not available. This should not happen in a browser environment.");
+  } else {
+    if (typeof Buffer !== "undefined") {
+      return Buffer.from(str, "utf-8").toString("base64");
+    }
+    throw new Error("Buffer is not available. Please ensure you're running in Node.js or provide a polyfill.");
+  }
+}
+__name(encodeBase64, "encodeBase64");
+function isFetchAvailable() {
+  return typeof fetch !== "undefined";
+}
+__name(isFetchAvailable, "isFetchAvailable");
+function isAbortControllerAvailable() {
+  return typeof AbortController !== "undefined";
+}
+__name(isAbortControllerAvailable, "isAbortControllerAvailable");
+function getFetchErrorMessage() {
+  if (isBrowser()) {
+    return "fetch is not available in this browser. Please use a modern browser or provide a polyfill.";
+  } else {
+    return "fetch is not available. Node.js 22+ includes native fetch. For older versions, please provide a custom fetch implementation (e.g., from 'undici' or 'node-fetch').";
+  }
+}
+__name(getFetchErrorMessage, "getFetchErrorMessage");
+function serializeQueryParams(query) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== void 0 && item !== null) {
+          params.append(key, String(item));
+        }
+      }
+    } else {
+      params.set(key, String(value));
+    }
+  }
+  return params;
+}
+__name(serializeQueryParams, "serializeQueryParams");
+function buildUrl(baseUrl, path, query) {
+  let normalizedPath = path || "";
+  if (normalizedPath.length > 1 && normalizedPath.endsWith("/")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  let normalizedBaseUrl = baseUrl || "";
+  if (normalizedBaseUrl) {
+    try {
+      const baseUrlObj = new URL(normalizedBaseUrl);
+      if (baseUrlObj.pathname && baseUrlObj.pathname !== "/" && !normalizedBaseUrl.endsWith("/")) {
+        normalizedBaseUrl = normalizedBaseUrl + "/";
+      }
+    } catch {
+    }
+  }
+  if (normalizedPath.startsWith("/")) {
+    normalizedPath = normalizedPath.slice(1);
+  }
+  const url = new URL(normalizedPath, normalizedBaseUrl);
+  if (query) {
+    const params = serializeQueryParams(query);
+    const keys = Array.from(new Set(params.keys()));
+    for (const key of keys) {
+      url.searchParams.delete(key);
+      for (const value of params.getAll(key)) {
+        url.searchParams.append(key, value);
+      }
+    }
+  }
+  return url;
+}
+__name(buildUrl, "buildUrl");
+function getContentType(body) {
+  if (body === null || body === void 0) {
+    return void 0;
+  }
+  if (body instanceof FormData) {
+    return void 0;
+  }
+  if (body instanceof URLSearchParams) {
+    return "application/x-www-form-urlencoded";
+  }
+  if (typeof body === "string") {
+    try {
+      JSON.parse(body);
+      return "application/json";
+    } catch {
+      return "text/plain";
+    }
+  }
+  if (typeof body === "object") {
+    return "application/json";
+  }
+  return void 0;
+}
+__name(getContentType, "getContentType");
+function serializeBody(body, contentType) {
+  if (body === null || body === void 0) {
+    return null;
+  }
+  if (typeof body === "string" || body instanceof FormData || body instanceof URLSearchParams || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    return body;
+  }
+  if (contentType === "application/x-www-form-urlencoded" && typeof body === "object" && body !== null && !Array.isArray(body)) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(body)) {
+      if (value !== null && value !== void 0) {
+        if (Array.isArray(value)) {
+          for (const item of value) {
+            params.append(key, String(item));
+          }
+        } else {
+          params.append(key, String(value));
+        }
+      }
+    }
+    return params;
+  }
+  if (typeof body === "object") {
+    return JSON.stringify(body);
+  }
+  return String(body);
+}
+__name(serializeBody, "serializeBody");
+async function parseResponse(response) {
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  } else if (contentType.startsWith("text/")) {
+    return await response.text();
+  } else {
+    return await response.arrayBuffer();
+  }
+}
+__name(parseResponse, "parseResponse");
+function isSuccessResponse(response) {
+  return response.ok;
+}
+__name(isSuccessResponse, "isSuccessResponse");
+var FetchClient = class {
+  static {
+    __name(this, "FetchClient");
+  }
+  hookRegistry;
+  cfg;
+  constructor(config = {}) {
+    this.cfg = config;
+    if (!this.cfg.baseURL) {
+      this.cfg.baseURL = "";
+    }
+    this.hookRegistry = new HookRegistry(this.cfg.hooks);
+    if (!isFetchAvailable() && !this.cfg.fetch) {
+      throw new Error(getFetchErrorMessage());
+    }
+  }
+  /**
+  * Add an authentication strategy
+  */
+  addAuthStrategy(strategy) {
+    if (!this.cfg.auth) {
+      this.cfg.auth = {
+        strategies: []
+      };
+    }
+    this.cfg.auth.strategies.push(strategy);
+  }
+  /**
+  * Remove all authentication strategies
+  */
+  clearAuthStrategies() {
+    if (this.cfg.auth) {
+      this.cfg.auth.strategies = [];
+    }
+  }
+  /**
+  * Register a hook for a specific lifecycle stage
+  */
+  useHook(stage, hook) {
+    this.hookRegistry.register(stage, hook);
+  }
+  /**
+  * Remove a hook
+  */
+  removeHook(stage, hook) {
+    return this.hookRegistry.remove(stage, hook);
+  }
+  /**
+  * Clear hooks for a stage or all hooks
+  */
+  clearHooks(stage) {
+    this.hookRegistry.clear(stage);
+  }
+  /**
+  * Make an HTTP request
+  */
+  async request(init) {
+    let url = buildUrl(this.cfg.baseURL || "", init.path, init.query);
+    const headers = new Headers(this.cfg.headers || {});
+    if (init.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach((value, key) => {
+          headers.set(key, value);
+        });
+      } else {
+        Object.entries(init.headers).forEach(([key, value]) => {
+          headers.set(key, String(value));
+        });
+      }
+    }
+    await this.applyAuthentication(headers, url);
+    let bodyContentType;
+    if (init.body !== void 0) {
+      bodyContentType = headers.get("Content-Type") || void 0;
+      if (!bodyContentType) {
+        bodyContentType = getContentType(init.body);
+        if (bodyContentType) {
+          headers.set("Content-Type", bodyContentType);
+        }
+      }
+    }
+    const retries = this.cfg.retry?.retries ?? 0;
+    const baseBackoff = this.cfg.retry?.backoffMs ?? 300;
+    const retryOn = this.cfg.retry?.retryOn ?? [
+      429,
+      500,
+      502,
+      503,
+      504
+    ];
+    const retryStrategy = this.cfg.retry?.strategy ?? "exponential";
+    let lastError;
+    for (let attempt = 0; attempt <= retries + 1; attempt++) {
+      try {
+        let attemptUrl = buildUrl(this.cfg.baseURL || "", init.path, init.query);
+        const attemptHeaders = new Headers(headers);
+        await this.applyAuthentication(attemptHeaders, attemptUrl);
+        return await this.doRequest(attemptUrl, init, attemptHeaders, attempt, bodyContentType);
+      } catch (err) {
+        lastError = err;
+        const shouldRetry = this.shouldRetry(err, attempt, retries, retryOn);
+        if (shouldRetry) {
+          if (this.hookRegistry.has("beforeRetry")) {
+            await this.hookRegistry.execute("beforeRetry", {
+              url: url.toString(),
+              init: {
+                ...init,
+                headers
+              },
+              attempt,
+              error: err,
+              retryCount: attempt
+            });
+          }
+          const delay = calculateRetryDelay(attempt, retryStrategy, baseBackoff);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          if (this.hookRegistry.has("afterRetry")) {
+            await this.hookRegistry.execute("afterRetry", {
+              url: url.toString(),
+              init: {
+                ...init,
+                headers
+              },
+              attempt,
+              error: err,
+              retryCount: attempt,
+              success: false
+            });
+          }
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError;
+  }
+  /**
+  * Make a streaming HTTP request
+  */
+  async *requestStream(init) {
+    let url = buildUrl(this.cfg.baseURL || "", init.path, init.query);
+    const headers = new Headers(this.cfg.headers || {});
+    if (init.headers) {
+      if (init.headers instanceof Headers) {
+        init.headers.forEach((value, key) => {
+          headers.set(key, value);
+        });
+      } else {
+        Object.entries(init.headers).forEach(([key, value]) => {
+          headers.set(key, String(value));
+        });
+      }
+    }
+    await this.applyAuthentication(headers, url);
+    let bodyContentType = headers.get("Content-Type") || void 0;
+    if (init.contentType && !bodyContentType) {
+      bodyContentType = init.contentType;
+      headers.set("Content-Type", bodyContentType);
+    }
+    const fetchInit = {
+      ...init,
+      headers,
+      body: serializeBody(init.body, bodyContentType)
+    };
+    if (this.cfg.credentials !== void 0) {
+      fetchInit.credentials = this.cfg.credentials;
+    }
+    if (this.hookRegistry.has("beforeRequest")) {
+      await this.hookRegistry.execute("beforeRequest", {
+        url: url.toString(),
+        init: fetchInit,
+        attempt: 0
+      });
+    }
+    let controller;
+    let timeoutId;
+    const existingSignal = fetchInit.signal;
+    if (this.cfg.timeoutMs && typeof AbortController !== "undefined") {
+      controller = new AbortController();
+      if (existingSignal) {
+        if (existingSignal.aborted) {
+          controller.abort();
+        } else {
+          existingSignal.addEventListener("abort", () => {
+            controller?.abort();
+          });
+        }
+      }
+      fetchInit.signal = controller.signal;
+      timeoutId = setTimeout(() => {
+        controller?.abort();
+        if (this.hookRegistry.has("onTimeout")) {
+          this.hookRegistry.execute("onTimeout", {
+            url: url.toString(),
+            init: fetchInit,
+            attempt: 0,
+            timeoutMs: this.cfg.timeoutMs
+          });
+        }
+      }, this.cfg.timeoutMs);
+    }
+    try {
+      const fetchFn = this.cfg.fetch || fetch;
+      const res = await fetchFn(url.toString(), fetchInit);
+      if (this.hookRegistry.has("afterRequest")) {
+        await this.hookRegistry.execute("afterRequest", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt: 0,
+          response: res
+        });
+      }
+      if (!res.ok) {
+        const parsed = await parseResponse(res);
+        const error = createFetchError(res.status, parsed?.message || `HTTP ${res.status}`, parsed, res.headers);
+        if (this.hookRegistry.has("onError")) {
+          await this.hookRegistry.execute("onError", {
+            url: url.toString(),
+            init: fetchInit,
+            attempt: 0,
+            error
+          });
+        }
+        throw error;
+      }
+      if (this.hookRegistry.has("onStreamStart")) {
+        await this.hookRegistry.execute("onStreamStart", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt: 0,
+          response: res
+        });
+      }
+      const streamingFormat = init.streamingFormat || "chunked";
+      if (streamingFormat === "sse") {
+        for await (const chunk of parseSSEStream(res)) {
+          let transformedChunk = chunk;
+          if (this.hookRegistry.has("onStreamChunk")) {
+            await this.hookRegistry.execute("onStreamChunk", {
+              url: url.toString(),
+              init: fetchInit,
+              attempt: 0,
+              chunk
+            });
+          }
+          yield transformedChunk;
+        }
+      } else if (streamingFormat === "ndjson") {
+        for await (const chunk of parseNDJSONStream(res)) {
+          let transformedChunk = chunk;
+          if (this.hookRegistry.has("onStreamChunk")) {
+            await this.hookRegistry.execute("onStreamChunk", {
+              url: url.toString(),
+              init: fetchInit,
+              attempt: 0,
+              chunk
+            });
+          }
+          yield transformedChunk;
+        }
+      } else {
+        for await (const chunk of parseChunkedStream(res)) {
+          let transformedChunk = chunk;
+          if (this.hookRegistry.has("onStreamChunk")) {
+            await this.hookRegistry.execute("onStreamChunk", {
+              url: url.toString(),
+              init: fetchInit,
+              attempt: 0,
+              chunk
+            });
+          }
+          yield transformedChunk;
+        }
+      }
+      if (this.hookRegistry.has("onStreamEnd")) {
+        await this.hookRegistry.execute("onStreamEnd", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt: 0,
+          response: res
+        });
+      }
+    } catch (err) {
+      if (this.hookRegistry.has("onError")) {
+        await this.hookRegistry.execute("onError", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt: 0,
+          error: err
+        });
+      }
+      throw err;
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  /**
+  * Internal method to execute a single request attempt
+  */
+  async doRequest(url, init, baseHeaders, attempt, contentType) {
+    const requestHeaders = baseHeaders;
+    const fetchInit = {
+      ...init,
+      headers: requestHeaders,
+      body: serializeBody(init.body, contentType)
+    };
+    if (this.cfg.credentials !== void 0) {
+      fetchInit.credentials = this.cfg.credentials;
+    }
+    if (this.hookRegistry.has("beforeRequest")) {
+      await this.hookRegistry.execute("beforeRequest", {
+        url: url.toString(),
+        init: fetchInit,
+        attempt
+      });
+    }
+    let controller;
+    let timeoutId;
+    const existingSignal = fetchInit.signal;
+    if (this.cfg.timeoutMs && typeof AbortController !== "undefined") {
+      controller = new AbortController();
+      if (existingSignal) {
+        if (existingSignal.aborted) {
+          controller.abort();
+        } else {
+          existingSignal.addEventListener("abort", () => {
+            controller?.abort();
+          });
+        }
+      }
+      fetchInit.signal = controller.signal;
+      timeoutId = setTimeout(() => {
+        controller?.abort();
+        if (this.hookRegistry.has("onTimeout")) {
+          this.hookRegistry.execute("onTimeout", {
+            url: url.toString(),
+            init: fetchInit,
+            attempt,
+            timeoutMs: this.cfg.timeoutMs
+          });
+        }
+      }, this.cfg.timeoutMs);
+    }
+    try {
+      const fetchFn = this.cfg.fetch || fetch;
+      const res = await fetchFn(url.toString(), fetchInit);
+      if (this.hookRegistry.has("afterRequest")) {
+        await this.hookRegistry.execute("afterRequest", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt,
+          response: res
+        });
+      }
+      const parsed = await parseResponse(res);
+      if (this.hookRegistry.has("afterResponse")) {
+        await this.hookRegistry.execute("afterResponse", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt,
+          response: res,
+          data: parsed
+        });
+      }
+      if (!isSuccessResponse(res)) {
+        const error = createFetchError(res.status, parsed?.message || `HTTP ${res.status}`, parsed, res.headers);
+        if (this.hookRegistry.has("onError")) {
+          await this.hookRegistry.execute("onError", {
+            url: url.toString(),
+            init: fetchInit,
+            attempt,
+            error
+          });
+        }
+        throw error;
+      }
+      return parsed;
+    } catch (err) {
+      if (this.hookRegistry.has("onError")) {
+        await this.hookRegistry.execute("onError", {
+          url: url.toString(),
+          init: fetchInit,
+          attempt,
+          error: err
+        });
+      }
+      if (err instanceof DOMException) {
+        throw err;
+      }
+      if (err instanceof FetchError) {
+        throw err;
+      }
+      const status = err?.status;
+      const statusCode = typeof status === "number" ? status : 0;
+      if (typeof err === "string") {
+        throw createFetchError(statusCode, err);
+      }
+      throw createFetchError(statusCode, err?.message || "Network error");
+    } finally {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  /**
+  * Apply authentication strategies
+  */
+  async applyAuthentication(headers, url) {
+    if (!this.cfg.auth?.strategies) {
+      return;
+    }
+    for (const strategy of this.cfg.auth.strategies) {
+      await this.applyAuthStrategy(strategy, headers, url);
+    }
+  }
+  /**
+  * Apply a single authentication strategy
+  */
+  async applyAuthStrategy(strategy, headers, url) {
+    switch (strategy.type) {
+      case "bearer": {
+        const token = typeof strategy.token === "function" ? await strategy.token() : strategy.token;
+        if (token != null) {
+          const headerName = strategy.headerName || "Authorization";
+          headers.set(headerName, `Bearer ${String(token)}`);
+        }
+        break;
+      }
+      case "basic": {
+        const encoded = encodeBase64(`${strategy.username}:${strategy.password}`);
+        headers.set("Authorization", `Basic ${encoded}`);
+        break;
+      }
+      case "apiKey": {
+        const key = typeof strategy.key === "function" ? await strategy.key() : strategy.key;
+        if (key != null) {
+          switch (strategy.location) {
+            case "header":
+              headers.set(strategy.name, String(key));
+              break;
+            case "query":
+              url.searchParams.set(strategy.name, String(key));
+              break;
+            case "cookie":
+              headers.set("Cookie", `${strategy.name}=${String(key)}`);
+              break;
+          }
+        }
+        break;
+      }
+      case "custom":
+        await strategy.apply(headers, url);
+        break;
+    }
+  }
+  /**
+  * Determine if an error should be retried
+  */
+  shouldRetry(error, attempt, maxRetries, retryOn) {
+    if (attempt >= maxRetries) {
+      return false;
+    }
+    if (this.cfg.retry?.retryOnError) {
+      return this.cfg.retry.retryOnError(error);
+    }
+    if (error instanceof FetchError) {
+      return retryOn.includes(error.status);
+    }
+    return true;
+  }
+};
+
+// src/client.ts
+var CoreClient = class extends FetchClient {
+  constructor(cfg = {}) {
+    const authStrategies = [];
+    const { auth: _existingAuth, bearer, ...restCfg } = cfg;
+    if (cfg.bearer) {
+      const bearerValue = cfg.bearer;
+      if (typeof bearerValue === "string") {
+        authStrategies.push({
+          type: "bearer",
+          token: () => bearerValue
+        });
+      } else if (typeof bearerValue === "function") {
+        authStrategies.push({
+          type: "bearer",
+          token: bearerValue
+        });
+      }
+    }
+    const finalAuthStrategies = [
+      ..._existingAuth?.strategies || [],
+      ...authStrategies
+    ];
+    const fetchConfig = {
+      ...restCfg,
+      baseURL: cfg.baseURL ?? "https://api.blimu.dev",
+      // Explicitly set auth after restCfg to ensure it's not overwritten
+      // (restCfg might have an auth property that we want to replace)
+      ...finalAuthStrategies.length > 0 ? {
+        auth: {
+          strategies: finalAuthStrategies
+        }
+      } : {}
+      // Hooks are passed through directly from FetchClientConfig (no mapping needed)
+    };
+    super(fetchConfig);
+  }
+  async request(init) {
+    return await super.request(init);
+  }
+  async *requestStream(init) {
+    yield* super.requestStream(init);
+  }
+};
+
+// src/services/auth.ts
+var AuthService = class {
+  constructor(core) {
+    this.core = core;
+  }
+  /**
+   * POST /v1/auth/logout*
+   * @summary Logout and invalidate session*/
+  logout(init) {
+    return this.core.request({
+      method: "POST",
+      path: `/v1/auth/logout`,
+      ...init || {}
+    });
+  }
+  /**
+   * @summary Get query keys for logout
+   * @returns ['v1/auth/logout']
+   */
+  logout__queryKeys() {
+    return ["v1/auth/logout"];
+  }
+  /**
+   * POST /v1/auth/refresh*
+   * @summary Refresh session token*/
+  refresh(query, init) {
+    return this.core.request({
+      method: "POST",
+      path: `/v1/auth/refresh`,
+      query,
+      ...init || {}
+    });
+  }
+  /**
+   * @summary Get query keys for refresh
+   * @returns ['v1/auth/refresh', query]
+   */
+  refresh__queryKeys(query) {
+    return ["v1/auth/refresh", query];
+  }
+  /**
+   * GET /v1/auth/session*
+   * @summary Get current session*/
+  getSession(init) {
+    return this.core.request({
+      method: "GET",
+      path: `/v1/auth/session`,
+      ...init || {}
+    });
+  }
+  /**
+   * @summary Get query keys for getSession
+   * @returns ['v1/auth/session']
+   */
+  getSession__queryKeys() {
+    return ["v1/auth/session"];
+  }
+};
+
+// src/services/entitlements.ts
+var EntitlementsService = class {
+  constructor(core) {
+    this.core = core;
+  }
+  /**
+   * GET /v1/client/entitlements/list-for-tenant/{tenantResourceId}*
+   * @summary List entitlements for a tenant and all its sub-resources*
+   * @description Returns entitlements for a tenant resource and all its descendant resources for the authenticated user. This endpoint scopes queries to a single tenant, preventing cross-tenant data access. Only evaluates roles and plans (excludes limits). Results are cached per resource for performance. The tenant resource type is automatically determined from the environment definition (resource marked as `is_tenant: true`).*/
+  listForTenant(tenantResourceId, init) {
+    return this.core.request({
+      method: "GET",
+      path: `/v1/client/entitlements/list-for-tenant/${encodeURIComponent(tenantResourceId)}`,
+      ...init || {}
+    });
+  }
+  /**
+   * @summary Get query keys for listForTenant
+   * @returns ['v1/client/entitlements/list-for-tenant', tenantResourceId]
+   */
+  listForTenant__queryKeys(tenantResourceId) {
+    return [
+      "v1/client/entitlements/list-for-tenant",
+      tenantResourceId
+    ];
+  }
+};
+
+// src/utils.ts
+async function* paginate(fetchPage, initialQuery = {}, pageSize = 100) {
+  let offset = Number(initialQuery.offset ?? 0);
+  const limit = Number(initialQuery.limit ?? pageSize);
+  const baseQuery = { ...initialQuery };
+  while (true) {
+    const page = await fetchPage({ ...baseQuery, limit, offset });
+    const items = page.data ?? [];
+    for (const item of items) {
+      yield item;
+    }
+    if (!page.hasMore || items.length < limit) break;
+    offset += limit;
+  }
+}
+async function listAll(fetchPage, query = {}, pageSize = 100) {
+  const out = [];
+  for await (const item of paginate(fetchPage, query, pageSize))
+    out.push(item);
+  return out;
+}
+
+// src/schema.ts
+var schema_exports = {};
+
+// src/schema.zod.ts
+var schema_zod_exports = {};
+__export(schema_zod_exports, {
+  AuthRefreshQuerySchema: () => AuthRefreshQuerySchema,
+  EntitlementTypeSchema: () => EntitlementTypeSchema,
+  EntitlementsListResultSchema: () => EntitlementsListResultSchema,
+  RefreshResponseSchema: () => RefreshResponseSchema,
+  ResourceTypeSchema: () => ResourceTypeSchema,
+  SessionResponseSchema: () => SessionResponseSchema
+});
+import { z } from "zod";
+var EntitlementTypeSchema = z.string();
+var ResourceTypeSchema = z.string();
+var EntitlementsListResultSchema = z.object({
+  results: z.array(
+    z.object({
+      entitlements: z.array(
+        z.object({
+          allowed: z.boolean(),
+          allowedByPlan: z.boolean(),
+          allowedByRole: z.boolean(),
+          allowedPlans: z.array(z.string()).optional(),
+          allowedRoles: z.array(z.string()),
+          currentPlan: z.string().optional(),
+          currentRole: z.string().optional(),
+          entitlement: EntitlementTypeSchema
+        })
+      ),
+      resourceId: z.string(),
+      resourceType: ResourceTypeSchema
+    })
+  )
+});
+var RefreshResponseSchema = z.object({ sessionToken: z.string() });
+var SessionResponseSchema = z.object({
+  isAuthenticated: z.boolean(),
+  user: z.object({
+    email: z.string(),
+    emailVerified: z.boolean(),
+    firstName: z.string().nullable(),
+    id: z.string(),
+    lastName: z.string().nullable()
+  }).nullable()
+});
+var AuthRefreshQuerySchema = z.object({
+  __lh_jwt: z.string().optional()
+});
 
 // src/index.ts
 var Blimu = class {
@@ -29,11 +1289,50 @@ var Blimu = class {
 var BlimuError = FetchError;
 export {
   AuthService,
+  BadGatewayError,
+  BadRequestError,
   Blimu,
   BlimuError,
+  ClientError,
+  ConflictError,
+  CoreClient,
   EntitlementsService,
+  FetchClient,
   FetchError,
+  ForbiddenError,
+  GatewayTimeoutError,
+  HookRegistry,
+  InternalServerError,
+  MethodNotAllowedError,
+  NotFoundError,
   schema_exports as Schema,
+  ServerError,
+  ServiceUnavailableError,
+  TooManyRequestsError,
+  UnauthorizedError,
+  UnprocessableEntityError,
+  schema_zod_exports as ZodSchema,
+  buildUrl,
+  calculateRetryDelay,
+  createFetchError,
+  encodeBase64,
+  exponentialStrategy,
+  getContentType,
+  getFetchErrorMessage,
+  getRetryStrategy,
+  isAbortControllerAvailable,
+  isBrowser,
+  isFetchAvailable,
+  isNode,
+  isSuccessResponse,
+  linearStrategy,
   listAll,
-  paginate
+  paginate,
+  parseChunkedStream,
+  parseNDJSONStream,
+  parseResponse,
+  parseSSEStream,
+  serializeBody,
+  serializeQueryParams
 };
+//# sourceMappingURL=index.mjs.map