@behio/storefront-sdk 0.37.0 → 0.41.0

package/dist/react.mjs

@@ -1,19 +1,1702 @@
-import {
-  formatPrice,
-  generateVisitorId,
-  getStoredVisitorId,
-  grantAnalyticsConsent,
-  revokeAnalyticsConsent,
-  trackEcommerceEvent
-} from "./chunk-QUU76QUB.mjs";
-import {
-  BehioStorefront
-} from "./chunk-5C6MNGGB.mjs";
+"use client";
 
 // src/react/provider.tsx
 import { useRef, useEffect, useMemo, useState, useCallback } from "react";
 import { QueryClient, QueryClientProvider } from "@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
 import { createContext, useContext } from "react";
 var BehioContext = createContext(null);
@@ -900,27 +2583,268 @@ function useLoyalty(options) {
   return { loyalty: data, isLoading, error, refetch };
 }
 
+// src/react/hooks/use-courses.ts
+import { useMutation as useMutation5, useQuery as useQuery16, useQueryClient as useQueryClient7 } from "@tanstack/react-query";
+var COURSES_KEY = ["behio", "courses"];
+function useCourses(options) {
+  const { client } = useBehio();
+  const { data, isLoading, error, refetch } = useQuery16({
+    queryKey: [...COURSES_KEY],
+    queryFn: () => unwrap(client.customer.getCourses()),
+    enabled: options?.enabled !== false && !!client.getAccessToken()
+  });
+  return { courses: data?.items ?? [], isLoading, error, refetch };
+}
+function useCourse(courseId, options) {
+  const { client } = useBehio();
+  const queryClient = useQueryClient7();
+  const { data, isLoading, error, refetch } = useQuery16({
+    queryKey: [...COURSES_KEY, courseId],
+    queryFn: () => unwrap(client.customer.getCourse(courseId)),
+    enabled: options?.enabled !== false && !!courseId && !!client.getAccessToken()
+  });
+  const complete = useMutation5({
+    mutationFn: ({ lessonId }) => unwrap(client.customer.completeLesson(courseId, lessonId)),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: [...COURSES_KEY] });
+    }
+  });
+  return {
+    course: data,
+    isLoading,
+    error,
+    refetch,
+    completeLesson: (lessonId) => complete.mutateAsync({ lessonId }),
+    isCompleting: complete.isPending
+  };
+}
+function useLessonQuiz(courseId, lessonId, options) {
+  const { client } = useBehio();
+  const queryClient = useQueryClient7();
+  const { data, isLoading, error, refetch } = useQuery16({
+    queryKey: [...COURSES_KEY, courseId, "quiz", lessonId],
+    queryFn: () => unwrap(
+      client.customer.getLessonQuiz(courseId, lessonId)
+    ),
+    enabled: options?.enabled !== false && !!courseId && !!lessonId && !!client.getAccessToken()
+  });
+  const submit = useMutation5(
+    {
+      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 } = useQuery16({
+    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 } = useQuery16(
+    {
+      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
+import { useMutation as useMutation6, useQuery as useQuery17, useQueryClient as useQueryClient8 } from "@tanstack/react-query";
+var TUTOR_KEY = ["behio", "course-tutor"];
+function useLessonTutor(courseId, lessonId, options) {
+  const { client } = useBehio();
+  const queryClient = useQueryClient8();
+  const { data, isLoading, error, refetch } = useQuery17({
+    queryKey: [...TUTOR_KEY, courseId, lessonId],
+    queryFn: () => unwrap(
+      client.customer.getLessonTutorThread(
+        courseId,
+        lessonId
+      )
+    ),
+    enabled: options?.enabled !== false && !!courseId && !!lessonId && !!client.getAccessToken()
+  });
+  const ask = useMutation6({
+    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-lesson-comments.ts
+import { useMutation as useMutation7, useQuery as useQuery18, useQueryClient as useQueryClient9 } from "@tanstack/react-query";
+var COMMENTS_KEY = ["behio", "course-comments"];
+function useLessonComments(courseId, lessonId, options) {
+  const { client } = useBehio();
+  const queryClient = useQueryClient9();
+  const page = options?.page ?? 1;
+  const { data, isLoading, error, refetch } = useQuery18({
+    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 = useMutation7({
+    mutationFn: ({ body, parentId }) => unwrap(
+      client.customer.postLessonComment(
+        courseId,
+        lessonId,
+        body,
+        parentId
+      )
+    ),
+    onSuccess: () => {
+      void invalidate();
+    }
+  });
+  const remove = useMutation7({
+    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
+import { useMutation as useMutation8, useQuery as useQuery19, useQueryClient as useQueryClient10 } from "@tanstack/react-query";
+var NOTE_KEY = ["behio", "course-note"];
+function useLessonNote(courseId, lessonId, options) {
+  const { client } = useBehio();
+  const queryClient = useQueryClient10();
+  const { data, isLoading, error, refetch } = useQuery19({
+    queryKey: [...NOTE_KEY, courseId, lessonId],
+    queryFn: () => unwrap(
+      client.customer.getLessonNote(courseId, lessonId)
+    ),
+    enabled: options?.enabled !== false && !!courseId && !!lessonId && !!client.getAccessToken()
+  });
+  const save = useMutation8({
+    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
-import { useQuery as useQuery16, useMutation as useMutation5, useQueryClient as useQueryClient7 } from "@tanstack/react-query";
+import { useQuery as useQuery20, useMutation as useMutation9, useQueryClient as useQueryClient11 } from "@tanstack/react-query";
 var SUBSCRIPTIONS_KEY = ["behio", "subscriptions"];
 function useSubscriptions(options) {
   const { client } = useBehio();
-  const qc = useQueryClient7();
-  const query = useQuery16({
+  const qc = useQueryClient11();
+  const query = useQuery20({
     queryKey: [...SUBSCRIPTIONS_KEY],
     queryFn: () => unwrap(client.subscriptions.list()),
     enabled: options?.enabled !== false && !!client.getAccessToken()
   });
   const invalidate = () => qc.invalidateQueries({ queryKey: [...SUBSCRIPTIONS_KEY] });
-  const pauseMutation = useMutation5({
+  const pauseMutation = useMutation9({
     mutationFn: (subscriptionId) => unwrap(client.subscriptions.pause(subscriptionId)),
     onSuccess: invalidate
   });
-  const resumeMutation = useMutation5({
+  const resumeMutation = useMutation9({
     mutationFn: (subscriptionId) => unwrap(client.subscriptions.resume(subscriptionId)),
     onSuccess: invalidate
   });
-  const cancelMutation = useMutation5({
+  const cancelMutation = useMutation9({
     mutationFn: (subscriptionId) => unwrap(client.subscriptions.cancel(subscriptionId)),
     onSuccess: invalidate
   });
@@ -939,11 +2863,11 @@ function useSubscriptions(options) {
 }
 
 // src/react/hooks/use-pickup-points.ts
-import { useQuery as useQuery17 } from "@tanstack/react-query";
+import { useQuery as useQuery21 } from "@tanstack/react-query";
 function usePickupPoints(input) {
   const { client } = useBehio();
   const { methodId, query, country, limit, enabled } = input;
-  const { data, isLoading, error, refetch } = useQuery17({
+  const { data, isLoading, error, refetch } = useQuery21({
     queryKey: ["behio", "pickup-points", methodId, query ?? "", country ?? "", limit ?? 30],
     queryFn: () => unwrap(
       client.shipping.getPickupPoints({
@@ -959,12 +2883,12 @@ function usePickupPoints(input) {
 }
 
 // src/react/hooks/use-shipping-methods.ts
-import { useQuery as useQuery18 } from "@tanstack/react-query";
+import { useQuery as useQuery22 } from "@tanstack/react-query";
 function useShippingMethods(options) {
   const { client, currency: activeCurrency } = useBehio();
   const currency = options?.currency ?? activeCurrency;
   const { country, cartTotal, cartWeightKg } = options ?? {};
-  const { data, isLoading, error, refetch } = useQuery18({
+  const { data, isLoading, error, refetch } = useQuery22({
     queryKey: [
       "behio",
       "shipping-methods",
@@ -980,12 +2904,12 @@ function useShippingMethods(options) {
 }
 
 // src/react/hooks/use-shipping-quote.ts
-import { useQuery as useQuery19 } from "@tanstack/react-query";
+import { useQuery as useQuery23 } from "@tanstack/react-query";
 function useShippingQuote(options) {
   const { client, currency: activeCurrency } = useBehio();
   const { destinationAddress, items, cartTotal, enabled } = options ?? {};
   const currency = options?.currency ?? activeCurrency;
-  const { data, isLoading, error, refetch } = useQuery19({
+  const { data, isLoading, error, refetch } = useQuery23({
     queryKey: [
       "behio",
       "shipping-quote",
@@ -1008,11 +2932,11 @@ function useShippingQuote(options) {
 }
 
 // src/react/hooks/use-payment-methods.ts
-import { useQuery as useQuery20 } from "@tanstack/react-query";
+import { useQuery as useQuery24 } from "@tanstack/react-query";
 function usePaymentMethods(options) {
   const { client, currency: activeCurrency } = useBehio();
   const currency = options?.currency ?? activeCurrency;
-  const { data, isLoading, error, refetch } = useQuery20({
+  const { data, isLoading, error, refetch } = useQuery24({
     queryKey: ["behio", "payment-methods", currency ?? ""],
     queryFn: () => unwrap(client.catalog.listPaymentMethods({ currency })),
     enabled: options?.enabled !== false
@@ -1022,10 +2946,10 @@ function usePaymentMethods(options) {
 
 // src/react/hooks/use-personal-offers.ts
 import { useCallback as useCallback8, useEffect as useEffect4, useState as useState5 } from "react";
-import { useMutation as useMutation6, useQuery as useQuery21, useQueryClient as useQueryClient8 } from "@tanstack/react-query";
+import { useMutation as useMutation10, useQuery as useQuery25, useQueryClient as useQueryClient12 } from "@tanstack/react-query";
 function usePersonalOffers(options) {
   const { client } = useBehio();
-  const queryClient = useQueryClient8();
+  const queryClient = useQueryClient12();
   const [polledVid, setPolledVid] = useState5(null);
   const explicitVid = options?.visitorId;
   useEffect4(() => {
@@ -1043,12 +2967,12 @@ function usePersonalOffers(options) {
   }, [client, explicitVid]);
   const visitorId = explicitVid ?? polledVid;
   const queryKey = ["behio", "personal-offers", visitorId ?? ""];
-  const { data, isLoading, error, refetch } = useQuery21({
+  const { data, isLoading, error, refetch } = useQuery25({
     queryKey,
     queryFn: () => unwrap(client.getPersonalOffers(visitorId)),
     enabled: options?.enabled !== false && !!visitorId
   });
-  const claimMutation = useMutation6({
+  const claimMutation = useMutation10({
     mutationFn: ({ offerId, email }) => unwrap(client.claimOfferByEmail(offerId, { visitorId, email })),
     onSuccess: (result, { offerId }) => {
       queryClient.setQueryData(
@@ -1110,16 +3034,16 @@ function useAnalyticsEvents() {
 }
 
 // src/react/hooks/use-newsletter.ts
-import { useMutation as useMutation7 } from "@tanstack/react-query";
+import { useMutation as useMutation11 } from "@tanstack/react-query";
 function useNewsletterSubscribe() {
   const { client } = useBehio();
-  return useMutation7({
+  return useMutation11({
     mutationFn: (input) => unwrap(client.newsletter.subscribe(input))
   });
 }
 function useNewsletterUnsubscribe() {
   const { client } = useBehio();
-  return useMutation7({
+  return useMutation11({
     mutationFn: (email) => unwrap(client.newsletter.unsubscribe(email))
   });
 }
@@ -1177,20 +3101,20 @@ function useOrders(options) {
 
 // src/react/hooks/use-order.ts
 import { useCallback as useCallback11 } from "react";
-import { useQuery as useQuery22, useMutation as useMutation8, useQueryClient as useQueryClient9 } from "@tanstack/react-query";
+import { useQuery as useQuery26, useMutation as useMutation12, useQueryClient as useQueryClient13 } from "@tanstack/react-query";
 function useOrder(orderNumber, options) {
   const { client } = useBehio();
-  const queryClient = useQueryClient9();
+  const queryClient = useQueryClient13();
   const {
     data,
     isLoading,
     error
-  } = useQuery22({
+  } = useQuery26({
     queryKey: ["behio", "order", orderNumber],
     queryFn: () => unwrap(client.orders.get(orderNumber)),
     enabled: options?.enabled !== false && !!orderNumber && !!client.getAccessToken()
   });
-  const cancelMutation = useMutation8({
+  const cancelMutation = useMutation12({
     mutationFn: () => unwrap(client.orders.cancel(orderNumber)),
     onSuccess: (updated) => {
       queryClient.setQueryData(["behio", "order", orderNumber], updated);
@@ -1212,21 +3136,21 @@ function useOrder(orderNumber, options) {
 
 // src/react/hooks/use-order-access.ts
 import { useCallback as useCallback12, useState as useState7 } from "react";
-import { useMutation as useMutation9 } from "@tanstack/react-query";
+import { useMutation as useMutation13 } from "@tanstack/react-query";
 function useOrderAccess() {
   const { client } = useBehio();
   const [orderNumber, setOrderNumber] = useState7(null);
   const [email, setEmail] = useState7(null);
   const [order, setOrder] = useState7(null);
   const [accessToken, setAccessToken] = useState7(null);
-  const requestMutation = useMutation9({
+  const requestMutation = useMutation13({
     mutationFn: (input) => unwrap(client.orders.requestAccessCode(input.orderNumber, input.email)),
     onSuccess: (_data, input) => {
       setOrderNumber(input.orderNumber);
       setEmail(input.email);
     }
   });
-  const verifyMutation = useMutation9({
+  const verifyMutation = useMutation13({
     mutationFn: (code) => {
       if (!orderNumber || !email) {
         throw new Error("Request a code before verifying");
@@ -1272,12 +3196,12 @@ function useOrderAccess() {
 
 // src/react/hooks/use-checkout.ts
 import { useState as useState8, useCallback as useCallback13 } from "react";
-import { useMutation as useMutation10, useQueryClient as useQueryClient10 } from "@tanstack/react-query";
+import { useMutation as useMutation14, useQueryClient as useQueryClient14 } from "@tanstack/react-query";
 function useCheckout() {
   const { client, storage } = useBehio();
-  const queryClient = useQueryClient10();
+  const queryClient = useQueryClient14();
   const [order, setOrder] = useState8(null);
-  const mutation = useMutation10({
+  const mutation = useMutation14({
     mutationFn: (input) => unwrap(client.checkout.createOrder(input)),
     onSuccess: (result) => {
       setOrder(result);
@@ -1304,10 +3228,10 @@ function useCheckout() {
 }
 
 // src/react/hooks/use-pages.ts
-import { useQuery as useQuery23 } from "@tanstack/react-query";
+import { useQuery as useQuery27 } from "@tanstack/react-query";
 function usePages(locale, options) {
   const { client } = useBehio();
-  return useQuery23({
+  return useQuery27({
     queryKey: ["behio", "pages", locale],
     queryFn: async () => {
       const result = await unwrap(client.pages.list(locale));
@@ -1318,7 +3242,7 @@ function usePages(locale, options) {
 }
 function usePage(slug, locale, options) {
   const { client } = useBehio();
-  return useQuery23({
+  return useQuery27({
     queryKey: ["behio", "page", slug, locale],
     queryFn: () => unwrap(client.pages.get(slug, locale)),
     enabled: options?.enabled !== false && !!slug
@@ -1326,10 +3250,10 @@ function usePage(slug, locale, options) {
 }
 
 // src/react/hooks/use-shop-info.ts
-import { useQuery as useQuery24 } from "@tanstack/react-query";
+import { useQuery as useQuery28 } from "@tanstack/react-query";
 function useShopInfo(options) {
   const { client } = useBehio();
-  return useQuery24({
+  return useQuery28({
     queryKey: ["behio", "shop-info"],
     queryFn: () => unwrap(client.getShopInfo()),
     enabled: options?.enabled !== false
@@ -1337,10 +3261,10 @@ function useShopInfo(options) {
 }
 
 // src/react/hooks/use-shop-scripts.ts
-import { useQuery as useQuery25 } from "@tanstack/react-query";
+import { useQuery as useQuery29 } from "@tanstack/react-query";
 function useShopScripts(options) {
   const { client } = useBehio();
-  return useQuery25({
+  return useQuery29({
     queryKey: ["behio", "shop-scripts"],
     queryFn: () => unwrap(client.getShopScripts()),
     enabled: options?.enabled !== false
@@ -1348,11 +3272,11 @@ function useShopScripts(options) {
 }
 
 // src/react/hooks/use-shop-seo.ts
-import { useQuery as useQuery26 } from "@tanstack/react-query";
+import { useQuery as useQuery30 } from "@tanstack/react-query";
 function useShopSeo(options) {
   const { client } = useBehio();
   const { locale, initialData, enabled = true } = options ?? {};
-  return useQuery26({
+  return useQuery30({
     queryKey: ["behio", "shop-seo", locale ?? "_default"],
     queryFn: () => unwrap(client.getShopSeo(locale)),
     initialData,
@@ -1415,20 +3339,20 @@ function CurrencySwitcher({
 import { useEffect as useEffect5, useMemo as useMemo4, useState as useState9 } from "react";
 
 // src/react/hooks/use-consent.ts
-import { useQuery as useQuery27, useMutation as useMutation11, useQueryClient as useQueryClient11 } from "@tanstack/react-query";
+import { useQuery as useQuery31, useMutation as useMutation15, useQueryClient as useQueryClient15 } from "@tanstack/react-query";
 function useCookieConsent(visitorId) {
   const { client } = useBehio();
-  const qc = useQueryClient11();
-  const query = useQuery27({
+  const qc = useQueryClient15();
+  const query = useQuery31({
     queryKey: ["behio", "consent", visitorId],
     queryFn: () => unwrap(client.consent.get(visitorId)),
     enabled: Boolean(visitorId)
   });
-  const recordMutation = useMutation11({
+  const recordMutation = useMutation15({
     mutationFn: (input) => unwrap(client.consent.record(input)),
     onSuccess: () => qc.invalidateQueries({ queryKey: ["behio", "consent"] })
   });
-  const revokeMutation = useMutation11({
+  const revokeMutation = useMutation15({
     mutationFn: () => unwrap(client.consent.revoke(visitorId)),
     onSuccess: () => qc.invalidateQueries({ queryKey: ["behio", "consent"] })
   });
@@ -1787,10 +3711,10 @@ function utmFromSearch(search) {
 }
 
 // src/react/hooks/use-bundles.ts
-import { useQuery as useQuery28 } from "@tanstack/react-query";
+import { useQuery as useQuery32 } from "@tanstack/react-query";
 function useBundles(options) {
   const { client } = useBehio();
-  return useQuery28({
+  return useQuery32({
     queryKey: ["behio", "bundles"],
     queryFn: () => unwrap(client.catalog.getBundles()),
     enabled: options?.enabled ?? true,
@@ -1799,7 +3723,7 @@ function useBundles(options) {
 }
 function useBundle(slug, options) {
   const { client } = useBehio();
-  return useQuery28({
+  return useQuery32({
     queryKey: ["behio", "bundle", slug],
     queryFn: () => unwrap(client.catalog.getBundle(slug)),
     enabled: Boolean(slug) && (options?.enabled ?? true),
@@ -1808,10 +3732,10 @@ function useBundle(slug, options) {
 }
 
 // src/react/hooks/use-product-group.ts
-import { useQuery as useQuery29 } from "@tanstack/react-query";
+import { useQuery as useQuery33 } from "@tanstack/react-query";
 function useProductGroup(slug, options) {
   const { client } = useBehio();
-  return useQuery29({
+  return useQuery33({
     queryKey: ["behio", "product-group", slug, options?.locale, options?.currency],
     queryFn: () => unwrap(
       client.catalog.getProductGroup(slug, {
@@ -1825,10 +3749,10 @@ function useProductGroup(slug, options) {
 }
 
 // src/react/hooks/use-cross-sell.ts
-import { useQuery as useQuery30 } from "@tanstack/react-query";
+import { useQuery as useQuery34 } from "@tanstack/react-query";
 function useCrossSell(productSlug, options) {
   const { client } = useBehio();
-  return useQuery30({
+  return useQuery34({
     queryKey: ["behio", "cross-sell", productSlug, options?.locale, options?.currency],
     queryFn: () => unwrap(
       client.catalog.getCrossSell(productSlug, {
@@ -1842,10 +3766,10 @@ function useCrossSell(productSlug, options) {
 }
 
 // src/react/hooks/use-product-promotions.ts
-import { useQuery as useQuery31 } from "@tanstack/react-query";
+import { useQuery as useQuery35 } from "@tanstack/react-query";
 function useProductPromotions(productSlug, options) {
   const { client } = useBehio();
-  return useQuery31({
+  return useQuery35({
     queryKey: ["behio", "product-promotions", productSlug],
     queryFn: () => unwrap(client.catalog.getProductPromotions(productSlug)),
     enabled: Boolean(productSlug) && (options?.enabled ?? true),
@@ -1854,11 +3778,11 @@ function useProductPromotions(productSlug, options) {
 }
 
 // src/react/hooks/use-gift-card.ts
-import { useQuery as useQuery32 } from "@tanstack/react-query";
+import { useQuery as useQuery36 } from "@tanstack/react-query";
 function useGiftCardBalance(code, options) {
   const { client } = useBehio();
   const trimmed = code?.trim();
-  return useQuery32({
+  return useQuery36({
     queryKey: ["behio", "gift-card-balance", trimmed],
     queryFn: () => unwrap(client.catalog.checkGiftCard(trimmed)),
     enabled: Boolean(trimmed && trimmed.length >= 6) && (options?.enabled ?? true)
@@ -1866,20 +3790,20 @@ function useGiftCardBalance(code, options) {
 }
 
 // src/react/hooks/use-wishlist.ts
-import { useQuery as useQuery33, useMutation as useMutation12, useQueryClient as useQueryClient12 } from "@tanstack/react-query";
+import { useQuery as useQuery37, useMutation as useMutation16, useQueryClient as useQueryClient16 } from "@tanstack/react-query";
 function useWishlist(options) {
   const { client } = useBehio();
-  const qc = useQueryClient12();
-  const query = useQuery33({
+  const qc = useQueryClient16();
+  const query = useQuery37({
     queryKey: ["behio", "wishlist"],
     queryFn: () => unwrap(client.wishlist.get()),
     enabled: options?.enabled ?? true
   });
-  const addMutation = useMutation12({
+  const addMutation = useMutation16({
     mutationFn: (productId) => unwrap(client.wishlist.add(productId)),
     onSuccess: () => qc.invalidateQueries({ queryKey: ["behio", "wishlist"] })
   });
-  const removeMutation = useMutation12({
+  const removeMutation = useMutation16({
     mutationFn: (productId) => unwrap(client.wishlist.remove(productId)),
     onSuccess: () => qc.invalidateQueries({ queryKey: ["behio", "wishlist"] })
   });
@@ -1893,7 +3817,7 @@ function useWishlist(options) {
 }
 function useIsInWishlist(productId) {
   const { client } = useBehio();
-  return useQuery33({
+  return useQuery37({
     queryKey: ["behio", "wishlist-check", productId],
     queryFn: () => unwrap(client.wishlist.isInWishlist(productId)),
     enabled: Boolean(productId)
@@ -1901,10 +3825,10 @@ function useIsInWishlist(productId) {
 }
 
 // src/react/hooks/use-reviews.ts
-import { useQuery as useQuery34, useMutation as useMutation13, useQueryClient as useQueryClient13 } from "@tanstack/react-query";
+import { useQuery as useQuery38, useMutation as useMutation17, useQueryClient as useQueryClient17 } from "@tanstack/react-query";
 function useProductReviews(productId, options) {
   const { client } = useBehio();
-  return useQuery34({
+  return useQuery38({
     queryKey: ["behio", "reviews", productId, options?.page ?? 1],
     queryFn: () => unwrap(client.reviews.getProductReviews(productId, options?.page, options?.limit)),
     enabled: Boolean(productId) && (options?.enabled ?? true)
@@ -1912,30 +3836,30 @@ function useProductReviews(productId, options) {
 }
 function useSubmitReview() {
   const { client } = useBehio();
-  const qc = useQueryClient13();
-  return useMutation13({
+  const qc = useQueryClient17();
+  return useMutation17({
     mutationFn: (input) => unwrap(client.reviews.submit(input)),
     onSuccess: (_, input) => qc.invalidateQueries({ queryKey: ["behio", "reviews", input.productId] })
   });
 }
 
 // src/react/hooks/use-returns.ts
-import { useQuery as useQuery35, useMutation as useMutation14 } from "@tanstack/react-query";
+import { useQuery as useQuery39, useMutation as useMutation18 } from "@tanstack/react-query";
 function useLookupReturnableOrder() {
   const { client } = useBehio();
-  return useMutation14({
+  return useMutation18({
     mutationFn: ({ orderNumber, email }) => unwrap(client.returns.lookupOrder(orderNumber, email))
   });
 }
 function useSubmitReturn() {
   const { client } = useBehio();
-  return useMutation14({
+  return useMutation18({
     mutationFn: (input) => unwrap(client.returns.submit(input))
   });
 }
 function useReturnStatus(returnId, email) {
   const { client } = useBehio();
-  return useQuery35({
+  return useQuery39({
     queryKey: ["behio", "return-status", returnId],
     queryFn: () => unwrap(client.returns.getStatus(returnId, email)),
     enabled: Boolean(returnId && email)
@@ -1943,16 +3867,16 @@ function useReturnStatus(returnId, email) {
 }
 
 // src/react/hooks/use-quotes.ts
-import { useMutation as useMutation15, useQuery as useQuery36 } from "@tanstack/react-query";
+import { useMutation as useMutation19, useQuery as useQuery40 } from "@tanstack/react-query";
 function useSubmitQuote() {
   const { client } = useBehio();
-  return useMutation15({
+  return useMutation19({
     mutationFn: (input) => unwrap(client.quotes.submit(input))
   });
 }
 function useQuoteStatus(quoteId, email) {
   const { client } = useBehio();
-  return useQuery36({
+  return useQuery40({
     queryKey: ["behio", "quote-status", quoteId],
     queryFn: () => unwrap(client.quotes.getStatus(quoteId, email)),
     enabled: Boolean(quoteId && email)
@@ -1960,13 +3884,123 @@ function useQuoteStatus(quoteId, email) {
 }
 
 // src/react/hooks/use-back-in-stock.ts
-import { useMutation as useMutation16 } from "@tanstack/react-query";
+import { useMutation as useMutation20 } from "@tanstack/react-query";
 function useNotifyWhenAvailable() {
   const { client } = useBehio();
-  return useMutation16({
+  return useMutation20({
     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 {
+  }
+}
+
+// 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);
+}
 export {
   BehioAnalyticsTracker,
   BehioProvider,
@@ -1995,8 +4029,12 @@ export {
   useCartCount,
   useCategories,
   useCategory,
+  useCertificateVerification,
   useCheckout,
   useCookieConsent,
+  useCourse,
+  useCourseCertificates,
+  useCourses,
   useCrossSell,
   useCurrency,
   useCustomer,
@@ -2006,6 +4044,10 @@ export {
   useGiftCardBalance,
   useIsInWishlist,
   useLabels,
+  useLessonComments,
+  useLessonNote,
+  useLessonQuiz,
+  useLessonTutor,
   useLookupReturnableOrder,
   useLoyalty,
   useMenu,