@behio/storefront-sdk 0.38.0 → 0.41.0

package/dist/react.js

@@ -1,24 +1,1809 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-
-var _chunkCZRSJULDjs = require('./chunk-CZRSJULD.js');
-
-
-var _chunkFOUBL2EQjs = require('./chunk-FOUBL2EQ.js');
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  BehioAnalyticsTracker: () => BehioAnalyticsTracker,
+  BehioProvider: () => BehioProvider,
+  CurrencySwitcher: () => CurrencySwitcher,
+  StorefrontScripts: () => StorefrontScripts,
+  cookieStorage: () => cookieStorage,
+  createMemoryStorage: () => createMemoryStorage,
+  detectStorage: () => detectStorage,
+  formatPrice: () => formatPrice,
+  generateVisitorId: () => generateVisitorId,
+  getStoredVisitorId: () => getStoredVisitorId,
+  grantAnalyticsConsent: () => grantAnalyticsConsent,
+  localStorageAdapter: () => localStorageAdapter,
+  memoryStorage: () => memoryStorage,
+  revokeAnalyticsConsent: () => revokeAnalyticsConsent,
+  trackEcommerceEvent: () => trackEcommerceEvent,
+  useAddressAutocomplete: () => useAddressAutocomplete,
+  useAddresses: () => useAddresses,
+  useAnalyticsEvents: () => useAnalyticsEvents,
+  useAuth: () => useAuth,
+  useBehio: () => useBehio,
+  useBehioClient: () => useBehioClient,
+  useBundle: () => useBundle,
+  useBundles: () => useBundles,
+  useCart: () => useCart,
+  useCartCount: () => useCartCount,
+  useCategories: () => useCategories,
+  useCategory: () => useCategory,
+  useCertificateVerification: () => useCertificateVerification,
+  useCheckout: () => useCheckout,
+  useCookieConsent: () => useCookieConsent,
+  useCourse: () => useCourse,
+  useCourseCertificates: () => useCourseCertificates,
+  useCourses: () => useCourses,
+  useCrossSell: () => useCrossSell,
+  useCurrency: () => useCurrency,
+  useCustomer: () => useCustomer,
+  useFacets: () => useFacets,
+  useFeatured: () => useFeatured,
+  useFilters: () => useFilters,
+  useGiftCardBalance: () => useGiftCardBalance,
+  useIsInWishlist: () => useIsInWishlist,
+  useLabels: () => useLabels,
+  useLessonComments: () => useLessonComments,
+  useLessonNote: () => useLessonNote,
+  useLessonQuiz: () => useLessonQuiz,
+  useLessonTutor: () => useLessonTutor,
+  useLookupReturnableOrder: () => useLookupReturnableOrder,
+  useLoyalty: () => useLoyalty,
+  useMenu: () => useMenu,
+  useNewsletterSubscribe: () => useNewsletterSubscribe,
+  useNewsletterUnsubscribe: () => useNewsletterUnsubscribe,
+  useNotifyWhenAvailable: () => useNotifyWhenAvailable,
+  useOrder: () => useOrder,
+  useOrderAccess: () => useOrderAccess,
+  useOrders: () => useOrders,
+  usePage: () => usePage,
+  usePages: () => usePages,
+  usePaymentMethods: () => usePaymentMethods,
+  usePersonalOffers: () => usePersonalOffers,
+  usePickupPoints: () => usePickupPoints,
+  useProduct: () => useProduct,
+  useProductGroup: () => useProductGroup,
+  useProductPromotions: () => useProductPromotions,
+  useProductReviews: () => useProductReviews,
+  useProducts: () => useProducts,
+  useQuoteStatus: () => useQuoteStatus,
+  useReturnStatus: () => useReturnStatus,
+  useSearch: () => useSearch,
+  useShippingMethods: () => useShippingMethods,
+  useShippingQuote: () => useShippingQuote,
+  useShopInfo: () => useShopInfo,
+  useShopScripts: () => useShopScripts,
+  useShopSeo: () => useShopSeo,
+  useSubmitQuote: () => useSubmitQuote,
+  useSubmitReturn: () => useSubmitReturn,
+  useSubmitReview: () => useSubmitReview,
+  useSubscriptions: () => useSubscriptions,
+  useWishlist: () => useWishlist
+});
+module.exports = __toCommonJS(react_exports);
 
 // src/react/provider.tsx
-var _react = require('react');
-var _reactquery = require('@tanstack/react-query');
+var import_react2 = require("react");
+var import_react_query = require("@tanstack/react-query");
+
+// src/types.ts
+var BehioApiError = class _BehioApiError extends Error {
+  constructor(status, body, message) {
+    super(message || `API Error ${status}`);
+    this.name = "BehioApiError";
+    this.status = status;
+    this.body = body;
+    this.code = _BehioApiError.resolveCode(status, body);
+    this.isRetryable = status >= 500 || status === 429;
+  }
+  static resolveCode(status, body) {
+    if (status === 401) return "UNAUTHORIZED";
+    if (status === 403) return "FORBIDDEN";
+    if (status === 404) return "NOT_FOUND";
+    if (status === 409) return "EMAIL_ALREADY_EXISTS";
+    if (status === 429) return "RATE_LIMITED";
+    if (status >= 500) return "INTERNAL_ERROR";
+    const msg = (body?.message || "").toLowerCase();
+    if (msg.includes("invalid") && msg.includes("password"))
+      return "INVALID_CREDENTIALS";
+    if (msg.includes("invalid") && msg.includes("email"))
+      return "INVALID_CREDENTIALS";
+    if (msg.includes("cart") && msg.includes("empty")) return "CART_EMPTY";
+    if (msg.includes("product") && msg.includes("not found"))
+      return "PRODUCT_NOT_FOUND";
+    if (msg.includes("discount") && msg.includes("expired"))
+      return "DISCOUNT_EXPIRED";
+    if (msg.includes("discount") && msg.includes("invalid"))
+      return "INVALID_DISCOUNT";
+    if (msg.includes("token") && msg.includes("expired"))
+      return "TOKEN_EXPIRED";
+    if (msg.includes("cancel")) return "ORDER_NOT_CANCELLABLE";
+    if (status === 400) return "VALIDATION_ERROR";
+    return "UNKNOWN";
+  }
+  /** Check if this is a specific error type */
+  is(code) {
+    return this.code === code;
+  }
+};
+var BehioNetworkError = class extends Error {
+  constructor(message, isTimeout = false) {
+    super(message);
+    this.isRetryable = true;
+    this.name = "BehioNetworkError";
+    this.code = isTimeout ? "TIMEOUT" : "NETWORK_ERROR";
+  }
+};
+function ok(data) {
+  return { data, error: null };
+}
+function toSdkError(err) {
+  if (err instanceof BehioApiError) {
+    return {
+      code: err.code,
+      message: err.message,
+      status: err.status,
+      body: err.body,
+      isRetryable: err.isRetryable,
+      cause: err
+    };
+  }
+  if (err instanceof BehioNetworkError) {
+    return {
+      code: err.code,
+      message: err.message,
+      status: null,
+      isRetryable: err.isRetryable,
+      cause: err
+    };
+  }
+  return {
+    code: "UNKNOWN",
+    message: err instanceof Error ? err.message : String(err),
+    status: null,
+    isRetryable: false,
+    cause: err
+  };
+}
+
+// src/client.ts
+var BehioStorefront = class {
+  constructor(config) {
+    /** Consent-gated persistent visitor id — set by the analytics tracker. */
+    this.analyticsVisitorId = null;
+    // Token refresh lock
+    this.isRefreshing = false;
+    this.refreshPromise = null;
+    // Event emitter
+    this.listeners = /* @__PURE__ */ new Map();
+    // Interceptors
+    this.requestInterceptors = [];
+    this.responseInterceptors = [];
+    // Rate limit tracking
+    this.rateLimitRemaining = null;
+    this.rateLimitReset = null;
+    this.baseUrl = (config.baseUrl || "https://be.behio.com").replace(
+      /\/$/,
+      ""
+    );
+    this.apiKey = config.apiKey;
+    this.shopDomain = config.shopDomain;
+    this.defaultLocale = config.locale;
+    this.defaultCurrency = config.currency;
+    this.fetchFn = config.fetch || globalThis.fetch.bind(globalThis);
+    this.timeout = config.timeout ?? 3e4;
+    this.retries = config.retries ?? 1;
+    this.retryDelay = config.retryDelay ?? 1e3;
+    this.catalog = new CatalogModule(this);
+    this.auth = new AuthModule(this);
+    this.cart = new CartModule(this);
+    this.checkout = new CheckoutModule(this);
+    this.orders = new OrdersModule(this);
+    this.customer = new CustomerModule(this);
+    this.pages = new PagesModule(this);
+    this.wishlist = new WishlistModule(this);
+    this.reviews = new ReviewsModule(this);
+    this.returns = new ReturnsModule(this);
+    this.consent = new ConsentModule(this);
+    this.quotes = new QuotesModule(this);
+    this.addresses = new AddressModule(this);
+    this.shipping = new ShippingModule(this);
+    this.newsletter = new NewsletterModule(this);
+    this.subscriptions = new SubscriptionsModule(this);
+    this.certificates = new CourseCertificatesModule(this);
+  }
+  // --- Public methods ---
+  /**
+   * Called by the analytics tracker when the visitor grants (id) or revokes
+   * (null) analytics consent. When set, requests carry the X-Behio-Vid header
+   * so the backend can attribute orders to the visitor journey.
+   */
+  setAnalyticsVisitorId(id) {
+    this.analyticsVisitorId = id;
+  }
+  /** The consent-gated visitor id, if analytics consent was granted. */
+  getAnalyticsVisitorId() {
+    return this.analyticsVisitorId;
+  }
+  /**
+   * Fire-and-forget Behio Analytics ingest. Uses a bare keepalive fetch (not
+   * the interceptor pipeline) so flushes on pagehide still land, and swallows
+   * every error — analytics must never break the shop. The client sends no
+   * identity; the visitor hash is computed server-side from a daily salt.
+   */
+  async sendAnalyticsEvents(input) {
+    try {
+      const headers = {
+        "X-Api-Key": this.apiKey,
+        "Content-Type": "application/json"
+      };
+      if (this.shopDomain) headers["X-Shop-Domain"] = this.shopDomain;
+      await fetch(`${this.baseUrl}/storefront/v1/analytics/events`, {
+        method: "POST",
+        keepalive: true,
+        headers,
+        body: JSON.stringify(input)
+      });
+    } catch {
+    }
+  }
+  /**
+   * Personal behavioral offers for this visitor (consent-gated id). Returns
+   * only the visitor's own offers; requires the analytics visitor id.
+   */
+  async getPersonalOffers(visitorId) {
+    return this.request("GET", "/offers", { query: { visitorId } });
+  }
+  /** Email-gate completion: trade an e-mail for the personal discount code. */
+  async claimOfferByEmail(offerId, input) {
+    return this.request("POST", `/offers/${offerId}/claim-email`, {
+      body: input
+    });
+  }
+  /** Get basic shop info */
+  async getShopInfo() {
+    return this.request("GET", "/shop");
+  }
+  /** Get SEO metadata for the shop homepage in the given locale (defaults to shop default). */
+  async getShopSeo(locale) {
+    return this.request("GET", "/shop/seo", {
+      query: locale ? { locale } : void 0
+    });
+  }
+  /**
+   * Get the merchant-defined scripts (analytics, pixels, verification, custom
+   * head/body markup) to inject into the storefront. Returns only enabled
+   * entries. Render typed entries into their snippet and RAW verbatim; gate
+   * any entry with `consentRequired` behind the visitor's analytics consent.
+   */
+  async getShopScripts() {
+    return this.request("GET", "/shop/scripts");
+  }
+  /** Set auth tokens (e.g. from localStorage) */
+  setTokens(tokens) {
+    this.accessToken = tokens.accessToken;
+    this.refreshToken = tokens.refreshToken;
+  }
+  /** Clear auth tokens */
+  clearTokens() {
+    this.accessToken = void 0;
+    this.refreshToken = void 0;
+  }
+  /** Get current access token */
+  getAccessToken() {
+    return this.accessToken;
+  }
+  /** Get current refresh token */
+  getRefreshToken() {
+    return this.refreshToken;
+  }
+  /** Set cart session token (e.g. from cookie) */
+  setCartSession(token) {
+    this.cartSession = token;
+  }
+  /** Get cart session token */
+  getCartSession() {
+    return this.cartSession;
+  }
+  /** Clear cart session */
+  clearCartSession() {
+    this.cartSession = void 0;
+  }
+  // --- Default currency / locale (runtime-switchable) ---
+  /**
+   * Set the default currency sent on every catalog request (unless a per-call
+   * `currency` overrides it). Read live at request time, so changing it takes
+   * effect immediately without rebuilding the client. Pass undefined to clear
+   * (falls back to the shop's default currency server-side).
+   */
+  setCurrency(currency) {
+    this.defaultCurrency = currency || void 0;
+  }
+  /** Get the current default currency, if any. */
+  getCurrency() {
+    return this.defaultCurrency;
+  }
+  /** Set the default locale sent on every catalog request (per-call wins). */
+  setLocale(locale) {
+    this.defaultLocale = locale || void 0;
+  }
+  /** Get the current default locale, if any. */
+  getLocale() {
+    return this.defaultLocale;
+  }
+  // --- Event emitter ---
+  /** Subscribe to SDK events. Returns an unsubscribe function. */
+  on(event, handler) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(handler);
+    return () => {
+      this.listeners.get(event)?.delete(handler);
+    };
+  }
+  /** @internal Emit an event (fire-and-forget, handler errors are swallowed) */
+  emit(event, data) {
+    this.listeners.get(event)?.forEach((fn) => {
+      try {
+        fn(data);
+      } catch {
+      }
+    });
+  }
+  // --- Interceptors ---
+  /** Add a request interceptor. Returns an unsubscribe function. */
+  addRequestInterceptor(fn) {
+    this.requestInterceptors.push(fn);
+    return () => {
+      this.requestInterceptors = this.requestInterceptors.filter(
+        (f) => f !== fn
+      );
+    };
+  }
+  /** Add a response interceptor. Returns an unsubscribe function. */
+  addResponseInterceptor(fn) {
+    this.responseInterceptors.push(fn);
+    return () => {
+      this.responseInterceptors = this.responseInterceptors.filter(
+        (f) => f !== fn
+      );
+    };
+  }
+  // --- Rate limit ---
+  /** Get current rate limit info from latest response headers */
+  getRateLimitInfo() {
+    return { remaining: this.rateLimitRemaining, reset: this.rateLimitReset };
+  }
+  // --- Token refresh ---
+  async handleTokenRefresh() {
+    if (this.isRefreshing) {
+      if (this.refreshPromise) await this.refreshPromise;
+      return;
+    }
+    this.isRefreshing = true;
+    this.refreshPromise = (async () => {
+      try {
+        const res = await this.auth.refresh();
+        if (res.error) {
+          this.clearTokens();
+          this.emit("auth:token-refresh-failed");
+          throw new BehioApiError(401, null, "Token refresh failed");
+        }
+        this.emit("auth:token-refresh");
+      } catch (err) {
+        this.clearTokens();
+        this.emit("auth:token-refresh-failed");
+        if (err instanceof BehioApiError) throw err;
+        throw new BehioApiError(401, null, "Token refresh failed");
+      } finally {
+        this.isRefreshing = false;
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  // --- Public request wrapper (SdkResult) ---
+  /**
+   * Every public module method funnels through here. Internally calls
+   * `rawRequest` (which throws on failure) and maps thrown errors to
+   * `SdkError` so the public surface can return `SdkResult<T>`.
+   *
+   * @internal — don't call from outside the SDK; use the typed module
+   * methods (behio.catalog.*, behio.cart.*, …) instead.
+   */
+  async request(method, path, options) {
+    try {
+      const data = await this.rawRequest(method, path, options);
+      return ok(data);
+    } catch (err) {
+      return { data: null, error: toSdkError(err) };
+    }
+  }
+  /**
+   * Binary GET (PDF downloads). Same auth headers as `request()`, but the
+   * response is returned as a Blob instead of parsed JSON.
+   *
+   * @internal — use the typed module methods (behio.certificates.downloadPdf).
+   */
+  async requestBlob(path) {
+    try {
+      const headers = { "X-Api-Key": this.apiKey };
+      if (this.accessToken)
+        headers.Authorization = `Bearer ${this.accessToken}`;
+      const res = await this.fetchFn(`${this.baseUrl}/storefront/v1${path}`, {
+        headers
+      });
+      if (!res.ok) {
+        let body = null;
+        try {
+          body = await res.json();
+        } catch {
+        }
+        throw new BehioApiError(res.status, body);
+      }
+      return ok(await res.blob());
+    } catch (err) {
+      return { data: null, error: toSdkError(err) };
+    }
+  }
+  /**
+   * Throws on failure (API error / network / timeout). Kept private so
+   * internal auth refresh recursion keeps its existing control flow —
+   * public callers must go through `request()` which returns Result.
+   */
+  async rawRequest(method, path, options) {
+    const params = new URLSearchParams();
+    if (options?.query) {
+      for (const [key, value] of Object.entries(options.query)) {
+        if (value === void 0 || value === null || value === "") continue;
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            if (v !== void 0 && v !== null && v !== "") {
+              params.append(key, String(v));
+            }
+          }
+        } else {
+          params.set(key, String(value));
+        }
+      }
+    }
+    if (this.defaultLocale && !params.has("locale")) {
+      params.set("locale", this.defaultLocale);
+    }
+    if (this.defaultCurrency && !params.has("currency")) {
+      params.set("currency", this.defaultCurrency);
+    }
+    const qs = params.toString();
+    const url = `${this.baseUrl}/storefront/v1${path}${qs ? `?${qs}` : ""}`;
+    const headers = {
+      "X-Api-Key": this.apiKey,
+      "Content-Type": "application/json"
+    };
+    if (this.shopDomain) {
+      headers["X-Shop-Domain"] = this.shopDomain;
+    }
+    if (this.accessToken && options?.auth !== false) {
+      headers["Authorization"] = `Bearer ${this.accessToken}`;
+    }
+    if (this.cartSession) {
+      headers["X-Cart-Session"] = this.cartSession;
+    }
+    if (this.analyticsVisitorId) {
+      headers["X-Behio-Vid"] = this.analyticsVisitorId;
+    }
+    if (options?.headers) {
+      Object.assign(headers, options.headers);
+    }
+    const bodyStr = options?.body ? JSON.stringify(options.body) : void 0;
+    let interceptedConfig = {
+      url,
+      method,
+      headers,
+      body: bodyStr
+    };
+    for (const interceptor of this.requestInterceptors) {
+      interceptedConfig = await interceptor(interceptedConfig);
+    }
+    this.emit("request", { method, path });
+    for (let attempt = 0; attempt <= this.retries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      if (options?.signal) {
+        if (options.signal.aborted) {
+          clearTimeout(timeoutId);
+          throw new BehioNetworkError("Request aborted", false);
+        }
+        options.signal.addEventListener("abort", () => controller.abort(), {
+          once: true
+        });
+      }
+      let res;
+      try {
+        res = await this.fetchFn(interceptedConfig.url, {
+          method: interceptedConfig.method,
+          headers: interceptedConfig.headers,
+          body: interceptedConfig.body,
+          signal: controller.signal
+        });
+      } catch (err) {
+        clearTimeout(timeoutId);
+        const isAbort = err instanceof DOMException && err.name === "AbortError";
+        const networkErr = new BehioNetworkError(
+          isAbort ? "Request timed out" : err.message || "Network error",
+          isAbort
+        );
+        this.emit("error", networkErr);
+        if (attempt < this.retries) {
+          await new Promise(
+            (r) => setTimeout(r, this.retryDelay * (attempt + 1))
+          );
+          continue;
+        }
+        throw networkErr;
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      const remaining = res.headers.get("X-RateLimit-Remaining");
+      const reset = res.headers.get("X-RateLimit-Reset");
+      if (remaining) this.rateLimitRemaining = parseInt(remaining, 10);
+      if (reset) this.rateLimitReset = parseInt(reset, 10);
+      if (this.rateLimitRemaining !== null && this.rateLimitRemaining <= 5) {
+        this.emit("rate-limit-warning", {
+          remaining: this.rateLimitRemaining,
+          reset: this.rateLimitReset
+        });
+      }
+      this.emit("response", { method, path, status: res.status });
+      if (!res.ok) {
+        const body = await res.json().catch(() => null);
+        const apiError = new BehioApiError(
+          res.status,
+          body,
+          body?.message || `API Error ${res.status}`
+        );
+        if (res.status === 401 && this.refreshToken && options?.auth !== false && !options?._isRetryAfterRefresh) {
+          try {
+            await this.handleTokenRefresh();
+            return this.rawRequest(method, path, {
+              ...options,
+              _isRetryAfterRefresh: true
+            });
+          } catch {
+            this.emit("error", apiError);
+            throw apiError;
+          }
+        }
+        this.emit("error", apiError);
+        if (attempt < this.retries && apiError.isRetryable) {
+          await new Promise(
+            (r) => setTimeout(r, this.retryDelay * (attempt + 1))
+          );
+          continue;
+        }
+        throw apiError;
+      }
+      const responseData = res.status === 204 ? null : await res.json();
+      for (const interceptor of this.responseInterceptors) {
+        try {
+          await interceptor({
+            status: res.status,
+            data: responseData,
+            headers: res.headers
+          });
+        } catch {
+        }
+      }
+      return responseData;
+    }
+    throw new BehioNetworkError("Request failed after retries");
+  }
+};
+var CatalogModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List products with filtering, pagination, search */
+  async getProducts(query) {
+    const q = {};
+    if (query) {
+      if (query.page) q.page = query.page;
+      if (query.limit) q.limit = query.limit;
+      if (query.category) q.category = query.category;
+      if (query.label) q.label = query.label;
+      if (query.priceMin) q.priceMin = query.priceMin;
+      if (query.priceMax) q.priceMax = query.priceMax;
+      if (query.currency) q.currency = query.currency;
+      if (query.locale) q.locale = query.locale;
+      if (query.sort) q.sort = query.sort;
+      if (query.inStock !== void 0) q.inStock = query.inStock;
+      if (query.ratingMin !== void 0) q.ratingMin = query.ratingMin;
+      if (query.search) q.search = query.search;
+      if (query.customFields)
+        q.customFields = JSON.stringify(query.customFields);
+      if (query.facets) q.facets = JSON.stringify(query.facets);
+      if (query.ids && query.ids.length > 0) q.ids = query.ids;
+      if (query.slugs && query.slugs.length > 0) q.slugs = query.slugs;
+      if (query.labels && query.labels.length > 0) q.labels = query.labels;
+      if (query.categories && query.categories.length > 0)
+        q.categories = query.categories;
+      if (query.excludeIds && query.excludeIds.length > 0)
+        q.excludeIds = query.excludeIds;
+      if (query.excludeCategories && query.excludeCategories.length > 0)
+        q.excludeCategories = query.excludeCategories;
+      if (query.hasDiscount !== void 0) q.hasDiscount = query.hasDiscount;
+      if (query.isFeatured !== void 0) q.isFeatured = query.isFeatured;
+      if (query.createdAfter !== void 0) q.createdAfter = query.createdAfter;
+    }
+    return this.client.request(
+      "GET",
+      "/catalog/products",
+      { query: q }
+    );
+  }
+  /** Get product detail by slug */
+  async getProduct(slug, options) {
+    return this.client.request(
+      "GET",
+      `/catalog/products/${slug}`,
+      {
+        query: { locale: options?.locale, currency: options?.currency }
+      }
+    );
+  }
+  /** Get category tree */
+  async getCategories(locale) {
+    const res = await this.client.request("GET", "/catalog/categories", { query: { locale } });
+    if (res.error) return res;
+    return ok({ categories: res.data.categories || res.data.items || [] });
+  }
+  /** Get category detail by slug */
+  async getCategory(slug, locale) {
+    return this.client.request(
+      "GET",
+      `/catalog/categories/${slug}`,
+      { query: { locale } }
+    );
+  }
+  /** Get products in a category */
+  async getCategoryProducts(slug, query) {
+    const q = {};
+    if (query) {
+      if (query.page) q.page = query.page;
+      if (query.limit) q.limit = query.limit;
+      if (query.sort) q.sort = query.sort;
+      if (query.locale) q.locale = query.locale;
+      if (query.currency) q.currency = query.currency;
+    }
+    return this.client.request(
+      "GET",
+      `/catalog/categories/${slug}/products`,
+      { query: q }
+    );
+  }
+  /**
+   * Resolved navigation menu by handle (e.g. "main", "footer"), built in the
+   * admin Navigace. Item labels resolve in `locale`; typed refs come back as
+   * {type, slug} for link building. Returns an SdkResult error (404) when the
+   * handle is unknown or inactive — callers fall back to their own source.
+   */
+  async getMenu(handle, options) {
+    return this.client.request(
+      "GET",
+      `/catalog/menu/${encodeURIComponent(handle)}`,
+      {
+        query: { locale: options?.locale }
+      }
+    );
+  }
+  /** Get all labels */
+  async getLabels(locale) {
+    const res = await this.client.request("GET", "/catalog/labels", { query: { locale } });
+    if (res.error) return res;
+    return ok({ labels: res.data.labels || res.data.items || [] });
+  }
+  /** Get featured products */
+  async getFeatured(options) {
+    return this.client.request(
+      "GET",
+      "/catalog/featured",
+      {
+        query: { locale: options?.locale, currency: options?.currency }
+      }
+    );
+  }
+  /** Get available filter fields for dynamic filter UI */
+  async getFilters() {
+    return this.client.request(
+      "GET",
+      "/catalog/filters"
+    );
+  }
+  /**
+   * Facet groups + selection-aware counts for the current filter set (custom
+   * fields, labels, price, availability, rating, subcategories). Pass the SAME
+   * query you pass to `getProducts` (category, search, price, inStock, ratingMin,
+   * customFields, facets slugs, labels): counts for each facet are computed with
+   * that facet excluded, and values that drop to 0 are still returned (render
+   * them disabled). Use this to build an Alza-style filter sidebar.
+   */
+  async getFacets(query) {
+    const q = {};
+    if (query) {
+      if (query.category) q.category = query.category;
+      if (query.label) q.label = query.label;
+      if (query.priceMin) q.priceMin = query.priceMin;
+      if (query.priceMax) q.priceMax = query.priceMax;
+      if (query.currency) q.currency = query.currency;
+      if (query.locale) q.locale = query.locale;
+      if (query.inStock !== void 0) q.inStock = query.inStock;
+      if (query.ratingMin !== void 0) q.ratingMin = query.ratingMin;
+      if (query.search) q.search = query.search;
+      if (query.customFields)
+        q.customFields = JSON.stringify(query.customFields);
+      if (query.facets) q.facets = JSON.stringify(query.facets);
+      if (query.labels && query.labels.length > 0) q.labels = query.labels;
+      if (query.categories && query.categories.length > 0)
+        q.categories = query.categories;
+      if (query.excludeCategories && query.excludeCategories.length > 0)
+        q.excludeCategories = query.excludeCategories;
+    }
+    return this.client.request("GET", "/catalog/facets", {
+      query: q
+    });
+  }
+  /** Search products */
+  async search(query, options) {
+    return this.getProducts({ search: query, ...options });
+  }
+  /** List all active bundles */
+  async getBundles() {
+    return this.client.request("GET", "/catalog/bundles");
+  }
+  /** Get a single bundle by slug */
+  async getBundle(slug) {
+    return this.client.request("GET", `/catalog/bundles/${slug}`);
+  }
+  /**
+   * One product group ("collection") by slug with its products as standard
+   * list items. Groups are curated in the admin; use this to render curated
+   * product bands. Returns an SdkResult error (404) when the group is
+   * missing or inactive — callers should render nothing in that case.
+   */
+  async getProductGroup(slug, options) {
+    return this.client.request(
+      "GET",
+      `/catalog/product-groups/${encodeURIComponent(slug)}`,
+      {
+        query: { locale: options?.locale, currency: options?.currency }
+      }
+    );
+  }
+  /**
+   * Cross-sell / related / upsell products for a product. Returns three
+   * separate lists: `related` (podobné produkty), `upsell` (dražší
+   * alternativy) and `crossSell` (doporučené k nákupu). Items are localized
+   * and priced in the requested currency, ready to render with the same card
+   * component as `getFeatured` / `getProductGroup`.
+   */
+  async getCrossSell(productSlug, options) {
+    return this.client.request(
+      "GET",
+      `/catalog/products/${encodeURIComponent(productSlug)}/cross-sell`,
+      { query: { locale: options?.locale, currency: options?.currency } }
+    );
+  }
+  /** Active promotions applicable to a product (with countdown end time) */
+  /** Back-in-stock notification subscription for a sold-out product. */
+  async notifyWhenAvailable(productId, email) {
+    return this.client.request(
+      "POST",
+      `/catalog/products/${productId}/notify-when-available`,
+      { body: { email } }
+    );
+  }
+  async getProductPromotions(productSlug) {
+    return this.client.request(
+      "GET",
+      `/catalog/products/${productSlug}/promotions`
+    );
+  }
+  /** Check a gift card code — returns validity and remaining balance */
+  async checkGiftCard(code) {
+    return this.client.request(
+      "GET",
+      `/catalog/gift-cards/${encodeURIComponent(code)}/check`
+    );
+  }
+  /**
+   * Buy a gift card (GAP-39): creates a cart-independent order for the chosen
+   * amount. Redirect the customer to `paymentRedirectUrl` when present; the
+   * code is generated and emailed to the recipient once the order is paid.
+   */
+  async purchaseGiftCard(input) {
+    return this.client.request(
+      "POST",
+      "/gift-cards/purchase",
+      { body: input }
+    );
+  }
+  /** List configured payment methods (filtered by currency). */
+  async listPaymentMethods(opts) {
+    const query = {};
+    if (opts?.currency) query.currency = opts.currency;
+    return this.client.request(
+      "GET",
+      "/catalog/payment-methods",
+      { query }
+    );
+  }
+};
+var AuthModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Register a new customer */
+  async register(input) {
+    const res = await this.client.request(
+      "POST",
+      "/auth/register",
+      {
+        body: input,
+        auth: false
+      }
+    );
+    if (res.error) return res;
+    if (res.data.accessToken && res.data.refreshToken) {
+      this.client.setTokens({
+        accessToken: res.data.accessToken,
+        refreshToken: res.data.refreshToken
+      });
+      this.client.emit("auth:login", { email: input.email });
+    }
+    return res;
+  }
+  /** Login with email and password */
+  async login(input) {
+    const res = await this.client.request("POST", "/auth/login", {
+      body: input,
+      auth: false
+    });
+    if (res.error) return res;
+    this.client.setTokens(res.data);
+    this.client.emit("auth:login", { email: input.email });
+    return res;
+  }
+  /** Refresh access token using refresh token */
+  async refresh(refreshToken) {
+    const token = refreshToken || this.client.getRefreshToken();
+    if (!token) {
+      return {
+        data: null,
+        error: {
+          code: "UNAUTHORIZED",
+          message: "No refresh token available",
+          status: null,
+          isRetryable: false
+        }
+      };
+    }
+    const res = await this.client.request("POST", "/auth/refresh", {
+      body: { refreshToken: token },
+      auth: false
+    });
+    if (res.error) return res;
+    this.client.setTokens(res.data);
+    return res;
+  }
+  /** Logout (invalidate refresh token) */
+  async logout(refreshToken) {
+    const token = refreshToken || this.client.getRefreshToken();
+    const res = await this.client.request(
+      "POST",
+      "/auth/logout",
+      {
+        body: { refreshToken: token }
+      }
+    );
+    this.client.clearTokens();
+    this.client.emit("auth:logout");
+    return res;
+  }
+  /** Request password reset email */
+  async forgotPassword(email) {
+    return this.client.request(
+      "POST",
+      "/auth/forgot-password",
+      {
+        body: { email },
+        auth: false
+      }
+    );
+  }
+  /** Reset password with token */
+  async resetPassword(token, newPassword) {
+    return this.client.request(
+      "POST",
+      "/auth/reset-password",
+      {
+        body: { token, newPassword },
+        auth: false
+      }
+    );
+  }
+  /** Verify email with token */
+  async verifyEmail(token) {
+    return this.client.request("POST", "/auth/verify-email", {
+      body: { token },
+      auth: false
+    });
+  }
+  /** Check if user is logged in (has access token) */
+  isLoggedIn() {
+    return !!this.client.getAccessToken();
+  }
+};
+var CartModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get current cart */
+  async get() {
+    return this.client.request("GET", "/cart");
+  }
+  /** Add item to cart */
+  async addItem(input) {
+    const res = await this.client.request(
+      "POST",
+      "/cart/items",
+      {
+        body: { productId: input.productId, quantity: input.quantity }
+      }
+    );
+    if (res.error) return res;
+    if (res.data.newSessionToken) {
+      this.client.setCartSession(res.data.newSessionToken);
+    }
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Update item quantity */
+  async updateQuantity(itemId, quantity) {
+    const res = await this.client.request(
+      "PATCH",
+      `/cart/items/${itemId}`,
+      {
+        body: { quantity }
+      }
+    );
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Remove item from cart */
+  async removeItem(itemId) {
+    const res = await this.client.request(
+      "DELETE",
+      `/cart/items/${itemId}`
+    );
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Clear entire cart */
+  async clear() {
+    const res = await this.client.request("DELETE", "/cart");
+    if (res.error) return res;
+    this.client.emit("cart:cleared");
+    return res;
+  }
+  /** Apply a gift card code to the cart. Balance is deducted at checkout. */
+  async applyGiftCard(code) {
+    const res = await this.client.request("POST", "/cart/gift-card", {
+      body: { code }
+    });
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Remove a specific applied gift card from the cart by its code. */
+  async removeGiftCard(code) {
+    const res = await this.client.request(
+      "DELETE",
+      `/cart/gift-card/${encodeURIComponent(code)}`
+    );
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /**
+   * Add a bundle to the cart. Price is snapshotted at the bundle's current
+   * price. Pass either the bundle id or its slug — slug is more ergonomic
+   * for static storefront wiring (`behio.cart.addBundle({slug: "morning-set"})`).
+   *
+   * Respects the bundle's `minQuantity`, `maxQuantity`, and `stockLimit`:
+   * the request rejects with HTTP 400 if the resulting cart line would
+   * violate any of them. The returned error includes the relevant field
+   * (`minQuantity`, `maxQuantity`, or `remaining`) so the storefront can
+   * surface a meaningful message.
+   *
+   * @param identifier Either `{id: bundleId}` or `{slug: bundleSlug}`. As a
+   *                   convenience, passing a plain string is treated as the
+   *                   bundle id for backwards compatibility.
+   * @param quantity   How many bundles to add (defaults to 1). Capped by
+   *                   the bundle's `maxQuantity` if set.
+   */
+  async addBundle(identifier, quantity = 1) {
+    const body = {
+      quantity
+    };
+    if (typeof identifier === "string") {
+      body.bundleId = identifier;
+    } else if ("id" in identifier) {
+      body.bundleId = identifier.id;
+    } else {
+      body.bundleSlug = identifier.slug;
+    }
+    const res = await this.client.request("POST", "/cart/bundles", {
+      body
+    });
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Update quantity of a bundle already in the cart */
+  async updateBundleQuantity(bundleId, quantity) {
+    const res = await this.client.request(
+      "PATCH",
+      `/cart/bundles/${bundleId}`,
+      {
+        body: { quantity }
+      }
+    );
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Remove a bundle from the cart */
+  async removeBundle(bundleId) {
+    const res = await this.client.request(
+      "DELETE",
+      `/cart/bundles/${bundleId}`
+    );
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Merge anonymous cart into authenticated customer cart */
+  async merge() {
+    const res = await this.client.request("POST", "/cart/merge");
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Apply discount code */
+  async applyDiscount(code) {
+    const res = await this.client.request("POST", "/cart/discount", {
+      body: { code }
+    });
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+  /** Remove discount code */
+  async removeDiscount() {
+    const res = await this.client.request("DELETE", "/cart/discount");
+    if (res.error) return res;
+    this.client.emit("cart:updated", res.data);
+    return res;
+  }
+};
+var CheckoutModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Create order from cart */
+  async createOrder(input) {
+    const res = await this.client.request("POST", "/checkout", {
+      body: input
+    });
+    if (res.error) return res;
+    this.client.clearCartSession();
+    this.client.emit("order:created", res.data);
+    this.client.emit("cart:cleared");
+    return res;
+  }
+};
+var OrdersModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List customer orders (requires auth) */
+  async list(options) {
+    return this.client.request(
+      "GET",
+      "/orders",
+      {
+        query: { page: options?.page, limit: options?.limit }
+      }
+    );
+  }
+  /** Get order detail (requires auth) */
+  async get(orderNumber) {
+    return this.client.request("GET", `/orders/${orderNumber}`);
+  }
+  /** Cancel a PENDING order (requires auth) */
+  async cancel(orderNumber) {
+    return this.client.request(
+      "POST",
+      `/orders/${orderNumber}/cancel`
+    );
+  }
+  /**
+   * Track an order by tracking token (no login, only API key). Returns a
+   * PII-minimized view: order status + items + masked email + destination
+   * city, never full address / phone / billing — the token travels in URLs
+   * and e-mails so it must not expose full personal data.
+   */
+  async track(trackingToken) {
+    return this.client.request(
+      "GET",
+      `/orders/track/${trackingToken}`,
+      { auth: false }
+    );
+  }
+  /**
+   * Step 1 of guest order-access: request a 6-digit code e-mailed to the
+   * address on the order. The response is always generic (success) regardless
+   * of whether the order number + e-mail match, so order numbers can't be
+   * enumerated. No login, only API key.
+   */
+  async requestAccessCode(orderNumber, email) {
+    return this.client.request(
+      "POST",
+      "/orders/access/request",
+      {
+        auth: false,
+        body: { orderNumber, email }
+      }
+    );
+  }
+  /**
+   * Step 2 of guest order-access: verify the e-mailed code. On success returns
+   * the FULL order detail plus a short-lived `accessToken` you can pass to
+   * {@link getByAccessToken} to re-fetch the detail without re-entering the
+   * code. No login, only API key.
+   */
+  async verifyAccessCode(orderNumber, email, code) {
+    return this.client.request(
+      "POST",
+      "/orders/access/verify",
+      {
+        auth: false,
+        body: { orderNumber, email, code }
+      }
+    );
+  }
+  /**
+   * Re-fetch a guest order's full detail using the `accessToken` returned by
+   * {@link verifyAccessCode}. The token is scoped to that single order and
+   * expires after 30 minutes.
+   */
+  async getByAccessToken(accessToken) {
+    return this.client.request("GET", "/orders/access/detail", {
+      auth: false,
+      headers: { "X-Order-Access": accessToken }
+    });
+  }
+  /**
+   * Guest digital download (GAP-07): mint a short-lived signed URL for a
+   * download grant on a guest-accessed order, using the order-access token from
+   * {@link verifyAccessCode}. Scoped to that one order.
+   */
+  async getAccessDownloadUrl(accessToken, downloadId) {
+    return this.client.request(
+      "POST",
+      `/orders/access/downloads/${downloadId}/url`,
+      {
+        auth: false,
+        headers: { "X-Order-Access": accessToken }
+      }
+    );
+  }
+};
+var CustomerModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Get customer profile */
+  async getProfile() {
+    return this.client.request("GET", "/customer/profile");
+  }
+  /** Update customer profile */
+  async updateProfile(data) {
+    return this.client.request("PATCH", "/customer/profile", {
+      body: data
+    });
+  }
+  /** Change password */
+  async changePassword(currentPassword, newPassword) {
+    return this.client.request("PUT", "/customer/password", {
+      body: { currentPassword, newPassword }
+    });
+  }
+  /** List addresses */
+  async getAddresses() {
+    return this.client.request(
+      "GET",
+      "/customer/addresses"
+    );
+  }
+  /** Create address */
+  async createAddress(address) {
+    return this.client.request("POST", "/customer/addresses", {
+      body: address
+    });
+  }
+  /** Update address */
+  async updateAddress(addressId, data) {
+    return this.client.request(
+      "PATCH",
+      `/customer/addresses/${addressId}`,
+      { body: data }
+    );
+  }
+  /** Delete address */
+  async deleteAddress(addressId) {
+    return this.client.request(
+      "DELETE",
+      `/customer/addresses/${addressId}`
+    );
+  }
+  /**
+   * Loyalty program summary for the logged-in customer (points balance +
+   * value, current tier, next-tier progress, point ratio, referral code,
+   * recent transactions). Requires an authenticated customer session.
+   */
+  async getLoyalty() {
+    return this.client.request("GET", "/customer/loyalty");
+  }
+  /**
+   * Digital product delivery (GAP-07): list the logged-in customer's download
+   * grants across all their orders (file name, product, remaining downloads,
+   * expiry). Requires an authenticated customer session.
+   */
+  async getDownloads() {
+    return this.client.request(
+      "GET",
+      "/customer/downloads"
+    );
+  }
+  /**
+   * Mint a short-lived signed URL for one download grant. Counts against the
+   * grant's download budget and enforces the max-download + expiry limits
+   * server-side. Requires an authenticated customer session.
+   */
+  async getDownloadUrl(downloadId) {
+    return this.client.request(
+      "POST",
+      `/customer/downloads/${downloadId}/url`
+    );
+  }
+  /**
+   * Online courses (LMS): list the logged-in customer's enrolled courses
+   * with progress. Enrollment is created automatically when an order with a
+   * course product is paid. Requires an authenticated customer session.
+   */
+  async getCourses() {
+    return this.client.request(
+      "GET",
+      "/customer/courses"
+    );
+  }
+  /**
+   * Course player payload: modules and lessons in order, with per-lesson
+   * drip-unlock state. Locked lessons never contain content — the server
+   * withholds `videoUrl`/`content`/`attachments` until `unlockAt`.
+   */
+  async getCourse(courseId) {
+    return this.client.request(
+      "GET",
+      `/customer/courses/${courseId}`
+    );
+  }
+  /** Mark an unlocked lesson as completed (idempotent). */
+  async completeLesson(courseId, lessonId) {
+    return this.client.request(
+      "POST",
+      `/customer/courses/${courseId}/lessons/${lessonId}/complete`
+    );
+  }
+  /**
+   * Quiz for an unlocked lesson. Correct answers are never included — scoring
+   * happens server-side in `submitLessonQuiz`. Locked lessons return 403.
+   */
+  async getLessonQuiz(courseId, lessonId) {
+    return this.client.request(
+      "GET",
+      `/customer/courses/${courseId}/lessons/${lessonId}/quiz`
+    );
+  }
+  /**
+   * Submit quiz answers: returns the score, reveals correct answers and, when
+   * the score reaches `passPercent` (70 %), marks the lesson completed
+   * automatically.
+   */
+  async submitLessonQuiz(courseId, lessonId, answers) {
+    return this.client.request(
+      "POST",
+      `/customer/courses/${courseId}/lessons/${lessonId}/quiz/submit`,
+      { body: { answers } }
+    );
+  }
+  /**
+   * Completion certificates of the logged-in customer. Each carries a public
+   * verification code for sharing (LinkedIn, CV).
+   */
+  async getCourseCertificates() {
+    return this.client.request(
+      "GET",
+      "/customer/courses/certificates"
+    );
+  }
+  /**
+   * AI tutor "Ask about this lesson": the student's private thread for one
+   * lesson (oldest first). `enabled: false` = the merchant turned the tutor
+   * off — hide the widget. Locked lessons return 403.
+   */
+  async getLessonTutorThread(courseId, lessonId) {
+    return this.client.request(
+      "GET",
+      `/customer/courses/${courseId}/lessons/${lessonId}/tutor`
+    );
+  }
+  /**
+   * Ask the AI tutor a question about the lesson. The answer sticks to the
+   * lesson topic and comes back in the language of the question (Czech by
+   * default). Rate limited (20/min); 403 on locked lessons or when the
+   * merchant disabled the tutor.
+   */
+  async askLessonTutor(courseId, lessonId, question) {
+    return this.client.request(
+      "POST",
+      `/customer/courses/${courseId}/lessons/${lessonId}/tutor`,
+      { body: { question } }
+    );
+  }
+  /**
+   * Lesson discussion: paginated top-level comments (newest first) with one
+   * level of replies. Only enrolled customers with the lesson unlocked; 403
+   * when the merchant disabled the discussion.
+   */
+  async getLessonComments(courseId, lessonId, page = 1) {
+    return this.client.request(
+      "GET",
+      `/customer/courses/${courseId}/lessons/${lessonId}/comments`,
+      { query: { page: String(page) } }
+    );
+  }
+  /**
+   * Post a comment under the lesson, or a reply when `parentId` points to a
+   * top-level comment (replies go one level deep only). Max 5000 characters.
+   */
+  async postLessonComment(courseId, lessonId, body, parentId) {
+    return this.client.request(
+      "POST",
+      `/customer/courses/${courseId}/lessons/${lessonId}/comments`,
+      { body: { body, ...parentId ? { parentId } : {} } }
+    );
+  }
+  /**
+   * Delete the customer's OWN comment (including its replies). Someone
+   * else's comment returns 404.
+   */
+  async deleteLessonComment(courseId, lessonId, commentId) {
+    return this.client.request(
+      "DELETE",
+      `/customer/courses/${courseId}/lessons/${lessonId}/comments/${commentId}`
+    );
+  }
+  /**
+   * The student's private note for one lesson. `body` is an empty string
+   * when no note exists yet. Visible only to the logged-in student.
+   */
+  async getLessonNote(courseId, lessonId) {
+    return this.client.request(
+      "GET",
+      `/customer/courses/${courseId}/lessons/${lessonId}/note`
+    );
+  }
+  /**
+   * Save (upsert) the student's private lesson note. Autosave-friendly; an
+   * empty string clears the note. Max 20 000 characters.
+   */
+  async saveLessonNote(courseId, lessonId, body) {
+    return this.client.request(
+      "PUT",
+      `/customer/courses/${courseId}/lessons/${lessonId}/note`,
+      { body: { body } }
+    );
+  }
+};
+var CourseCertificatesModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Publicly verify a certificate code (no customer login needed) — build a
+   * `/certifikat/{code}` page with this. Unknown codes return a 404 error.
+   */
+  async verify(code) {
+    return this.client.request(
+      "GET",
+      `/course-certificates/${encodeURIComponent(code)}`
+    );
+  }
+  /**
+   * Download the certificate as a branded PDF (A5 landscape). Returns a Blob;
+   * trigger a browser download via `URL.createObjectURL(blob)`.
+   */
+  async downloadPdf(code) {
+    return this.client.requestBlob(
+      `/course-certificates/${encodeURIComponent(code)}/pdf`
+    );
+  }
+};
+var PagesModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** List CMS pages */
+  async list(locale) {
+    return this.client.request("GET", "/pages", {
+      query: { locale }
+    });
+  }
+  /** Get page by slug */
+  async get(slug, locale) {
+    return this.client.request("GET", `/pages/${slug}`, {
+      query: { locale }
+    });
+  }
+};
+var WishlistModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get() {
+    return this.client.request(
+      "GET",
+      "/customer/wishlist"
+    );
+  }
+  async add(productId) {
+    return this.client.request(
+      "POST",
+      "/customer/wishlist",
+      { body: { productId } }
+    );
+  }
+  async remove(productId) {
+    return this.client.request(
+      "DELETE",
+      `/customer/wishlist/${productId}`
+    );
+  }
+  async isInWishlist(productId) {
+    return this.client.request(
+      "GET",
+      `/customer/wishlist/${productId}/check`
+    );
+  }
+};
+var SubscriptionsModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * List the logged-in customer's recurring-order subscriptions (products,
+   * cadence, next order date, status). Requires an authenticated customer
+   * session. Subscriptions are created by the merchant in v1.
+   */
+  async list() {
+    return this.client.request(
+      "GET",
+      "/customer/subscriptions"
+    );
+  }
+  /** Pause an active subscription (no orders are generated while paused). */
+  async pause(subscriptionId) {
+    return this.client.request(
+      "POST",
+      `/customer/subscriptions/${subscriptionId}/pause`
+    );
+  }
+  /** Resume a paused subscription (re-schedules the next order). */
+  async resume(subscriptionId) {
+    return this.client.request(
+      "POST",
+      `/customer/subscriptions/${subscriptionId}/resume`
+    );
+  }
+  /** Cancel a subscription permanently (no more orders). */
+  async cancel(subscriptionId) {
+    return this.client.request(
+      "POST",
+      `/customer/subscriptions/${subscriptionId}/cancel`
+    );
+  }
+};
+var ReviewsModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getProductReviews(productId, page = 1, limit = 20) {
+    return this.client.request(
+      "GET",
+      `/catalog/products/${productId}/reviews`,
+      {
+        query: { page: String(page), limit: String(limit) }
+      }
+    );
+  }
+  async submit(input) {
+    return this.client.request("POST", "/catalog/reviews", {
+      body: input
+    });
+  }
+  async voteHelpful(reviewId, helpful) {
+    return this.client.request(
+      "POST",
+      `/catalog/reviews/${reviewId}/vote`,
+      { body: { helpful } }
+    );
+  }
+};
+var ReturnsModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Guest order lookup for the EU withdrawal form: order number + the email
+   * used on the order resolve to the order id and per-item returnable
+   * quantities. POST so the email never appears in a URL.
+   */
+  async lookupOrder(orderNumber, email) {
+    return this.client.request(
+      "POST",
+      "/returns/lookup-order",
+      {
+        body: { orderNumber, email }
+      }
+    );
+  }
+  async submit(input) {
+    return this.client.request("POST", "/returns", {
+      body: input
+    });
+  }
+  /** Email is the ownership gate; POST so it never lands in a URL / log. */
+  async getStatus(returnId, email) {
+    return this.client.request(
+      "POST",
+      `/returns/${returnId}/status`,
+      { body: { email } }
+    );
+  }
+};
+var ConsentModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async record(input) {
+    return this.client.request("POST", "/consent", {
+      body: input,
+      auth: false
+    });
+  }
+  async get(visitorId) {
+    const result = await this.client.request("GET", `/consent/${visitorId}/status`, { auth: false });
+    if (result.error && result.error.status === 404) {
+      const legacy = await this.client.request(
+        "GET",
+        `/consent/${visitorId}`,
+        { auth: false }
+      );
+      if (legacy.error && legacy.error.status === 404)
+        return { data: null, error: null };
+      return legacy;
+    }
+    if (result.error) return { data: null, error: result.error };
+    return {
+      data: result.data?.consented ? result.data.consent : null,
+      error: null
+    };
+  }
+  async revoke(visitorId) {
+    return this.client.request(
+      "DELETE",
+      `/consent/${visitorId}`,
+      { auth: false }
+    );
+  }
+};
+var QuotesModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async submit(input) {
+    return this.client.request("POST", "/catalog/quote-request", {
+      body: input
+    });
+  }
+  async accept(quoteId, email) {
+    return this.client.request(
+      "POST",
+      `/quotes/${quoteId}/accept`,
+      { body: { email } }
+    );
+  }
+  /** Email is the ownership gate — quotes carry contact PII and negotiated
+   *  prices, so the id alone is never enough. POST keeps it out of URLs. */
+  async getStatus(quoteId, email) {
+    return this.client.request(
+      "POST",
+      `/quotes/${quoteId}/status`,
+      { body: { email } }
+    );
+  }
+  /**
+   * The logged-in customer's own quote requests ("Moje poptávky", GAP-18).
+   * Requires an authenticated session; ownership is the auth token (customer id
+   * + verified email), never a payload. Newest first.
+   */
+  async listMine() {
+    return this.client.request(
+      "GET",
+      "/customer/quotes"
+    );
+  }
+};
+var AddressModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /** Search for address suggestions (debounce on your side, or use the React hook) */
+  async autocomplete(query, country) {
+    if (!query || query.length < 2) return ok({ suggestions: [] });
+    return this.client.request(
+      "GET",
+      "/addresses/autocomplete",
+      {
+        query: { q: query, country }
+      }
+    );
+  }
+  /** Get full structured address from a suggestion's placeId */
+  async getDetail(placeId) {
+    return this.client.request(
+      "GET",
+      "/addresses/place-detail",
+      {
+        query: { placeId }
+      }
+    );
+  }
+};
+var ShippingModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Return the configured shipping methods that pass the current
+   * currency + country filter. Fixed-price methods come back with
+   * their `pricing[]` row resolved; live-quote methods come back with
+   * `price` 0 here — call `quote()` to get the real live price.
+   */
+  async listMethods(opts) {
+    const query = {};
+    if (opts?.currency) query.currency = opts.currency;
+    if (opts?.country) query.country = opts.country;
+    if (opts?.cartTotal != null) query.cartTotal = String(opts.cartTotal);
+    if (opts?.cartWeightKg != null)
+      query.cartWeightKg = String(opts.cartWeightKg);
+    return this.client.request(
+      "GET",
+      "/catalog/shipping-methods",
+      { query }
+    );
+  }
+  /**
+   * Quote shipping for a destination address + cart contents. Each
+   * configured method is evaluated:
+   *   - `priceStrategy="fixed"` → resolved from the merchant's per-currency
+   *     `pricing[]` rows + free-shipping threshold check.
+   *   - `priceStrategy="live_quote"` → dispatched to the upstream
+   *     meta-provider (Zaslat, future Shippo / Sendcloud / …) and run
+   *     through the merchant's markup/rounding rules.
+   *
+   * Filter `available: true` for the checkout picker; `available: false`
+   * rows carry a `reason` (`"no_rate_returned"`, `"live_quote_not_implemented"`,
+   * …) you can log but should not display.
+   */
+  async quote(input) {
+    return this.client.request(
+      "POST",
+      "/catalog/shipping/quote",
+      { body: input }
+    );
+  }
+  /**
+   * List pickup points (parcel shops / lockers) for a method that has
+   * `supportsPickupPoints`. Filter with `query` (name / city / zip) for a
+   * "find your branch" box. Send the chosen point's `externalId` back as
+   * `checkout.pickupPointId`.
+   */
+  async getPickupPoints(input) {
+    const query = { methodId: input.methodId };
+    if (input.query) query.query = input.query;
+    if (input.country) query.country = input.country;
+    if (input.limit != null) query.limit = String(input.limit);
+    return this.client.request(
+      "GET",
+      "/catalog/shipping/pickup-points",
+      { query }
+    );
+  }
+};
+var NewsletterModule = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async subscribe(input) {
+    return this.client.request(
+      "POST",
+      "/newsletter/subscribe",
+      {
+        body: input,
+        auth: false
+      }
+    );
+  }
+  async unsubscribe(email) {
+    return this.client.request(
+      "POST",
+      "/newsletter/unsubscribe",
+      {
+        body: { email },
+        auth: false
+      }
+    );
+  }
+};
 
 // src/react/context.ts
-
-var BehioContext = _react.createContext.call(void 0, null);
+var import_react = require("react");
+var BehioContext = (0, import_react.createContext)(null);
 function useBehio() {
-  const ctx = _react.useContext.call(void 0, BehioContext);
+  const ctx = (0, import_react.useContext)(BehioContext);
   if (!ctx) {
     throw new Error("useBehio must be used within a <BehioProvider>");
   }
@@ -49,20 +1834,20 @@ var localStorageAdapter = {
   get(key) {
     try {
       return window.localStorage.getItem(key);
-    } catch (e2) {
+    } catch {
       return null;
     }
   },
   set(key, value) {
     try {
       window.localStorage.setItem(key, value);
-    } catch (e3) {
+    } catch {
     }
   },
   remove(key) {
     try {
       window.localStorage.removeItem(key);
-    } catch (e4) {
+    } catch {
     }
   }
 };
@@ -70,7 +1855,7 @@ function createMemoryStorage() {
   const store = /* @__PURE__ */ new Map();
   return {
     get(key) {
-      return _nullishCoalesce(store.get(key), () => ( null));
+      return store.get(key) ?? null;
     },
     set(key, value) {
       store.set(key, value);
@@ -111,7 +1896,7 @@ var STORAGE_KEYS = {
 };
 
 // src/react/provider.tsx
-var _jsxruntime = require('react/jsx-runtime');
+var import_jsx_runtime = require("react/jsx-runtime");
 function BehioProvider({
   apiKey,
   baseUrl,
@@ -127,7 +1912,7 @@ function BehioProvider({
   queryClient: externalQueryClient,
   children
 }) {
-  const storageAdapter = _react.useMemo.call(void 0, () => resolveStorage(storageOption), [storageOption]);
+  const storageAdapter = (0, import_react2.useMemo)(() => resolveStorage(storageOption), [storageOption]);
   const resolveInitialCurrency = () => {
     if (persistCurrency) {
       const stored = cookieStorage.get(currencyCookieName);
@@ -135,10 +1920,10 @@ function BehioProvider({
     }
     return currency;
   };
-  const [activeCurrency, setActiveCurrency] = _react.useState.call(void 0, resolveInitialCurrency);
-  const clientRef = _react.useRef.call(void 0, null);
+  const [activeCurrency, setActiveCurrency] = (0, import_react2.useState)(resolveInitialCurrency);
+  const clientRef = (0, import_react2.useRef)(null);
   if (!clientRef.current) {
-    clientRef.current = new (0, _chunkFOUBL2EQjs.BehioStorefront)({
+    clientRef.current = new BehioStorefront({
       apiKey,
       baseUrl,
       ...shopDomain ? { shopDomain } : {},
@@ -149,7 +1934,7 @@ function BehioProvider({
     });
   }
   const client = clientRef.current;
-  _react.useEffect.call(void 0, () => {
+  (0, import_react2.useEffect)(() => {
     const accessToken = storageAdapter.get(STORAGE_KEYS.ACCESS_TOKEN);
     const refreshToken = storageAdapter.get(STORAGE_KEYS.REFRESH_TOKEN);
     if (accessToken && refreshToken) {
@@ -160,7 +1945,7 @@ function BehioProvider({
       client.setCartSession(cartSession);
     }
   }, [client, storageAdapter]);
-  _react.useEffect.call(void 0, () => {
+  (0, import_react2.useEffect)(() => {
     if (!persistCurrency) return;
     const stored = cookieStorage.get(currencyCookieName);
     if (stored && stored !== activeCurrency) {
@@ -168,17 +1953,17 @@ function BehioProvider({
       client.setCurrency(stored);
     }
   }, []);
-  _react.useEffect.call(void 0, () => {
+  (0, import_react2.useEffect)(() => {
     if (currency !== void 0 && currency !== activeCurrency) {
       setActiveCurrency(currency);
       client.setCurrency(currency);
     }
   }, [currency]);
-  const queryClientRef = _react.useRef.call(void 0, null);
-  const qc = _react.useMemo.call(void 0, () => {
+  const queryClientRef = (0, import_react2.useRef)(null);
+  const qc = (0, import_react2.useMemo)(() => {
     if (externalQueryClient) return externalQueryClient;
     if (!queryClientRef.current) {
-      queryClientRef.current = new (0, _reactquery.QueryClient)({
+      queryClientRef.current = new import_react_query.QueryClient({
         defaultOptions: {
           queries: {
             staleTime: 6e4,
@@ -189,7 +1974,7 @@ function BehioProvider({
     }
     return queryClientRef.current;
   }, [externalQueryClient]);
-  const setCurrency = _react.useCallback.call(void 0, 
+  const setCurrency = (0, import_react2.useCallback)(
     (next) => {
       setActiveCurrency(next);
       client.setCurrency(next);
@@ -197,12 +1982,12 @@ function BehioProvider({
         if (next) cookieStorage.set(currencyCookieName, next);
         else cookieStorage.remove(currencyCookieName);
       }
-      _optionalChain([onCurrencyChange, 'optionalCall', _2 => _2(next)]);
+      onCurrencyChange?.(next);
       void qc.invalidateQueries({ queryKey: ["behio"] });
     },
     [client, qc, persistCurrency, currencyCookieName, onCurrencyChange]
   );
-  const ctxValue = _react.useMemo.call(void 0, 
+  const ctxValue = (0, import_react2.useMemo)(
     () => ({
       client,
       storage: storageAdapter,
@@ -213,12 +1998,12 @@ function BehioProvider({
     }),
     [client, storageAdapter, activeCurrency, setCurrency, defaultCurrency, currencies]
   );
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _reactquery.QueryClientProvider, { client: qc, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, BehioContext.Provider, { value: ctxValue, children }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_query.QueryClientProvider, { client: qc, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BehioContext.Provider, { value: ctxValue, children }) });
 }
 
 // src/react/hooks/use-products.ts
-
-
+var import_react3 = require("react");
+var import_react_query2 = require("@tanstack/react-query");
 
 // src/react/utils/unwrap.ts
 var UnwrappedError = class extends Error {
@@ -237,10 +2022,10 @@ async function unwrap(p) {
 // src/react/hooks/use-products.ts
 function useProducts(query) {
   const { client } = useBehio();
-  const { initialData, enabled, page: initialPage, limit, ...filters } = _nullishCoalesce(query, () => ( {}));
-  const [page, setPage] = _react.useState.call(void 0, _nullishCoalesce(initialPage, () => ( 1)));
-  const serializedFilters = _react.useMemo.call(void 0, () => JSON.stringify({ ...filters, limit }), [filters, limit]);
-  const infinite = _reactquery.useInfiniteQuery.call(void 0, {
+  const { initialData, enabled, page: initialPage, limit, ...filters } = query ?? {};
+  const [page, setPage] = (0, import_react3.useState)(initialPage ?? 1);
+  const serializedFilters = (0, import_react3.useMemo)(() => JSON.stringify({ ...filters, limit }), [filters, limit]);
+  const infinite = (0, import_react_query2.useInfiniteQuery)({
     queryKey: ["behio", "products", serializedFilters, page],
     queryFn: ({ pageParam }) => unwrap(client.catalog.getProducts({ ...filters, limit, page: pageParam })),
     initialPageParam: page,
@@ -249,19 +2034,19 @@ function useProducts(query) {
     initialData: initialData ? { pages: [initialData], pageParams: [initialData.page] } : void 0,
     enabled: enabled !== false
   });
-  const items = _react.useMemo.call(void 0, 
-    () => _nullishCoalesce(_optionalChain([infinite, 'access', _3 => _3.data, 'optionalAccess', _4 => _4.pages, 'access', _5 => _5.flatMap, 'call', _6 => _6((p) => p.items)]), () => ( [])),
+  const items = (0, import_react3.useMemo)(
+    () => infinite.data?.pages.flatMap((p) => p.items) ?? [],
     [infinite.data]
   );
-  const lastPage = _optionalChain([infinite, 'access', _7 => _7.data, 'optionalAccess', _8 => _8.pages, 'access', _9 => _9[infinite.data.pages.length - 1]]);
-  const firstPage = _optionalChain([infinite, 'access', _10 => _10.data, 'optionalAccess', _11 => _11.pages, 'access', _12 => _12[0]]);
-  const loadMore = _react.useCallback.call(void 0, () => {
+  const lastPage = infinite.data?.pages[infinite.data.pages.length - 1];
+  const firstPage = infinite.data?.pages[0];
+  const loadMore = (0, import_react3.useCallback)(() => {
     if (infinite.hasNextPage && !infinite.isFetchingNextPage) {
       return infinite.fetchNextPage();
     }
     return Promise.resolve();
   }, [infinite]);
-  const goToPage = _react.useCallback.call(void 0, (newPage) => {
+  const goToPage = (0, import_react3.useCallback)((newPage) => {
     setPage(newPage);
   }, []);
   return {
@@ -271,10 +2056,10 @@ function useProducts(query) {
     /** Raw React Query data with all pages */
     data: infinite.data,
     /** Last loaded page meta */
-    total: _nullishCoalesce(_optionalChain([lastPage, 'optionalAccess', _13 => _13.total]), () => ( 0)),
-    totalPages: _nullishCoalesce(_optionalChain([lastPage, 'optionalAccess', _14 => _14.totalPages]), () => ( 0)),
-    currentPage: _nullishCoalesce(_optionalChain([lastPage, 'optionalAccess', _15 => _15.page]), () => ( page)),
-    limit: _nullishCoalesce(_nullishCoalesce(_optionalChain([lastPage, 'optionalAccess', _16 => _16.limit]), () => ( limit)), () => ( 20)),
+    total: lastPage?.total ?? 0,
+    totalPages: lastPage?.totalPages ?? 0,
+    currentPage: lastPage?.page ?? page,
+    limit: lastPage?.limit ?? limit ?? 20,
     // --- Pagination controls ---
     /** Current page (manual pagination) */
     page,
@@ -285,8 +2070,8 @@ function useProducts(query) {
     /** Fetch previous page */
     loadPrevious: infinite.fetchPreviousPage,
     /** Can load more? */
-    hasMore: _nullishCoalesce(infinite.hasNextPage, () => ( false)),
-    hasPrevious: _nullishCoalesce(infinite.hasPreviousPage, () => ( false)),
+    hasMore: infinite.hasNextPage ?? false,
+    hasPrevious: infinite.hasPreviousPage ?? false,
     // --- States ---
     isLoading: infinite.isLoading,
     isFetching: infinite.isFetching,
@@ -300,117 +2085,117 @@ function useProducts(query) {
 }
 
 // src/react/hooks/use-product.ts
-
+var import_react_query3 = require("@tanstack/react-query");
 function useProduct(slug, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query3.useQuery)({
     // currency + locale belong in the key so switching either refetches the
     // price/translation instead of serving a stale cache hit.
-    queryKey: ["behio", "product", slug, _optionalChain([options, 'optionalAccess', _17 => _17.locale]), _optionalChain([options, 'optionalAccess', _18 => _18.currency])],
+    queryKey: ["behio", "product", slug, options?.locale, options?.currency],
     queryFn: () => unwrap(client.catalog.getProduct(slug, {
-      locale: _optionalChain([options, 'optionalAccess', _19 => _19.locale]),
-      currency: _optionalChain([options, 'optionalAccess', _20 => _20.currency])
+      locale: options?.locale,
+      currency: options?.currency
     })),
-    initialData: _optionalChain([options, 'optionalAccess', _21 => _21.initialData]),
-    enabled: _optionalChain([options, 'optionalAccess', _22 => _22.enabled]) !== false && !!slug
+    initialData: options?.initialData,
+    enabled: options?.enabled !== false && !!slug
   });
 }
 
 // src/react/hooks/use-categories.ts
-
+var import_react_query4 = require("@tanstack/react-query");
 function useCategories(locale, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query4.useQuery)({
     queryKey: ["behio", "categories", locale],
     queryFn: async () => {
       const result = await unwrap(client.catalog.getCategories(locale));
       return result.categories;
     },
-    enabled: _optionalChain([options, 'optionalAccess', _23 => _23.enabled]) !== false
+    enabled: options?.enabled !== false
   });
 }
 function useCategory(slug, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "category", slug, _optionalChain([options, 'optionalAccess', _24 => _24.locale])],
-    queryFn: () => unwrap(client.catalog.getCategory(slug, _optionalChain([options, 'optionalAccess', _25 => _25.locale]))),
-    enabled: _optionalChain([options, 'optionalAccess', _26 => _26.enabled]) !== false && !!slug
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["behio", "category", slug, options?.locale],
+    queryFn: () => unwrap(client.catalog.getCategory(slug, options?.locale)),
+    enabled: options?.enabled !== false && !!slug
   });
 }
 
 // src/react/hooks/use-menu.ts
-
+var import_react_query5 = require("@tanstack/react-query");
 function useMenu(handle, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "menu", handle, _optionalChain([options, 'optionalAccess', _27 => _27.locale])],
-    queryFn: () => unwrap(client.catalog.getMenu(handle, { locale: _optionalChain([options, 'optionalAccess', _28 => _28.locale]) })),
-    enabled: _optionalChain([options, 'optionalAccess', _29 => _29.enabled]) !== false && !!handle
+  return (0, import_react_query5.useQuery)({
+    queryKey: ["behio", "menu", handle, options?.locale],
+    queryFn: () => unwrap(client.catalog.getMenu(handle, { locale: options?.locale })),
+    enabled: options?.enabled !== false && !!handle
   });
 }
 
 // src/react/hooks/use-labels.ts
-
+var import_react_query6 = require("@tanstack/react-query");
 function useLabels(locale, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query6.useQuery)({
     queryKey: ["behio", "labels", locale],
     queryFn: async () => {
       const result = await unwrap(client.catalog.getLabels(locale));
       return result.labels;
     },
-    enabled: _optionalChain([options, 'optionalAccess', _30 => _30.enabled]) !== false
+    enabled: options?.enabled !== false
   });
 }
 
 // src/react/hooks/use-featured.ts
-
+var import_react_query7 = require("@tanstack/react-query");
 function useFeatured(options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "featured", _optionalChain([options, 'optionalAccess', _31 => _31.locale]), _optionalChain([options, 'optionalAccess', _32 => _32.currency])],
+  return (0, import_react_query7.useQuery)({
+    queryKey: ["behio", "featured", options?.locale, options?.currency],
     queryFn: () => unwrap(client.catalog.getFeatured({
-      locale: _optionalChain([options, 'optionalAccess', _33 => _33.locale]),
-      currency: _optionalChain([options, 'optionalAccess', _34 => _34.currency])
+      locale: options?.locale,
+      currency: options?.currency
     })),
-    initialData: _optionalChain([options, 'optionalAccess', _35 => _35.initialData]),
-    enabled: _optionalChain([options, 'optionalAccess', _36 => _36.enabled]) !== false
+    initialData: options?.initialData,
+    enabled: options?.enabled !== false
   });
 }
 
 // src/react/hooks/use-filters.ts
-
+var import_react_query8 = require("@tanstack/react-query");
 function useFilters(options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query8.useQuery)({
     queryKey: ["behio", "filters"],
     queryFn: async () => {
       const result = await unwrap(client.catalog.getFilters());
       return result.filters;
     },
-    enabled: _optionalChain([options, 'optionalAccess', _37 => _37.enabled]) !== false
+    enabled: options?.enabled !== false
   });
 }
 
 // src/react/hooks/use-facets.ts
-
+var import_react_query9 = require("@tanstack/react-query");
 function useFacets(query, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "facets", _nullishCoalesce(query, () => ( {}))],
+  return (0, import_react_query9.useQuery)({
+    queryKey: ["behio", "facets", query ?? {}],
     queryFn: async () => unwrap(client.catalog.getFacets(query)),
-    enabled: _optionalChain([options, 'optionalAccess', _38 => _38.enabled]) !== false
+    enabled: options?.enabled !== false
   });
 }
 
 // src/react/hooks/use-search.ts
-
-
+var import_react4 = require("react");
+var import_react_query10 = require("@tanstack/react-query");
 function useSearch(query, options) {
   const { client } = useBehio();
-  const debounceMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _39 => _39.debounceMs]), () => ( 300));
-  const [debouncedQuery, setDebouncedQuery] = _react.useState.call(void 0, query);
-  _react.useEffect.call(void 0, () => {
+  const debounceMs = options?.debounceMs ?? 300;
+  const [debouncedQuery, setDebouncedQuery] = (0, import_react4.useState)(query);
+  (0, import_react4.useEffect)(() => {
     if (debounceMs <= 0) {
       setDebouncedQuery(query);
       return;
@@ -418,36 +2203,36 @@ function useSearch(query, options) {
     const timer = setTimeout(() => setDebouncedQuery(query), debounceMs);
     return () => clearTimeout(timer);
   }, [query, debounceMs]);
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "search", debouncedQuery, _optionalChain([options, 'optionalAccess', _40 => _40.page]), _optionalChain([options, 'optionalAccess', _41 => _41.limit])],
+  return (0, import_react_query10.useQuery)({
+    queryKey: ["behio", "search", debouncedQuery, options?.page, options?.limit],
     queryFn: () => unwrap(client.catalog.search(debouncedQuery, {
-      page: _optionalChain([options, 'optionalAccess', _42 => _42.page]),
-      limit: _optionalChain([options, 'optionalAccess', _43 => _43.limit])
+      page: options?.page,
+      limit: options?.limit
     })),
-    enabled: _optionalChain([options, 'optionalAccess', _44 => _44.enabled]) !== false && debouncedQuery.length > 0
+    enabled: options?.enabled !== false && debouncedQuery.length > 0
   });
 }
 
 // src/react/hooks/use-cart.ts
-
-
+var import_react5 = require("react");
+var import_react_query11 = require("@tanstack/react-query");
 var CART_KEY = ["behio", "cart"];
 function useCart(options) {
   const { client, storage } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const queryClient = (0, import_react_query11.useQueryClient)();
   const {
     data: cart,
     isLoading,
     error
-  } = _reactquery.useQuery.call(void 0, {
+  } = (0, import_react_query11.useQuery)({
     queryKey: [...CART_KEY],
     queryFn: () => unwrap(client.cart.get()),
     // Only fetch if we have a cart session or are logged in
-    enabled: _optionalChain([options, 'optionalAccess', _45 => _45.enabled]) !== false && (!!client.getCartSession() || !!client.getAccessToken())
+    enabled: options?.enabled !== false && (!!client.getCartSession() || !!client.getAccessToken())
   });
-  const addMutation = _reactquery.useMutation.call(void 0, {
+  const addMutation = (0, import_react_query11.useMutation)({
     mutationFn: async ({ productId, quantity }) => {
-      return unwrap(client.cart.addItem({ productId, quantity: _nullishCoalesce(quantity, () => ( 1)) }));
+      return unwrap(client.cart.addItem({ productId, quantity: quantity ?? 1 }));
     },
     onSuccess: (result) => {
       if (result.newSessionToken) {
@@ -456,7 +2241,7 @@ function useCart(options) {
       queryClient.setQueryData([...CART_KEY], result);
     }
   });
-  const updateMutation = _reactquery.useMutation.call(void 0, {
+  const updateMutation = (0, import_react_query11.useMutation)({
     mutationFn: async ({ itemId, quantity }) => {
       return unwrap(client.cart.updateQuantity(itemId, quantity));
     },
@@ -476,7 +2261,7 @@ function useCart(options) {
       return { previous };
     },
     onError: (_err, _vars, context) => {
-      if (_optionalChain([context, 'optionalAccess', _46 => _46.previous])) {
+      if (context?.previous) {
         queryClient.setQueryData([...CART_KEY], context.previous);
       }
     },
@@ -484,7 +2269,7 @@ function useCart(options) {
       queryClient.invalidateQueries({ queryKey: [...CART_KEY] });
     }
   });
-  const removeMutation = _reactquery.useMutation.call(void 0, {
+  const removeMutation = (0, import_react_query11.useMutation)({
     mutationFn: async (itemId) => {
       return unwrap(client.cart.removeItem(itemId));
     },
@@ -502,7 +2287,7 @@ function useCart(options) {
       return { previous };
     },
     onError: (_err, _vars, context) => {
-      if (_optionalChain([context, 'optionalAccess', _47 => _47.previous])) {
+      if (context?.previous) {
         queryClient.setQueryData([...CART_KEY], context.previous);
       }
     },
@@ -510,7 +2295,7 @@ function useCart(options) {
       queryClient.invalidateQueries({ queryKey: [...CART_KEY] });
     }
   });
-  const clearMutation = _reactquery.useMutation.call(void 0, {
+  const clearMutation = (0, import_react_query11.useMutation)({
     mutationFn: () => unwrap(client.cart.clear()),
     onSuccess: () => {
       queryClient.setQueryData([...CART_KEY], null);
@@ -518,19 +2303,19 @@ function useCart(options) {
       storage.remove(STORAGE_KEYS.CART_SESSION);
     }
   });
-  const applyDiscountMutation = _reactquery.useMutation.call(void 0, {
+  const applyDiscountMutation = (0, import_react_query11.useMutation)({
     mutationFn: (code) => unwrap(client.cart.applyDiscount(code)),
     onSuccess: (result) => {
       queryClient.setQueryData([...CART_KEY], result);
     }
   });
-  const removeDiscountMutation = _reactquery.useMutation.call(void 0, {
+  const removeDiscountMutation = (0, import_react_query11.useMutation)({
     mutationFn: () => unwrap(client.cart.removeDiscount()),
     onSuccess: (result) => {
       queryClient.setQueryData([...CART_KEY], result);
     }
   });
-  const mergeMutation = _reactquery.useMutation.call(void 0, {
+  const mergeMutation = (0, import_react_query11.useMutation)({
     mutationFn: () => unwrap(client.cart.merge()),
     onSuccess: (result) => {
       queryClient.setQueryData([...CART_KEY], result);
@@ -538,36 +2323,36 @@ function useCart(options) {
       storage.remove(STORAGE_KEYS.CART_SESSION);
     }
   });
-  const addItem = _react.useCallback.call(void 0, 
+  const addItem = (0, import_react5.useCallback)(
     (productId, quantity) => addMutation.mutateAsync({ productId, quantity }),
     [addMutation]
   );
-  const updateQuantity = _react.useCallback.call(void 0, 
+  const updateQuantity = (0, import_react5.useCallback)(
     (itemId, quantity) => updateMutation.mutateAsync({ itemId, quantity }),
     [updateMutation]
   );
-  const removeItem = _react.useCallback.call(void 0, 
+  const removeItem = (0, import_react5.useCallback)(
     (itemId) => removeMutation.mutateAsync(itemId),
     [removeMutation]
   );
-  const clear = _react.useCallback.call(void 0, 
+  const clear = (0, import_react5.useCallback)(
     () => clearMutation.mutateAsync(),
     [clearMutation]
   );
-  const applyDiscount = _react.useCallback.call(void 0, 
+  const applyDiscount = (0, import_react5.useCallback)(
     (code) => applyDiscountMutation.mutateAsync(code),
     [applyDiscountMutation]
   );
-  const removeDiscount = _react.useCallback.call(void 0, 
+  const removeDiscount = (0, import_react5.useCallback)(
     () => removeDiscountMutation.mutateAsync(),
     [removeDiscountMutation]
   );
-  const merge = _react.useCallback.call(void 0, 
+  const merge = (0, import_react5.useCallback)(
     () => mergeMutation.mutateAsync(),
     [mergeMutation]
   );
   return {
-    cart: _nullishCoalesce(cart, () => ( null)),
+    cart: cart ?? null,
     isLoading,
     error,
     // Actions
@@ -579,7 +2364,7 @@ function useCart(options) {
     removeDiscount,
     merge,
     // Computed
-    itemCount: _nullishCoalesce(_optionalChain([cart, 'optionalAccess', _48 => _48.itemCount]), () => ( 0)),
+    itemCount: cart?.itemCount ?? 0,
     isEmpty: !cart || cart.items.length === 0,
     // Mutation states
     isAdding: addMutation.isPending,
@@ -589,39 +2374,39 @@ function useCart(options) {
 }
 
 // src/react/hooks/use-cart-count.ts
-
+var import_react_query12 = require("@tanstack/react-query");
 var CART_KEY2 = ["behio", "cart"];
 function useCartCount(options) {
   const { client } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const queryClient = (0, import_react_query12.useQueryClient)();
   const cachedCart = queryClient.getQueryData([...CART_KEY2]);
-  const { data } = _reactquery.useQuery.call(void 0, {
+  const { data } = (0, import_react_query12.useQuery)({
     queryKey: [...CART_KEY2],
     queryFn: () => unwrap(client.cart.get()),
-    enabled: _optionalChain([options, 'optionalAccess', _49 => _49.enabled]) !== false && !cachedCart && (!!client.getCartSession() || !!client.getAccessToken())
+    enabled: options?.enabled !== false && !cachedCart && (!!client.getCartSession() || !!client.getAccessToken())
   });
-  const cart = _nullishCoalesce(cachedCart, () => ( data));
-  return _nullishCoalesce(_optionalChain([cart, 'optionalAccess', _50 => _50.itemCount]), () => ( 0));
+  const cart = cachedCart ?? data;
+  return cart?.itemCount ?? 0;
 }
 
 // src/react/hooks/use-auth.ts
-
-
+var import_react6 = require("react");
+var import_react_query13 = require("@tanstack/react-query");
 var CUSTOMER_KEY = ["behio", "customer"];
 var CART_KEY3 = ["behio", "cart"];
 function useAuth() {
   const { client, storage } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const queryClient = (0, import_react_query13.useQueryClient)();
   const isLoggedIn = !!client.getAccessToken();
   const {
     data: customer,
     isLoading
-  } = _reactquery.useQuery.call(void 0, {
+  } = (0, import_react_query13.useQuery)({
     queryKey: [...CUSTOMER_KEY],
     queryFn: () => unwrap(client.customer.getProfile()),
     enabled: isLoggedIn
   });
-  const persistTokens = _react.useCallback.call(void 0, 
+  const persistTokens = (0, import_react6.useCallback)(
     (tokens) => {
       client.setTokens(tokens);
       storage.set(STORAGE_KEYS.ACCESS_TOKEN, tokens.accessToken);
@@ -629,7 +2414,7 @@ function useAuth() {
     },
     [client, storage]
   );
-  const clearAuth = _react.useCallback.call(void 0, () => {
+  const clearAuth = (0, import_react6.useCallback)(() => {
     client.clearTokens();
     storage.remove(STORAGE_KEYS.ACCESS_TOKEN);
     storage.remove(STORAGE_KEYS.REFRESH_TOKEN);
@@ -637,19 +2422,19 @@ function useAuth() {
     queryClient.invalidateQueries({ queryKey: ["behio", "orders"] });
     queryClient.invalidateQueries({ queryKey: ["behio", "addresses"] });
   }, [client, storage, queryClient]);
-  const postAuth = _react.useCallback.call(void 0, async () => {
+  const postAuth = (0, import_react6.useCallback)(async () => {
     await queryClient.invalidateQueries({ queryKey: [...CUSTOMER_KEY] });
     if (client.getCartSession()) {
       try {
         await unwrap(client.cart.merge());
         client.clearCartSession();
         storage.remove(STORAGE_KEYS.CART_SESSION);
-      } catch (e5) {
+      } catch {
       }
     }
     queryClient.invalidateQueries({ queryKey: [...CART_KEY3] });
   }, [client, storage, queryClient]);
-  const loginMutation = _reactquery.useMutation.call(void 0, {
+  const loginMutation = (0, import_react_query13.useMutation)({
     mutationFn: async ({ email, password }) => {
       return unwrap(client.auth.login({ email, password }));
     },
@@ -658,7 +2443,7 @@ function useAuth() {
       await postAuth();
     }
   });
-  const registerMutation = _reactquery.useMutation.call(void 0, {
+  const registerMutation = (0, import_react_query13.useMutation)({
     mutationFn: async (input) => {
       return unwrap(client.auth.register(input));
     },
@@ -669,48 +2454,48 @@ function useAuth() {
       }
     }
   });
-  const logoutMutation = _reactquery.useMutation.call(void 0, {
+  const logoutMutation = (0, import_react_query13.useMutation)({
     mutationFn: () => unwrap(client.auth.logout()),
     onSettled: () => {
       clearAuth();
     }
   });
-  const forgotPasswordMutation = _reactquery.useMutation.call(void 0, {
+  const forgotPasswordMutation = (0, import_react_query13.useMutation)({
     mutationFn: (email) => unwrap(client.auth.forgotPassword(email))
   });
-  const resetPasswordMutation = _reactquery.useMutation.call(void 0, {
+  const resetPasswordMutation = (0, import_react_query13.useMutation)({
     mutationFn: ({ token, newPassword }) => unwrap(client.auth.resetPassword(token, newPassword))
   });
-  const verifyEmailMutation = _reactquery.useMutation.call(void 0, {
+  const verifyEmailMutation = (0, import_react_query13.useMutation)({
     mutationFn: (token) => unwrap(client.auth.verifyEmail(token))
   });
-  const login = _react.useCallback.call(void 0, 
+  const login = (0, import_react6.useCallback)(
     (email, password) => loginMutation.mutateAsync({ email, password }).then(() => void 0),
     [loginMutation]
   );
-  const register = _react.useCallback.call(void 0, 
+  const register = (0, import_react6.useCallback)(
     (input) => registerMutation.mutateAsync(input).then(() => void 0),
     [registerMutation]
   );
-  const logout = _react.useCallback.call(void 0, 
+  const logout = (0, import_react6.useCallback)(
     () => logoutMutation.mutateAsync().then(() => void 0),
     [logoutMutation]
   );
-  const forgotPassword = _react.useCallback.call(void 0, 
+  const forgotPassword = (0, import_react6.useCallback)(
     (email) => forgotPasswordMutation.mutateAsync(email).then(() => void 0),
     [forgotPasswordMutation]
   );
-  const resetPassword = _react.useCallback.call(void 0, 
+  const resetPassword = (0, import_react6.useCallback)(
     (token, newPassword) => resetPasswordMutation.mutateAsync({ token, newPassword }).then(() => void 0),
     [resetPasswordMutation]
   );
-  const verifyEmail = _react.useCallback.call(void 0, 
+  const verifyEmail = (0, import_react6.useCallback)(
     (token) => verifyEmailMutation.mutateAsync(token).then(() => void 0),
     [verifyEmailMutation]
   );
   return {
     isLoggedIn,
-    customer: _nullishCoalesce(customer, () => ( null)),
+    customer: customer ?? null,
     isLoading,
     // Actions
     login,
@@ -728,33 +2513,33 @@ function useAuth() {
 }
 
 // src/react/hooks/use-customer.ts
-
-
+var import_react7 = require("react");
+var import_react_query14 = require("@tanstack/react-query");
 var CUSTOMER_KEY2 = ["behio", "customer"];
 function useCustomer(options) {
   const { client } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const queryClient = (0, import_react_query14.useQueryClient)();
   const {
     data,
     isLoading,
     error
-  } = _reactquery.useQuery.call(void 0, {
+  } = (0, import_react_query14.useQuery)({
     queryKey: [...CUSTOMER_KEY2],
     queryFn: () => unwrap(client.customer.getProfile()),
-    enabled: _optionalChain([options, 'optionalAccess', _51 => _51.enabled]) !== false && !!client.getAccessToken()
+    enabled: options?.enabled !== false && !!client.getAccessToken()
   });
-  const updateMutation = _reactquery.useMutation.call(void 0, {
+  const updateMutation = (0, import_react_query14.useMutation)({
     mutationFn: (data2) => unwrap(client.customer.updateProfile(data2)),
     onSuccess: (updated) => {
       queryClient.setQueryData([...CUSTOMER_KEY2], updated);
     }
   });
-  const updateProfile = _react.useCallback.call(void 0, 
+  const updateProfile = (0, import_react7.useCallback)(
     (profileData) => updateMutation.mutateAsync(profileData),
     [updateMutation]
   );
   return {
-    data: _nullishCoalesce(data, () => ( null)),
+    data: data ?? null,
     isLoading,
     error,
     updateProfile,
@@ -763,56 +2548,56 @@ function useCustomer(options) {
 }
 
 // src/react/hooks/use-addresses.ts
-
-
+var import_react8 = require("react");
+var import_react_query15 = require("@tanstack/react-query");
 var ADDRESSES_KEY = ["behio", "addresses"];
 function useAddresses(options) {
   const { client } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const queryClient = (0, import_react_query15.useQueryClient)();
   const {
     data,
     isLoading,
     error
-  } = _reactquery.useQuery.call(void 0, {
+  } = (0, import_react_query15.useQuery)({
     queryKey: [...ADDRESSES_KEY],
     queryFn: async () => {
       const result = await unwrap(client.customer.getAddresses());
       return result.items;
     },
-    enabled: _optionalChain([options, 'optionalAccess', _52 => _52.enabled]) !== false && !!client.getAccessToken()
+    enabled: options?.enabled !== false && !!client.getAccessToken()
   });
-  const createMutation = _reactquery.useMutation.call(void 0, {
+  const createMutation = (0, import_react_query15.useMutation)({
     mutationFn: (address) => unwrap(client.customer.createAddress(address)),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: [...ADDRESSES_KEY] });
     }
   });
-  const updateMutation = _reactquery.useMutation.call(void 0, {
+  const updateMutation = (0, import_react_query15.useMutation)({
     mutationFn: ({ addressId, data: data2 }) => unwrap(client.customer.updateAddress(addressId, data2)),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: [...ADDRESSES_KEY] });
     }
   });
-  const deleteMutation = _reactquery.useMutation.call(void 0, {
+  const deleteMutation = (0, import_react_query15.useMutation)({
     mutationFn: (addressId) => unwrap(client.customer.deleteAddress(addressId)),
     onSuccess: () => {
       queryClient.invalidateQueries({ queryKey: [...ADDRESSES_KEY] });
     }
   });
-  const createAddress = _react.useCallback.call(void 0, 
+  const createAddress = (0, import_react8.useCallback)(
     (address) => createMutation.mutateAsync(address),
     [createMutation]
   );
-  const updateAddress = _react.useCallback.call(void 0, 
+  const updateAddress = (0, import_react8.useCallback)(
     (addressId, addressData) => updateMutation.mutateAsync({ addressId, data: addressData }),
     [updateMutation]
   );
-  const deleteAddress = _react.useCallback.call(void 0, 
+  const deleteAddress = (0, import_react8.useCallback)(
     (addressId) => deleteMutation.mutateAsync(addressId),
     [deleteMutation]
   );
   return {
-    addresses: _nullishCoalesce(data, () => ( [])),
+    addresses: data ?? [],
     isLoading,
     error,
     createAddress,
@@ -824,18 +2609,18 @@ function useAddresses(options) {
 }
 
 // src/react/hooks/use-address-autocomplete.ts
-
-
+var import_react9 = require("react");
+var import_react_query16 = require("@tanstack/react-query");
 var AC_KEY = ["behio", "address-autocomplete"];
 function useAddressAutocomplete(options) {
   const { country, debounce = 300, minChars = 3, enabled = true } = options;
   const { client } = useBehio();
-  const [query, setQuery] = _react.useState.call(void 0, "");
-  const [debouncedQuery, setDebouncedQuery] = _react.useState.call(void 0, "");
-  const [selected, setSelected] = _react.useState.call(void 0, null);
-  const [isSelecting, setIsSelecting] = _react.useState.call(void 0, false);
-  const timerRef = _react.useRef.call(void 0, void 0);
-  _react.useEffect.call(void 0, () => {
+  const [query, setQuery] = (0, import_react9.useState)("");
+  const [debouncedQuery, setDebouncedQuery] = (0, import_react9.useState)("");
+  const [selected, setSelected] = (0, import_react9.useState)(null);
+  const [isSelecting, setIsSelecting] = (0, import_react9.useState)(false);
+  const timerRef = (0, import_react9.useRef)(void 0);
+  (0, import_react9.useEffect)(() => {
     if (timerRef.current) clearTimeout(timerRef.current);
     if (query.length < minChars) {
       setDebouncedQuery("");
@@ -848,14 +2633,14 @@ function useAddressAutocomplete(options) {
       if (timerRef.current) clearTimeout(timerRef.current);
     };
   }, [query, debounce, minChars]);
-  const { data, isLoading } = _reactquery.useQuery.call(void 0, {
+  const { data, isLoading } = (0, import_react_query16.useQuery)({
     queryKey: [...AC_KEY, debouncedQuery, country],
     queryFn: () => unwrap(client.addresses.autocomplete(debouncedQuery, country)),
     enabled: enabled && debouncedQuery.length >= minChars,
     staleTime: 6e4
     // Cache suggestions for 1 min
   });
-  const select = _react.useCallback.call(void 0, 
+  const select = (0, import_react9.useCallback)(
     async (placeId) => {
       setIsSelecting(true);
       try {
@@ -870,7 +2655,7 @@ function useAddressAutocomplete(options) {
     },
     [client]
   );
-  const clear = _react.useCallback.call(void 0, () => {
+  const clear = (0, import_react9.useCallback)(() => {
     setQuery("");
     setDebouncedQuery("");
     setSelected(null);
@@ -878,7 +2663,7 @@ function useAddressAutocomplete(options) {
   return {
     query,
     setQuery,
-    suggestions: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _53 => _53.suggestions]), () => ( [])),
+    suggestions: data?.suggestions ?? [],
     isLoading: isLoading && debouncedQuery.length >= minChars,
     select,
     selected,
@@ -888,39 +2673,39 @@ function useAddressAutocomplete(options) {
 }
 
 // src/react/hooks/use-loyalty.ts
-
+var import_react_query17 = require("@tanstack/react-query");
 var LOYALTY_KEY = ["behio", "loyalty"];
 function useLoyalty(options) {
   const { client } = useBehio();
-  const { data, isLoading, error, refetch } = _reactquery.useQuery.call(void 0, {
+  const { data, isLoading, error, refetch } = (0, import_react_query17.useQuery)({
     queryKey: [...LOYALTY_KEY],
     queryFn: () => unwrap(client.customer.getLoyalty()),
-    enabled: _optionalChain([options, 'optionalAccess', _54 => _54.enabled]) !== false && !!client.getAccessToken()
+    enabled: options?.enabled !== false && !!client.getAccessToken()
   });
   return { loyalty: data, isLoading, error, refetch };
 }
 
 // src/react/hooks/use-courses.ts
-
+var import_react_query18 = require("@tanstack/react-query");
 var COURSES_KEY = ["behio", "courses"];
 function useCourses(options) {
   const { client } = useBehio();
-  const { data, isLoading, error, refetch } = _reactquery.useQuery.call(void 0, {
+  const { data, isLoading, error, refetch } = (0, import_react_query18.useQuery)({
     queryKey: [...COURSES_KEY],
     queryFn: () => unwrap(client.customer.getCourses()),
-    enabled: _optionalChain([options, 'optionalAccess', _55 => _55.enabled]) !== false && !!client.getAccessToken()
+    enabled: options?.enabled !== false && !!client.getAccessToken()
   });
-  return { courses: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _56 => _56.items]), () => ( [])), isLoading, error, refetch };
+  return { courses: data?.items ?? [], isLoading, error, refetch };
 }
 function useCourse(courseId, options) {
   const { client } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
-  const { data, isLoading, error, refetch } = _reactquery.useQuery.call(void 0, {
+  const queryClient = (0, import_react_query18.useQueryClient)();
+  const { data, isLoading, error, refetch } = (0, import_react_query18.useQuery)({
     queryKey: [...COURSES_KEY, courseId],
     queryFn: () => unwrap(client.customer.getCourse(courseId)),
-    enabled: _optionalChain([options, 'optionalAccess', _57 => _57.enabled]) !== false && !!courseId && !!client.getAccessToken()
+    enabled: options?.enabled !== false && !!courseId && !!client.getAccessToken()
   });
-  const complete = _reactquery.useMutation.call(void 0, {
+  const complete = (0, import_react_query18.useMutation)({
     mutationFn: ({ lessonId }) => unwrap(client.customer.completeLesson(courseId, lessonId)),
     onSuccess: () => {
       void queryClient.invalidateQueries({ queryKey: [...COURSES_KEY] });
@@ -935,33 +2720,238 @@ function useCourse(courseId, options) {
     isCompleting: complete.isPending
   };
 }
+function useLessonQuiz(courseId, lessonId, options) {
+  const { client } = useBehio();
+  const queryClient = (0, import_react_query18.useQueryClient)();
+  const { data, isLoading, error, refetch } = (0, import_react_query18.useQuery)({
+    queryKey: [...COURSES_KEY, courseId, "quiz", lessonId],
+    queryFn: () => unwrap(
+      client.customer.getLessonQuiz(courseId, lessonId)
+    ),
+    enabled: options?.enabled !== false && !!courseId && !!lessonId && !!client.getAccessToken()
+  });
+  const submit = (0, import_react_query18.useMutation)(
+    {
+      mutationFn: ({ answers }) => unwrap(
+        client.customer.submitLessonQuiz(
+          courseId,
+          lessonId,
+          answers
+        )
+      ),
+      onSuccess: (result) => {
+        if (result.lessonCompleted) {
+          void queryClient.invalidateQueries({ queryKey: [...COURSES_KEY] });
+        }
+      }
+    }
+  );
+  return {
+    quiz: data,
+    isLoading,
+    error,
+    refetch,
+    submitQuiz: (answers) => submit.mutateAsync({ answers }),
+    isSubmitting: submit.isPending,
+    result: submit.data ?? null
+  };
+}
+function useCourseCertificates(options) {
+  const { client } = useBehio();
+  const { data, isLoading, error, refetch } = (0, import_react_query18.useQuery)({
+    queryKey: [...COURSES_KEY, "certificates"],
+    queryFn: () => unwrap(client.customer.getCourseCertificates()),
+    enabled: options?.enabled !== false && !!client.getAccessToken()
+  });
+  return { certificates: data?.items ?? [], isLoading, error, refetch };
+}
+function useCertificateVerification(code, options) {
+  const { client } = useBehio();
+  const { data, isLoading, error, refetch } = (0, import_react_query18.useQuery)(
+    {
+      queryKey: ["behio", "certificate-verification", code],
+      queryFn: () => unwrap(client.certificates.verify(code)),
+      enabled: options?.enabled !== false && !!code,
+      retry: false
+    }
+  );
+  return { verification: data ?? null, isLoading, error, refetch };
+}
+
+// src/react/hooks/use-lesson-tutor.ts
+var import_react_query19 = require("@tanstack/react-query");
+var TUTOR_KEY = ["behio", "course-tutor"];
+function useLessonTutor(courseId, lessonId, options) {
+  const { client } = useBehio();
+  const queryClient = (0, import_react_query19.useQueryClient)();
+  const { data, isLoading, error, refetch } = (0, import_react_query19.useQuery)({
+    queryKey: [...TUTOR_KEY, courseId, lessonId],
+    queryFn: () => unwrap(
+      client.customer.getLessonTutorThread(
+        courseId,
+        lessonId
+      )
+    ),
+    enabled: options?.enabled !== false && !!courseId && !!lessonId && !!client.getAccessToken()
+  });
+  const ask = (0, import_react_query19.useMutation)({
+    mutationFn: ({ question }) => unwrap(
+      client.customer.askLessonTutor(
+        courseId,
+        lessonId,
+        question
+      )
+    ),
+    onSuccess: (message) => {
+      queryClient.setQueryData(
+        [...TUTOR_KEY, courseId, lessonId],
+        (prev) => prev ? { ...prev, items: [...prev.items, message] } : prev
+      );
+    }
+  });
+  return {
+    messages: data?.items ?? [],
+    /** False when the merchant disabled the AI tutor — hide the widget. */
+    enabled: data?.enabled ?? true,
+    isLoading,
+    error,
+    refetch,
+    ask: (question) => ask.mutateAsync({ question }),
+    isAsking: ask.isPending,
+    askError: ask.error
+  };
+}
 
-// src/react/hooks/use-subscriptions.ts
+// src/react/hooks/use-lesson-comments.ts
+var import_react_query20 = require("@tanstack/react-query");
+var COMMENTS_KEY = ["behio", "course-comments"];
+function useLessonComments(courseId, lessonId, options) {
+  const { client } = useBehio();
+  const queryClient = (0, import_react_query20.useQueryClient)();
+  const page = options?.page ?? 1;
+  const { data, isLoading, error, refetch } = (0, import_react_query20.useQuery)({
+    queryKey: [...COMMENTS_KEY, courseId, lessonId, page],
+    queryFn: () => unwrap(
+      client.customer.getLessonComments(
+        courseId,
+        lessonId,
+        page
+      )
+    ),
+    enabled: options?.enabled !== false && !!courseId && !!lessonId && !!client.getAccessToken()
+  });
+  const invalidate = () => queryClient.invalidateQueries({
+    queryKey: [...COMMENTS_KEY, courseId, lessonId]
+  });
+  const post = (0, import_react_query20.useMutation)({
+    mutationFn: ({ body, parentId }) => unwrap(
+      client.customer.postLessonComment(
+        courseId,
+        lessonId,
+        body,
+        parentId
+      )
+    ),
+    onSuccess: () => {
+      void invalidate();
+    }
+  });
+  const remove = (0, import_react_query20.useMutation)({
+    mutationFn: ({ commentId }) => unwrap(
+      client.customer.deleteLessonComment(
+        courseId,
+        lessonId,
+        commentId
+      )
+    ),
+    onSuccess: () => {
+      void invalidate();
+    }
+  });
+  return {
+    comments: data?.items ?? [],
+    totalCount: data?.totalCount ?? 0,
+    page: data?.page ?? page,
+    pageSize: data?.pageSize ?? 20,
+    /** False when the merchant disabled the discussion — hide the widget. */
+    enabled: data?.enabled ?? true,
+    isLoading,
+    error,
+    refetch,
+    postComment: (body, parentId) => post.mutateAsync({ body, parentId }),
+    isPosting: post.isPending,
+    deleteComment: (commentId) => remove.mutateAsync({ commentId }),
+    isDeleting: remove.isPending
+  };
+}
+
+// src/react/hooks/use-lesson-note.ts
+var import_react_query21 = require("@tanstack/react-query");
+var NOTE_KEY = ["behio", "course-note"];
+function useLessonNote(courseId, lessonId, options) {
+  const { client } = useBehio();
+  const queryClient = (0, import_react_query21.useQueryClient)();
+  const { data, isLoading, error, refetch } = (0, import_react_query21.useQuery)({
+    queryKey: [...NOTE_KEY, courseId, lessonId],
+    queryFn: () => unwrap(
+      client.customer.getLessonNote(courseId, lessonId)
+    ),
+    enabled: options?.enabled !== false && !!courseId && !!lessonId && !!client.getAccessToken()
+  });
+  const save = (0, import_react_query21.useMutation)({
+    mutationFn: ({ body }) => unwrap(
+      client.customer.saveLessonNote(
+        courseId,
+        lessonId,
+        body
+      )
+    ),
+    onSuccess: (note) => {
+      queryClient.setQueryData(
+        [...NOTE_KEY, courseId, lessonId],
+        note
+      );
+    }
+  });
+  return {
+    note: data ?? null,
+    body: data?.body ?? "",
+    updatedAt: data?.updatedAt ?? null,
+    isLoading,
+    error,
+    refetch,
+    save: (body) => save.mutateAsync({ body }),
+    isSaving: save.isPending,
+    saveError: save.error
+  };
+}
 
+// src/react/hooks/use-subscriptions.ts
+var import_react_query22 = require("@tanstack/react-query");
 var SUBSCRIPTIONS_KEY = ["behio", "subscriptions"];
 function useSubscriptions(options) {
   const { client } = useBehio();
-  const qc = _reactquery.useQueryClient.call(void 0, );
-  const query = _reactquery.useQuery.call(void 0, {
+  const qc = (0, import_react_query22.useQueryClient)();
+  const query = (0, import_react_query22.useQuery)({
     queryKey: [...SUBSCRIPTIONS_KEY],
     queryFn: () => unwrap(client.subscriptions.list()),
-    enabled: _optionalChain([options, 'optionalAccess', _58 => _58.enabled]) !== false && !!client.getAccessToken()
+    enabled: options?.enabled !== false && !!client.getAccessToken()
   });
   const invalidate = () => qc.invalidateQueries({ queryKey: [...SUBSCRIPTIONS_KEY] });
-  const pauseMutation = _reactquery.useMutation.call(void 0, {
+  const pauseMutation = (0, import_react_query22.useMutation)({
     mutationFn: (subscriptionId) => unwrap(client.subscriptions.pause(subscriptionId)),
     onSuccess: invalidate
   });
-  const resumeMutation = _reactquery.useMutation.call(void 0, {
+  const resumeMutation = (0, import_react_query22.useMutation)({
     mutationFn: (subscriptionId) => unwrap(client.subscriptions.resume(subscriptionId)),
     onSuccess: invalidate
   });
-  const cancelMutation = _reactquery.useMutation.call(void 0, {
+  const cancelMutation = (0, import_react_query22.useMutation)({
     mutationFn: (subscriptionId) => unwrap(client.subscriptions.cancel(subscriptionId)),
     onSuccess: invalidate
   });
   return {
-    subscriptions: _nullishCoalesce(_optionalChain([query, 'access', _59 => _59.data, 'optionalAccess', _60 => _60.items]), () => ( [])),
+    subscriptions: query.data?.items ?? [],
     isLoading: query.isLoading,
     error: query.error,
     refetch: query.refetch,
@@ -975,12 +2965,12 @@ function useSubscriptions(options) {
 }
 
 // src/react/hooks/use-pickup-points.ts
-
+var import_react_query23 = require("@tanstack/react-query");
 function usePickupPoints(input) {
   const { client } = useBehio();
   const { methodId, query, country, limit, enabled } = input;
-  const { data, isLoading, error, refetch } = _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "pickup-points", methodId, _nullishCoalesce(query, () => ( "")), _nullishCoalesce(country, () => ( "")), _nullishCoalesce(limit, () => ( 30))],
+  const { data, isLoading, error, refetch } = (0, import_react_query23.useQuery)({
+    queryKey: ["behio", "pickup-points", methodId, query ?? "", country ?? "", limit ?? 30],
     queryFn: () => unwrap(
       client.shipping.getPickupPoints({
         methodId,
@@ -991,44 +2981,44 @@ function usePickupPoints(input) {
     ),
     enabled: enabled !== false && !!methodId
   });
-  return { pickupPoints: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _61 => _61.items]), () => ( [])), isLoading, error, refetch };
+  return { pickupPoints: data?.items ?? [], isLoading, error, refetch };
 }
 
 // src/react/hooks/use-shipping-methods.ts
-
+var import_react_query24 = require("@tanstack/react-query");
 function useShippingMethods(options) {
   const { client, currency: activeCurrency } = useBehio();
-  const currency = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _62 => _62.currency]), () => ( activeCurrency));
-  const { country, cartTotal, cartWeightKg } = _nullishCoalesce(options, () => ( {}));
-  const { data, isLoading, error, refetch } = _reactquery.useQuery.call(void 0, {
+  const currency = options?.currency ?? activeCurrency;
+  const { country, cartTotal, cartWeightKg } = options ?? {};
+  const { data, isLoading, error, refetch } = (0, import_react_query24.useQuery)({
     queryKey: [
       "behio",
       "shipping-methods",
-      _nullishCoalesce(currency, () => ( "")),
-      _nullishCoalesce(country, () => ( "")),
-      _nullishCoalesce(cartTotal, () => ( "")),
-      _nullishCoalesce(cartWeightKg, () => ( ""))
+      currency ?? "",
+      country ?? "",
+      cartTotal ?? "",
+      cartWeightKg ?? ""
     ],
     queryFn: () => unwrap(client.shipping.listMethods({ currency, country, cartTotal, cartWeightKg })),
-    enabled: _optionalChain([options, 'optionalAccess', _63 => _63.enabled]) !== false
+    enabled: options?.enabled !== false
   });
-  return { methods: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _64 => _64.items]), () => ( [])), isLoading, error, refetch };
+  return { methods: data?.items ?? [], isLoading, error, refetch };
 }
 
 // src/react/hooks/use-shipping-quote.ts
-
+var import_react_query25 = require("@tanstack/react-query");
 function useShippingQuote(options) {
   const { client, currency: activeCurrency } = useBehio();
-  const { destinationAddress, items, cartTotal, enabled } = _nullishCoalesce(options, () => ( {}));
-  const currency = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _65 => _65.currency]), () => ( activeCurrency));
-  const { data, isLoading, error, refetch } = _reactquery.useQuery.call(void 0, {
+  const { destinationAddress, items, cartTotal, enabled } = options ?? {};
+  const currency = options?.currency ?? activeCurrency;
+  const { data, isLoading, error, refetch } = (0, import_react_query25.useQuery)({
     queryKey: [
       "behio",
       "shipping-quote",
-      JSON.stringify(_nullishCoalesce(destinationAddress, () => ( null))),
-      JSON.stringify(_nullishCoalesce(items, () => ( null))),
-      _nullishCoalesce(cartTotal, () => ( "")),
-      _nullishCoalesce(currency, () => ( ""))
+      JSON.stringify(destinationAddress ?? null),
+      JSON.stringify(items ?? null),
+      cartTotal ?? "",
+      currency ?? ""
     ],
     queryFn: () => unwrap(
       client.shipping.quote({
@@ -1038,33 +3028,33 @@ function useShippingQuote(options) {
         currency
       })
     ),
-    enabled: enabled !== false && !!_optionalChain([destinationAddress, 'optionalAccess', _66 => _66.country])
+    enabled: enabled !== false && !!destinationAddress?.country
   });
-  return { quotes: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _67 => _67.items]), () => ( [])), isLoading, error, refetch };
+  return { quotes: data?.items ?? [], isLoading, error, refetch };
 }
 
 // src/react/hooks/use-payment-methods.ts
-
+var import_react_query26 = require("@tanstack/react-query");
 function usePaymentMethods(options) {
   const { client, currency: activeCurrency } = useBehio();
-  const currency = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _68 => _68.currency]), () => ( activeCurrency));
-  const { data, isLoading, error, refetch } = _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "payment-methods", _nullishCoalesce(currency, () => ( ""))],
+  const currency = options?.currency ?? activeCurrency;
+  const { data, isLoading, error, refetch } = (0, import_react_query26.useQuery)({
+    queryKey: ["behio", "payment-methods", currency ?? ""],
     queryFn: () => unwrap(client.catalog.listPaymentMethods({ currency })),
-    enabled: _optionalChain([options, 'optionalAccess', _69 => _69.enabled]) !== false
+    enabled: options?.enabled !== false
   });
-  return { methods: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _70 => _70.items]), () => ( [])), isLoading, error, refetch };
+  return { methods: data?.items ?? [], isLoading, error, refetch };
 }
 
 // src/react/hooks/use-personal-offers.ts
-
-
+var import_react10 = require("react");
+var import_react_query27 = require("@tanstack/react-query");
 function usePersonalOffers(options) {
   const { client } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
-  const [polledVid, setPolledVid] = _react.useState.call(void 0, null);
-  const explicitVid = _optionalChain([options, 'optionalAccess', _71 => _71.visitorId]);
-  _react.useEffect.call(void 0, () => {
+  const queryClient = (0, import_react_query27.useQueryClient)();
+  const [polledVid, setPolledVid] = (0, import_react10.useState)(null);
+  const explicitVid = options?.visitorId;
+  (0, import_react10.useEffect)(() => {
     if (explicitVid) return;
     const read = () => {
       const vid = client.getAnalyticsVisitorId();
@@ -1077,14 +3067,14 @@ function usePersonalOffers(options) {
     }, 3e3);
     return () => clearInterval(timer);
   }, [client, explicitVid]);
-  const visitorId = _nullishCoalesce(explicitVid, () => ( polledVid));
-  const queryKey = ["behio", "personal-offers", _nullishCoalesce(visitorId, () => ( ""))];
-  const { data, isLoading, error, refetch } = _reactquery.useQuery.call(void 0, {
+  const visitorId = explicitVid ?? polledVid;
+  const queryKey = ["behio", "personal-offers", visitorId ?? ""];
+  const { data, isLoading, error, refetch } = (0, import_react_query27.useQuery)({
     queryKey,
     queryFn: () => unwrap(client.getPersonalOffers(visitorId)),
-    enabled: _optionalChain([options, 'optionalAccess', _72 => _72.enabled]) !== false && !!visitorId
+    enabled: options?.enabled !== false && !!visitorId
   });
-  const claimMutation = _reactquery.useMutation.call(void 0, {
+  const claimMutation = (0, import_react_query27.useMutation)({
     mutationFn: ({ offerId, email }) => unwrap(client.claimOfferByEmail(offerId, { visitorId, email })),
     onSuccess: (result, { offerId }) => {
       queryClient.setQueryData(
@@ -1097,14 +3087,14 @@ function usePersonalOffers(options) {
       );
     }
   });
-  const claimByEmail = _react.useCallback.call(void 0, 
+  const claimByEmail = (0, import_react10.useCallback)(
     (offerId, email) => claimMutation.mutateAsync({ offerId, email }),
     [claimMutation]
   );
   return {
-    offers: _nullishCoalesce(_optionalChain([data, 'optionalAccess', _73 => _73.items]), () => ( [])),
+    offers: data?.items ?? [],
     /** Resolved consent-gated visitor id (null before consent). */
-    visitorId: _nullishCoalesce(visitorId, () => ( null)),
+    visitorId: visitorId ?? null,
     isLoading,
     error,
     refetch,
@@ -1116,22 +3106,22 @@ function usePersonalOffers(options) {
 }
 
 // src/react/hooks/use-analytics-events.ts
-
+var import_react11 = require("react");
 function useAnalyticsEvents() {
   const { client } = useBehio();
-  const track = _react.useCallback.call(void 0, 
+  const track = (0, import_react11.useCallback)(
     (events, opts) => {
       const list = Array.isArray(events) ? events : [events];
       if (list.length === 0) return Promise.resolve();
       return client.sendAnalyticsEvents({
-        sessionId: _optionalChain([opts, 'optionalAccess', _74 => _74.sessionId]),
-        visitorId: _nullishCoalesce(client.getAnalyticsVisitorId(), () => ( void 0)),
+        sessionId: opts?.sessionId,
+        visitorId: client.getAnalyticsVisitorId() ?? void 0,
         events: list.map((e) => ({ ts: Date.now(), ...e }))
       });
     },
     [client]
   );
-  const trackEvent = _react.useCallback.call(void 0, 
+  const trackEvent = (0, import_react11.useCallback)(
     (name, props) => track({ type: "custom", name, props }),
     [track]
   );
@@ -1146,28 +3136,28 @@ function useAnalyticsEvents() {
 }
 
 // src/react/hooks/use-newsletter.ts
-
+var import_react_query28 = require("@tanstack/react-query");
 function useNewsletterSubscribe() {
   const { client } = useBehio();
-  return _reactquery.useMutation.call(void 0, {
+  return (0, import_react_query28.useMutation)({
     mutationFn: (input) => unwrap(client.newsletter.subscribe(input))
   });
 }
 function useNewsletterUnsubscribe() {
   const { client } = useBehio();
-  return _reactquery.useMutation.call(void 0, {
+  return (0, import_react_query28.useMutation)({
     mutationFn: (email) => unwrap(client.newsletter.unsubscribe(email))
   });
 }
 
 // src/react/hooks/use-orders.ts
-
-
+var import_react12 = require("react");
+var import_react_query29 = require("@tanstack/react-query");
 function useOrders(options) {
   const { client } = useBehio();
-  const { page: initialPage, limit, enabled } = _nullishCoalesce(options, () => ( {}));
-  const [page, setPage] = _react.useState.call(void 0, _nullishCoalesce(initialPage, () => ( 1)));
-  const infinite = _reactquery.useInfiniteQuery.call(void 0, {
+  const { page: initialPage, limit, enabled } = options ?? {};
+  const [page, setPage] = (0, import_react12.useState)(initialPage ?? 1);
+  const infinite = (0, import_react_query29.useInfiniteQuery)({
     queryKey: ["behio", "orders", limit, page],
     queryFn: ({ pageParam }) => unwrap(client.orders.list({ limit, page: pageParam })),
     initialPageParam: page,
@@ -1175,33 +3165,33 @@ function useOrders(options) {
     getPreviousPageParam: (firstPage) => firstPage.page > 1 ? firstPage.page - 1 : void 0,
     enabled: enabled !== false && !!client.getAccessToken()
   });
-  const items = _react.useMemo.call(void 0, 
-    () => _nullishCoalesce(_optionalChain([infinite, 'access', _75 => _75.data, 'optionalAccess', _76 => _76.pages, 'access', _77 => _77.flatMap, 'call', _78 => _78((p) => p.items)]), () => ( [])),
+  const items = (0, import_react12.useMemo)(
+    () => infinite.data?.pages.flatMap((p) => p.items) ?? [],
     [infinite.data]
   );
-  const lastPage = _optionalChain([infinite, 'access', _79 => _79.data, 'optionalAccess', _80 => _80.pages, 'access', _81 => _81[infinite.data.pages.length - 1]]);
-  const loadMore = _react.useCallback.call(void 0, () => {
+  const lastPage = infinite.data?.pages[infinite.data.pages.length - 1];
+  const loadMore = (0, import_react12.useCallback)(() => {
     if (infinite.hasNextPage && !infinite.isFetchingNextPage) {
       return infinite.fetchNextPage();
     }
     return Promise.resolve();
   }, [infinite]);
-  const goToPage = _react.useCallback.call(void 0, (newPage) => {
+  const goToPage = (0, import_react12.useCallback)((newPage) => {
     setPage(newPage);
   }, []);
   return {
     items,
     data: infinite.data,
-    total: _nullishCoalesce(_optionalChain([lastPage, 'optionalAccess', _82 => _82.total]), () => ( 0)),
-    totalPages: _nullishCoalesce(_optionalChain([lastPage, 'optionalAccess', _83 => _83.totalPages]), () => ( 0)),
-    currentPage: _nullishCoalesce(_optionalChain([lastPage, 'optionalAccess', _84 => _84.page]), () => ( page)),
-    limit: _nullishCoalesce(_nullishCoalesce(_optionalChain([lastPage, 'optionalAccess', _85 => _85.limit]), () => ( limit)), () => ( 20)),
+    total: lastPage?.total ?? 0,
+    totalPages: lastPage?.totalPages ?? 0,
+    currentPage: lastPage?.page ?? page,
+    limit: lastPage?.limit ?? limit ?? 20,
     page,
     setPage: goToPage,
     loadMore,
     loadPrevious: infinite.fetchPreviousPage,
-    hasMore: _nullishCoalesce(infinite.hasNextPage, () => ( false)),
-    hasPrevious: _nullishCoalesce(infinite.hasPreviousPage, () => ( false)),
+    hasMore: infinite.hasNextPage ?? false,
+    hasPrevious: infinite.hasPreviousPage ?? false,
     isLoading: infinite.isLoading,
     isFetching: infinite.isFetching,
     isLoadingMore: infinite.isFetchingNextPage,
@@ -1212,33 +3202,33 @@ function useOrders(options) {
 }
 
 // src/react/hooks/use-order.ts
-
-
+var import_react13 = require("react");
+var import_react_query30 = require("@tanstack/react-query");
 function useOrder(orderNumber, options) {
   const { client } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
+  const queryClient = (0, import_react_query30.useQueryClient)();
   const {
     data,
     isLoading,
     error
-  } = _reactquery.useQuery.call(void 0, {
+  } = (0, import_react_query30.useQuery)({
     queryKey: ["behio", "order", orderNumber],
     queryFn: () => unwrap(client.orders.get(orderNumber)),
-    enabled: _optionalChain([options, 'optionalAccess', _86 => _86.enabled]) !== false && !!orderNumber && !!client.getAccessToken()
+    enabled: options?.enabled !== false && !!orderNumber && !!client.getAccessToken()
   });
-  const cancelMutation = _reactquery.useMutation.call(void 0, {
+  const cancelMutation = (0, import_react_query30.useMutation)({
     mutationFn: () => unwrap(client.orders.cancel(orderNumber)),
     onSuccess: (updated) => {
       queryClient.setQueryData(["behio", "order", orderNumber], updated);
       queryClient.invalidateQueries({ queryKey: ["behio", "orders"] });
     }
   });
-  const cancel = _react.useCallback.call(void 0, 
+  const cancel = (0, import_react13.useCallback)(
     () => cancelMutation.mutateAsync(),
     [cancelMutation]
   );
   return {
-    data: _nullishCoalesce(data, () => ( null)),
+    data: data ?? null,
     isLoading,
     error,
     cancel,
@@ -1247,22 +3237,22 @@ function useOrder(orderNumber, options) {
 }
 
 // src/react/hooks/use-order-access.ts
-
-
+var import_react14 = require("react");
+var import_react_query31 = require("@tanstack/react-query");
 function useOrderAccess() {
   const { client } = useBehio();
-  const [orderNumber, setOrderNumber] = _react.useState.call(void 0, null);
-  const [email, setEmail] = _react.useState.call(void 0, null);
-  const [order, setOrder] = _react.useState.call(void 0, null);
-  const [accessToken, setAccessToken] = _react.useState.call(void 0, null);
-  const requestMutation = _reactquery.useMutation.call(void 0, {
+  const [orderNumber, setOrderNumber] = (0, import_react14.useState)(null);
+  const [email, setEmail] = (0, import_react14.useState)(null);
+  const [order, setOrder] = (0, import_react14.useState)(null);
+  const [accessToken, setAccessToken] = (0, import_react14.useState)(null);
+  const requestMutation = (0, import_react_query31.useMutation)({
     mutationFn: (input) => unwrap(client.orders.requestAccessCode(input.orderNumber, input.email)),
     onSuccess: (_data, input) => {
       setOrderNumber(input.orderNumber);
       setEmail(input.email);
     }
   });
-  const verifyMutation = _reactquery.useMutation.call(void 0, {
+  const verifyMutation = (0, import_react_query31.useMutation)({
     mutationFn: (code) => {
       if (!orderNumber || !email) {
         throw new Error("Request a code before verifying");
@@ -1274,12 +3264,12 @@ function useOrderAccess() {
       setAccessToken(result.accessToken);
     }
   });
-  const requestCode = _react.useCallback.call(void 0, 
+  const requestCode = (0, import_react14.useCallback)(
     (on, em) => requestMutation.mutateAsync({ orderNumber: on, email: em }),
     [requestMutation]
   );
-  const verifyCode = _react.useCallback.call(void 0, (code) => verifyMutation.mutateAsync(code), [verifyMutation]);
-  const reset = _react.useCallback.call(void 0, () => {
+  const verifyCode = (0, import_react14.useCallback)((code) => verifyMutation.mutateAsync(code), [verifyMutation]);
+  const reset = (0, import_react14.useCallback)(() => {
     setOrderNumber(null);
     setEmail(null);
     setOrder(null);
@@ -1307,13 +3297,13 @@ function useOrderAccess() {
 }
 
 // src/react/hooks/use-checkout.ts
-
-
+var import_react15 = require("react");
+var import_react_query32 = require("@tanstack/react-query");
 function useCheckout() {
   const { client, storage } = useBehio();
-  const queryClient = _reactquery.useQueryClient.call(void 0, );
-  const [order, setOrder] = _react.useState.call(void 0, null);
-  const mutation = _reactquery.useMutation.call(void 0, {
+  const queryClient = (0, import_react_query32.useQueryClient)();
+  const [order, setOrder] = (0, import_react15.useState)(null);
+  const mutation = (0, import_react_query32.useMutation)({
     mutationFn: (input) => unwrap(client.checkout.createOrder(input)),
     onSuccess: (result) => {
       setOrder(result);
@@ -1322,11 +3312,11 @@ function useCheckout() {
       queryClient.invalidateQueries({ queryKey: ["behio", "orders"] });
     }
   });
-  const createOrder = _react.useCallback.call(void 0, 
+  const createOrder = (0, import_react15.useCallback)(
     (input) => mutation.mutateAsync(input),
     [mutation]
   );
-  const reset = _react.useCallback.call(void 0, () => {
+  const reset = (0, import_react15.useCallback)(() => {
     setOrder(null);
     mutation.reset();
   }, [mutation]);
@@ -1340,56 +3330,56 @@ function useCheckout() {
 }
 
 // src/react/hooks/use-pages.ts
-
+var import_react_query33 = require("@tanstack/react-query");
 function usePages(locale, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query33.useQuery)({
     queryKey: ["behio", "pages", locale],
     queryFn: async () => {
       const result = await unwrap(client.pages.list(locale));
       return result.pages;
     },
-    enabled: _optionalChain([options, 'optionalAccess', _87 => _87.enabled]) !== false
+    enabled: options?.enabled !== false
   });
 }
 function usePage(slug, locale, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query33.useQuery)({
     queryKey: ["behio", "page", slug, locale],
     queryFn: () => unwrap(client.pages.get(slug, locale)),
-    enabled: _optionalChain([options, 'optionalAccess', _88 => _88.enabled]) !== false && !!slug
+    enabled: options?.enabled !== false && !!slug
   });
 }
 
 // src/react/hooks/use-shop-info.ts
-
+var import_react_query34 = require("@tanstack/react-query");
 function useShopInfo(options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query34.useQuery)({
     queryKey: ["behio", "shop-info"],
     queryFn: () => unwrap(client.getShopInfo()),
-    enabled: _optionalChain([options, 'optionalAccess', _89 => _89.enabled]) !== false
+    enabled: options?.enabled !== false
   });
 }
 
 // src/react/hooks/use-shop-scripts.ts
-
+var import_react_query35 = require("@tanstack/react-query");
 function useShopScripts(options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query35.useQuery)({
     queryKey: ["behio", "shop-scripts"],
     queryFn: () => unwrap(client.getShopScripts()),
-    enabled: _optionalChain([options, 'optionalAccess', _90 => _90.enabled]) !== false
+    enabled: options?.enabled !== false
   });
 }
 
 // src/react/hooks/use-shop-seo.ts
-
+var import_react_query36 = require("@tanstack/react-query");
 function useShopSeo(options) {
   const { client } = useBehio();
-  const { locale, initialData, enabled = true } = _nullishCoalesce(options, () => ( {}));
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "shop-seo", _nullishCoalesce(locale, () => ( "_default"))],
+  const { locale, initialData, enabled = true } = options ?? {};
+  return (0, import_react_query36.useQuery)({
+    queryKey: ["behio", "shop-seo", locale ?? "_default"],
     queryFn: () => unwrap(client.getShopSeo(locale)),
     initialData,
     enabled
@@ -1407,11 +3397,11 @@ function dedupe(values) {
 function useCurrency() {
   const { currency, setCurrency, configuredDefaultCurrency, configuredCurrencies } = useBehio();
   const { data: shop, isLoading } = useShopInfo();
-  const defaultCurrency = _nullishCoalesce(configuredDefaultCurrency, () => ( _optionalChain([shop, 'optionalAccess', _91 => _91.defaultCurrency])));
-  const currencies = configuredCurrencies && configuredCurrencies.length > 0 ? dedupe(configuredCurrencies) : dedupe([defaultCurrency, ..._nullishCoalesce(_optionalChain([shop, 'optionalAccess', _92 => _92.supportedCurrencies]), () => ( []))]);
+  const defaultCurrency = configuredDefaultCurrency ?? shop?.defaultCurrency;
+  const currencies = configuredCurrencies && configuredCurrencies.length > 0 ? dedupe(configuredCurrencies) : dedupe([defaultCurrency, ...shop?.supportedCurrencies ?? []]);
   return {
     currency,
-    effectiveCurrency: _nullishCoalesce(currency, () => ( defaultCurrency)),
+    effectiveCurrency: currency ?? defaultCurrency,
     setCurrency,
     currencies,
     defaultCurrency,
@@ -1420,7 +3410,7 @@ function useCurrency() {
 }
 
 // src/react/components/currency-switcher.tsx
-
+var import_jsx_runtime2 = require("react/jsx-runtime");
 function CurrencySwitcher({
   className,
   labels,
@@ -1431,40 +3421,40 @@ function CurrencySwitcher({
   const { currencies, effectiveCurrency, setCurrency } = useCurrency();
   if (currencies.length === 0) return null;
   if (currencies.length <= 1 && !showWhenSingle) return null;
-  const label = (code) => _nullishCoalesce(_optionalChain([labels, 'optionalAccess', _93 => _93[code]]), () => ( code));
+  const label = (code) => labels?.[code] ?? code;
   if (children) {
-    return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _jsxruntime.Fragment, { children: children({ currencies, value: effectiveCurrency, setCurrency, label }) });
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: children({ currencies, value: effectiveCurrency, setCurrency, label }) });
   }
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
     "select",
     {
       className,
       "aria-label": ariaLabel,
-      value: _nullishCoalesce(effectiveCurrency, () => ( "")),
+      value: effectiveCurrency ?? "",
       onChange: (e) => setCurrency(e.target.value),
-      children: currencies.map((code) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "option", { value: code, children: label(code) }, code))
+      children: currencies.map((code) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("option", { value: code, children: label(code) }, code))
     }
   );
 }
 
 // src/react/components/storefront-scripts.tsx
-
+var import_react16 = require("react");
 
 // src/react/hooks/use-consent.ts
-
+var import_react_query37 = require("@tanstack/react-query");
 function useCookieConsent(visitorId) {
   const { client } = useBehio();
-  const qc = _reactquery.useQueryClient.call(void 0, );
-  const query = _reactquery.useQuery.call(void 0, {
+  const qc = (0, import_react_query37.useQueryClient)();
+  const query = (0, import_react_query37.useQuery)({
     queryKey: ["behio", "consent", visitorId],
     queryFn: () => unwrap(client.consent.get(visitorId)),
     enabled: Boolean(visitorId)
   });
-  const recordMutation = _reactquery.useMutation.call(void 0, {
+  const recordMutation = (0, import_react_query37.useMutation)({
     mutationFn: (input) => unwrap(client.consent.record(input)),
     onSuccess: () => qc.invalidateQueries({ queryKey: ["behio", "consent"] })
   });
-  const revokeMutation = _reactquery.useMutation.call(void 0, {
+  const revokeMutation = (0, import_react_query37.useMutation)({
     mutationFn: () => unwrap(client.consent.revoke(visitorId)),
     onSuccess: () => qc.invalidateQueries({ queryKey: ["behio", "consent"] })
   });
@@ -1538,26 +3528,26 @@ function injectHtml(target, html) {
 }
 function StorefrontScripts({ visitorId: visitorIdProp } = {}) {
   const { data } = useShopScripts();
-  const [visitorId, setVisitorId] = _react.useState.call(void 0, _nullishCoalesce(visitorIdProp, () => ( "")));
-  _react.useEffect.call(void 0, () => {
+  const [visitorId, setVisitorId] = (0, import_react16.useState)(visitorIdProp ?? "");
+  (0, import_react16.useEffect)(() => {
     if (visitorIdProp) return;
     try {
       const v = localStorage.getItem(VISITOR_KEY);
       if (v) setVisitorId(v);
-    } catch (e6) {
+    } catch {
     }
   }, [visitorIdProp]);
   const { data: consent } = useCookieConsent(visitorId || void 0);
-  const analyticsOk = Boolean(_optionalChain([consent, 'optionalAccess', _94 => _94.analytics]));
-  const scripts = _react.useMemo.call(void 0, 
-    () => (_nullishCoalesce(_optionalChain([data, 'optionalAccess', _95 => _95.scripts]), () => ( []))).filter((s) => !s.consentRequired || analyticsOk),
+  const analyticsOk = Boolean(consent?.analytics);
+  const scripts = (0, import_react16.useMemo)(
+    () => (data?.scripts ?? []).filter((s) => !s.consentRequired || analyticsOk),
     [data, analyticsOk]
   );
-  const signature = _react.useMemo.call(void 0, 
+  const signature = (0, import_react16.useMemo)(
     () => JSON.stringify(scripts.map((s) => [s.id, s.type, s.placement, s.value])),
     [scripts]
   );
-  _react.useEffect.call(void 0, () => {
+  (0, import_react16.useEffect)(() => {
     if (typeof document === "undefined") return;
     const added = [];
     for (const s of scripts) {
@@ -1574,7 +3564,7 @@ function StorefrontScripts({ visitorId: visitorIdProp } = {}) {
 }
 
 // src/react/components/behio-analytics.tsx
-
+var import_react17 = require("react");
 
 // src/react/hooks/use-behio-client.ts
 function useBehioClient() {
@@ -1584,7 +3574,7 @@ function useBehioClient() {
 // src/react/components/behio-analytics.tsx
 function BehioAnalyticsTracker() {
   const client = useBehioClient();
-  _react.useEffect.call(void 0, () => {
+  (0, import_react17.useEffect)(() => {
     if (typeof window === "undefined") return;
     const w = window;
     if (w.__behioAnalytics) return;
@@ -1608,17 +3598,17 @@ function initTracker(client) {
   let dwellAccumMs = 0;
   const refreshIdentity = async () => {
     try {
-      const stored = _nullishCoalesce(localStorage.getItem(VISITOR_KEY2), () => ( void 0));
+      const stored = localStorage.getItem(VISITOR_KEY2) ?? void 0;
       if (!stored) {
         visitorId = void 0;
         client.setAnalyticsVisitorId(null);
         return;
       }
       const { data } = await client.consent.get(stored);
-      const granted = Boolean(_optionalChain([data, 'optionalAccess', _96 => _96.analytics]));
+      const granted = Boolean(data?.analytics);
       visitorId = granted ? stored : void 0;
       client.setAnalyticsVisitorId(granted ? stored : null);
-    } catch (e7) {
+    } catch {
       visitorId = void 0;
     }
   };
@@ -1699,17 +3689,17 @@ function initTracker(client) {
   };
   const onClick = (ev) => {
     const target = ev.target;
-    const el = _optionalChain([target, 'optionalAccess', _97 => _97.closest, 'optionalCall', _98 => _98("a,button,[role=button],[data-behio-event]")]);
+    const el = target?.closest?.("a,button,[role=button],[data-behio-event]");
     if (!el) return;
-    const explicit = _nullishCoalesce(el.getAttribute("data-behio-event"), () => ( void 0));
-    const text = (_nullishCoalesce(el.textContent, () => ( ""))).trim().replace(/\s+/g, " ").slice(0, 80) || void 0;
-    const hrefRaw = _nullishCoalesce(el.getAttribute("href"), () => ( void 0));
+    const explicit = el.getAttribute("data-behio-event") ?? void 0;
+    const text = (el.textContent ?? "").trim().replace(/\s+/g, " ").slice(0, 80) || void 0;
+    const hrefRaw = el.getAttribute("href") ?? void 0;
     let href;
     if (hrefRaw) {
       try {
         const u = new URL(hrefRaw, window.location.origin);
         href = u.origin === window.location.origin ? u.pathname : u.hostname;
-      } catch (e8) {
+      } catch {
         href = void 0;
       }
     }
@@ -1743,7 +3733,7 @@ function initTracker(client) {
     if (event === "purchase") return;
     const items = Array.isArray(payload.items) ? payload.items : [];
     const props = {
-      ..._nullishCoalesce(payload.props, () => ( {})),
+      ...payload.props ?? {},
       ...payload.search_term != null ? { query: payload.search_term } : {},
       ...payload.shipping_tier != null ? { shippingTier: payload.shipping_tier } : {},
       ...payload.payment_type != null ? { paymentType: payload.payment_type } : {},
@@ -1753,7 +3743,7 @@ function initTracker(client) {
         items: items.length,
         // First item id = the product (view_item/add_to_cart are
         // single-product in practice) - Behavioral Offers count on it.
-        itemId: _optionalChain([items, 'access', _99 => _99[0], 'optionalAccess', _100 => _100.item_id])
+        itemId: items[0]?.item_id
       } : {}
     };
     enqueue({
@@ -1799,7 +3789,7 @@ function getSessionId() {
     const sid = `s-${Math.random().toString(36).slice(2, 12)}${Date.now().toString(36)}`;
     sessionStorage.setItem("behio.sid", sid);
     return sid;
-  } catch (e9) {
+  } catch {
     return `s-${Math.random().toString(36).slice(2, 12)}`;
   }
 }
@@ -1807,115 +3797,115 @@ function utmFromSearch(search) {
   try {
     const p = new URLSearchParams(search);
     return {
-      utmSource: _nullishCoalesce(p.get("utm_source"), () => ( void 0)),
-      utmMedium: _nullishCoalesce(p.get("utm_medium"), () => ( void 0)),
-      utmCampaign: _nullishCoalesce(p.get("utm_campaign"), () => ( void 0)),
+      utmSource: p.get("utm_source") ?? void 0,
+      utmMedium: p.get("utm_medium") ?? void 0,
+      utmCampaign: p.get("utm_campaign") ?? void 0,
       // Extended attribution: paid-search term/content + click ids. The
       // backend folds these into event props (raw columns unchanged).
-      utmTerm: _nullishCoalesce(p.get("utm_term"), () => ( void 0)),
-      utmContent: _nullishCoalesce(p.get("utm_content"), () => ( void 0)),
-      gclid: _nullishCoalesce(p.get("gclid"), () => ( void 0)),
-      fbclid: _nullishCoalesce(p.get("fbclid"), () => ( void 0))
+      utmTerm: p.get("utm_term") ?? void 0,
+      utmContent: p.get("utm_content") ?? void 0,
+      gclid: p.get("gclid") ?? void 0,
+      fbclid: p.get("fbclid") ?? void 0
     };
-  } catch (e10) {
+  } catch {
     return {};
   }
 }
 
 // src/react/hooks/use-bundles.ts
-
+var import_react_query38 = require("@tanstack/react-query");
 function useBundles(options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query38.useQuery)({
     queryKey: ["behio", "bundles"],
     queryFn: () => unwrap(client.catalog.getBundles()),
-    enabled: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _101 => _101.enabled]), () => ( true)),
-    initialData: _optionalChain([options, 'optionalAccess', _102 => _102.initialData])
+    enabled: options?.enabled ?? true,
+    initialData: options?.initialData
   });
 }
 function useBundle(slug, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query38.useQuery)({
     queryKey: ["behio", "bundle", slug],
     queryFn: () => unwrap(client.catalog.getBundle(slug)),
-    enabled: Boolean(slug) && (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _103 => _103.enabled]), () => ( true))),
-    initialData: _optionalChain([options, 'optionalAccess', _104 => _104.initialData])
+    enabled: Boolean(slug) && (options?.enabled ?? true),
+    initialData: options?.initialData
   });
 }
 
 // src/react/hooks/use-product-group.ts
-
+var import_react_query39 = require("@tanstack/react-query");
 function useProductGroup(slug, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "product-group", slug, _optionalChain([options, 'optionalAccess', _105 => _105.locale]), _optionalChain([options, 'optionalAccess', _106 => _106.currency])],
+  return (0, import_react_query39.useQuery)({
+    queryKey: ["behio", "product-group", slug, options?.locale, options?.currency],
     queryFn: () => unwrap(
       client.catalog.getProductGroup(slug, {
-        locale: _optionalChain([options, 'optionalAccess', _107 => _107.locale]),
-        currency: _optionalChain([options, 'optionalAccess', _108 => _108.currency])
+        locale: options?.locale,
+        currency: options?.currency
       })
     ),
-    enabled: Boolean(slug) && (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _109 => _109.enabled]), () => ( true))),
-    initialData: _optionalChain([options, 'optionalAccess', _110 => _110.initialData])
+    enabled: Boolean(slug) && (options?.enabled ?? true),
+    initialData: options?.initialData
   });
 }
 
 // src/react/hooks/use-cross-sell.ts
-
+var import_react_query40 = require("@tanstack/react-query");
 function useCrossSell(productSlug, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "cross-sell", productSlug, _optionalChain([options, 'optionalAccess', _111 => _111.locale]), _optionalChain([options, 'optionalAccess', _112 => _112.currency])],
+  return (0, import_react_query40.useQuery)({
+    queryKey: ["behio", "cross-sell", productSlug, options?.locale, options?.currency],
     queryFn: () => unwrap(
       client.catalog.getCrossSell(productSlug, {
-        locale: _optionalChain([options, 'optionalAccess', _113 => _113.locale]),
-        currency: _optionalChain([options, 'optionalAccess', _114 => _114.currency])
+        locale: options?.locale,
+        currency: options?.currency
       })
     ),
-    enabled: Boolean(productSlug) && (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _115 => _115.enabled]), () => ( true))),
-    initialData: _optionalChain([options, 'optionalAccess', _116 => _116.initialData])
+    enabled: Boolean(productSlug) && (options?.enabled ?? true),
+    initialData: options?.initialData
   });
 }
 
 // src/react/hooks/use-product-promotions.ts
-
+var import_react_query41 = require("@tanstack/react-query");
 function useProductPromotions(productSlug, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query41.useQuery)({
     queryKey: ["behio", "product-promotions", productSlug],
     queryFn: () => unwrap(client.catalog.getProductPromotions(productSlug)),
-    enabled: Boolean(productSlug) && (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _117 => _117.enabled]), () => ( true))),
-    refetchInterval: _optionalChain([options, 'optionalAccess', _118 => _118.refetchIntervalMs])
+    enabled: Boolean(productSlug) && (options?.enabled ?? true),
+    refetchInterval: options?.refetchIntervalMs
   });
 }
 
 // src/react/hooks/use-gift-card.ts
-
+var import_react_query42 = require("@tanstack/react-query");
 function useGiftCardBalance(code, options) {
   const { client } = useBehio();
-  const trimmed = _optionalChain([code, 'optionalAccess', _119 => _119.trim, 'call', _120 => _120()]);
-  return _reactquery.useQuery.call(void 0, {
+  const trimmed = code?.trim();
+  return (0, import_react_query42.useQuery)({
     queryKey: ["behio", "gift-card-balance", trimmed],
     queryFn: () => unwrap(client.catalog.checkGiftCard(trimmed)),
-    enabled: Boolean(trimmed && trimmed.length >= 6) && (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _121 => _121.enabled]), () => ( true)))
+    enabled: Boolean(trimmed && trimmed.length >= 6) && (options?.enabled ?? true)
   });
 }
 
 // src/react/hooks/use-wishlist.ts
-
+var import_react_query43 = require("@tanstack/react-query");
 function useWishlist(options) {
   const { client } = useBehio();
-  const qc = _reactquery.useQueryClient.call(void 0, );
-  const query = _reactquery.useQuery.call(void 0, {
+  const qc = (0, import_react_query43.useQueryClient)();
+  const query = (0, import_react_query43.useQuery)({
     queryKey: ["behio", "wishlist"],
     queryFn: () => unwrap(client.wishlist.get()),
-    enabled: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _122 => _122.enabled]), () => ( true))
+    enabled: options?.enabled ?? true
   });
-  const addMutation = _reactquery.useMutation.call(void 0, {
+  const addMutation = (0, import_react_query43.useMutation)({
     mutationFn: (productId) => unwrap(client.wishlist.add(productId)),
     onSuccess: () => qc.invalidateQueries({ queryKey: ["behio", "wishlist"] })
   });
-  const removeMutation = _reactquery.useMutation.call(void 0, {
+  const removeMutation = (0, import_react_query43.useMutation)({
     mutationFn: (productId) => unwrap(client.wishlist.remove(productId)),
     onSuccess: () => qc.invalidateQueries({ queryKey: ["behio", "wishlist"] })
   });
@@ -1929,7 +3919,7 @@ function useWishlist(options) {
 }
 function useIsInWishlist(productId) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query43.useQuery)({
     queryKey: ["behio", "wishlist-check", productId],
     queryFn: () => unwrap(client.wishlist.isInWishlist(productId)),
     enabled: Boolean(productId)
@@ -1937,41 +3927,41 @@ function useIsInWishlist(productId) {
 }
 
 // src/react/hooks/use-reviews.ts
-
+var import_react_query44 = require("@tanstack/react-query");
 function useProductReviews(productId, options) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
-    queryKey: ["behio", "reviews", productId, _nullishCoalesce(_optionalChain([options, 'optionalAccess', _123 => _123.page]), () => ( 1))],
-    queryFn: () => unwrap(client.reviews.getProductReviews(productId, _optionalChain([options, 'optionalAccess', _124 => _124.page]), _optionalChain([options, 'optionalAccess', _125 => _125.limit]))),
-    enabled: Boolean(productId) && (_nullishCoalesce(_optionalChain([options, 'optionalAccess', _126 => _126.enabled]), () => ( true)))
+  return (0, import_react_query44.useQuery)({
+    queryKey: ["behio", "reviews", productId, options?.page ?? 1],
+    queryFn: () => unwrap(client.reviews.getProductReviews(productId, options?.page, options?.limit)),
+    enabled: Boolean(productId) && (options?.enabled ?? true)
   });
 }
 function useSubmitReview() {
   const { client } = useBehio();
-  const qc = _reactquery.useQueryClient.call(void 0, );
-  return _reactquery.useMutation.call(void 0, {
+  const qc = (0, import_react_query44.useQueryClient)();
+  return (0, import_react_query44.useMutation)({
     mutationFn: (input) => unwrap(client.reviews.submit(input)),
     onSuccess: (_, input) => qc.invalidateQueries({ queryKey: ["behio", "reviews", input.productId] })
   });
 }
 
 // src/react/hooks/use-returns.ts
-
+var import_react_query45 = require("@tanstack/react-query");
 function useLookupReturnableOrder() {
   const { client } = useBehio();
-  return _reactquery.useMutation.call(void 0, {
+  return (0, import_react_query45.useMutation)({
     mutationFn: ({ orderNumber, email }) => unwrap(client.returns.lookupOrder(orderNumber, email))
   });
 }
 function useSubmitReturn() {
   const { client } = useBehio();
-  return _reactquery.useMutation.call(void 0, {
+  return (0, import_react_query45.useMutation)({
     mutationFn: (input) => unwrap(client.returns.submit(input))
   });
 }
 function useReturnStatus(returnId, email) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query45.useQuery)({
     queryKey: ["behio", "return-status", returnId],
     queryFn: () => unwrap(client.returns.getStatus(returnId, email)),
     enabled: Boolean(returnId && email)
@@ -1979,16 +3969,16 @@ function useReturnStatus(returnId, email) {
 }
 
 // src/react/hooks/use-quotes.ts
-
+var import_react_query46 = require("@tanstack/react-query");
 function useSubmitQuote() {
   const { client } = useBehio();
-  return _reactquery.useMutation.call(void 0, {
+  return (0, import_react_query46.useMutation)({
     mutationFn: (input) => unwrap(client.quotes.submit(input))
   });
 }
 function useQuoteStatus(quoteId, email) {
   const { client } = useBehio();
-  return _reactquery.useQuery.call(void 0, {
+  return (0, import_react_query46.useQuery)({
     queryKey: ["behio", "quote-status", quoteId],
     queryFn: () => unwrap(client.quotes.getStatus(quoteId, email)),
     enabled: Boolean(quoteId && email)
@@ -1996,84 +3986,201 @@ function useQuoteStatus(quoteId, email) {
 }
 
 // src/react/hooks/use-back-in-stock.ts
-
+var import_react_query47 = require("@tanstack/react-query");
 function useNotifyWhenAvailable() {
   const { client } = useBehio();
-  return _reactquery.useMutation.call(void 0, {
+  return (0, import_react_query47.useMutation)({
     mutationFn: ({ productId, email }) => unwrap(client.catalog.notifyWhenAvailable(productId, email))
   });
 }
 
+// src/react/utils/format-price.ts
+function formatPrice(amount, currency, locale) {
+  const resolvedLocale = locale ?? "cs";
+  try {
+    return new Intl.NumberFormat(resolvedLocale, {
+      style: "currency",
+      currency,
+      minimumFractionDigits: Number.isInteger(amount) ? 0 : 2,
+      maximumFractionDigits: 2
+    }).format(amount);
+  } catch {
+    return `${amount} ${currency}`;
+  }
+}
 
+// src/analytics.ts
+var GA4_NAME_MAP = {
+  newsletter_signup: "generate_lead"
+};
+function trackEcommerceEvent(event, payload) {
+  if (typeof window === "undefined") return;
+  const w = window;
+  try {
+    w.__behioEcommerceSink?.(event, payload);
+  } catch {
+  }
+  const gaName = GA4_NAME_MAP[event] ?? event;
+  try {
+    if (typeof w.gtag === "function") {
+      w.gtag("event", gaName, payload);
+      return;
+    }
+    if (Array.isArray(w.dataLayer)) {
+      w.dataLayer.push({ ecommerce: null });
+      w.dataLayer.push({ event: gaName, ecommerce: payload });
+    }
+  } catch {
+  }
+}
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.BehioAnalyticsTracker = BehioAnalyticsTracker; exports.BehioProvider = BehioProvider; exports.CurrencySwitcher = CurrencySwitcher; exports.StorefrontScripts = StorefrontScripts; exports.cookieStorage = cookieStorage; exports.createMemoryStorage = createMemoryStorage; exports.detectStorage = detectStorage; exports.formatPrice = _chunkCZRSJULDjs.formatPrice; exports.generateVisitorId = _chunkCZRSJULDjs.generateVisitorId; exports.getStoredVisitorId = _chunkCZRSJULDjs.getStoredVisitorId; exports.grantAnalyticsConsent = _chunkCZRSJULDjs.grantAnalyticsConsent; exports.localStorageAdapter = localStorageAdapter; exports.memoryStorage = memoryStorage; exports.revokeAnalyticsConsent = _chunkCZRSJULDjs.revokeAnalyticsConsent; exports.trackEcommerceEvent = _chunkCZRSJULDjs.trackEcommerceEvent; exports.useAddressAutocomplete = useAddressAutocomplete; exports.useAddresses = useAddresses; exports.useAnalyticsEvents = useAnalyticsEvents; exports.useAuth = useAuth; exports.useBehio = useBehio; exports.useBehioClient = useBehioClient; exports.useBundle = useBundle; exports.useBundles = useBundles; exports.useCart = useCart; exports.useCartCount = useCartCount; exports.useCategories = useCategories; exports.useCategory = useCategory; exports.useCheckout = useCheckout; exports.useCookieConsent = useCookieConsent; exports.useCourse = useCourse; exports.useCourses = useCourses; exports.useCrossSell = useCrossSell; exports.useCurrency = useCurrency; exports.useCustomer = useCustomer; exports.useFacets = useFacets; exports.useFeatured = useFeatured; exports.useFilters = useFilters; exports.useGiftCardBalance = useGiftCardBalance; exports.useIsInWishlist = useIsInWishlist; exports.useLabels = useLabels; exports.useLookupReturnableOrder = useLookupReturnableOrder; exports.useLoyalty = useLoyalty; exports.useMenu = useMenu; exports.useNewsletterSubscribe = useNewsletterSubscribe; exports.useNewsletterUnsubscribe = useNewsletterUnsubscribe; exports.useNotifyWhenAvailable = useNotifyWhenAvailable; exports.useOrder = useOrder; exports.useOrderAccess = useOrderAccess; exports.useOrders = useOrders; exports.usePage = usePage; exports.usePages = usePages; exports.usePaymentMethods = usePaymentMethods; exports.usePersonalOffers = usePersonalOffers; exports.usePickupPoints = usePickupPoints; exports.useProduct = useProduct; exports.useProductGroup = useProductGroup; exports.useProductPromotions = useProductPromotions; exports.useProductReviews = useProductReviews; exports.useProducts = useProducts; exports.useQuoteStatus = useQuoteStatus; exports.useReturnStatus = useReturnStatus; exports.useSearch = useSearch; exports.useShippingMethods = useShippingMethods; exports.useShippingQuote = useShippingQuote; exports.useShopInfo = useShopInfo; exports.useShopScripts = useShopScripts; exports.useShopSeo = useShopSeo; exports.useSubmitQuote = useSubmitQuote; exports.useSubmitReturn = useSubmitReturn; exports.useSubmitReview = useSubmitReview; exports.useSubscriptions = useSubscriptions; exports.useWishlist = useWishlist;
+// src/consent-visitor.ts
+var VISITOR_KEY3 = "behio_visitor_id";
+var COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
+function getStoredVisitorId() {
+  if (typeof window === "undefined") return null;
+  try {
+    const ls = localStorage.getItem(VISITOR_KEY3);
+    if (ls) return ls;
+  } catch {
+  }
+  return readCookie(VISITOR_KEY3);
+}
+function generateVisitorId() {
+  const bytes = new Uint8Array(18);
+  try {
+    globalThis.crypto?.getRandomValues?.(bytes);
+  } catch {
+  }
+  let filled = false;
+  for (const b of bytes) if (b !== 0) filled = true;
+  if (!filled) for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  const b64 = typeof btoa === "function" ? btoa(bin) : Buffer.from(bytes).toString("base64");
+  return `v${b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`.slice(0, 40);
+}
+function writeVisitorId(id) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(VISITOR_KEY3, id);
+  } catch {
+  }
+  try {
+    document.cookie = `${VISITOR_KEY3}=${encodeURIComponent(id)}; path=/; max-age=${COOKIE_MAX_AGE}; SameSite=Lax`;
+  } catch {
+  }
+}
+function readCookie(name) {
+  if (typeof document === "undefined") return null;
+  const match = document.cookie.match(new RegExp(`(?:^|; )${name}=([^;]*)`));
+  return match ? decodeURIComponent(match[1]) : null;
+}
+function emitConsentChanged() {
+  if (typeof window === "undefined") return;
+  try {
+    window.dispatchEvent(new Event("behio:consent-changed"));
+  } catch {
+  }
+}
+async function grantAnalyticsConsent(client, categories) {
+  const id = getStoredVisitorId() ?? generateVisitorId();
+  writeVisitorId(id);
+  client.setAnalyticsVisitorId(id);
+  const res = await client.consent.record({
+    visitorId: id,
+    analytics: true,
+    marketing: categories?.marketing ?? false,
+    preferences: categories?.preferences ?? false
+  });
+  emitConsentChanged();
+  return res;
+}
+async function revokeAnalyticsConsent(client) {
+  const id = getStoredVisitorId();
+  client.setAnalyticsVisitorId(null);
+  emitConsentChanged();
+  if (!id) return { data: { success: true }, error: null };
+  return client.consent.revoke(id);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BehioAnalyticsTracker,
+  BehioProvider,
+  CurrencySwitcher,
+  StorefrontScripts,
+  cookieStorage,
+  createMemoryStorage,
+  detectStorage,
+  formatPrice,
+  generateVisitorId,
+  getStoredVisitorId,
+  grantAnalyticsConsent,
+  localStorageAdapter,
+  memoryStorage,
+  revokeAnalyticsConsent,
+  trackEcommerceEvent,
+  useAddressAutocomplete,
+  useAddresses,
+  useAnalyticsEvents,
+  useAuth,
+  useBehio,
+  useBehioClient,
+  useBundle,
+  useBundles,
+  useCart,
+  useCartCount,
+  useCategories,
+  useCategory,
+  useCertificateVerification,
+  useCheckout,
+  useCookieConsent,
+  useCourse,
+  useCourseCertificates,
+  useCourses,
+  useCrossSell,
+  useCurrency,
+  useCustomer,
+  useFacets,
+  useFeatured,
+  useFilters,
+  useGiftCardBalance,
+  useIsInWishlist,
+  useLabels,
+  useLessonComments,
+  useLessonNote,
+  useLessonQuiz,
+  useLessonTutor,
+  useLookupReturnableOrder,
+  useLoyalty,
+  useMenu,
+  useNewsletterSubscribe,
+  useNewsletterUnsubscribe,
+  useNotifyWhenAvailable,
+  useOrder,
+  useOrderAccess,
+  useOrders,
+  usePage,
+  usePages,
+  usePaymentMethods,
+  usePersonalOffers,
+  usePickupPoints,
+  useProduct,
+  useProductGroup,
+  useProductPromotions,
+  useProductReviews,
+  useProducts,
+  useQuoteStatus,
+  useReturnStatus,
+  useSearch,
+  useShippingMethods,
+  useShippingQuote,
+  useShopInfo,
+  useShopScripts,
+  useShopSeo,
+  useSubmitQuote,
+  useSubmitReturn,
+  useSubmitReview,
+  useSubscriptions,
+  useWishlist
+});