@behio/storefront-sdk 0.37.0 → 0.41.0

package/dist/react.d.ts

@@ -1,10 +1,7 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { QueryClient } from '@tanstack/react-query';
-import { a as BehioStorefront, P as ProductsQuery, b as PaginatedResponse, c as ProductListItem, d as ProductDetail, C as Category, e as CategoryDetail, M as Menu, f as ProductLabel, F as FilterField, g as FacetsResponse, h as Cart, i as CustomerProfile, R as RegisterInput, j as CustomerAddress, A as AddressSuggestion, k as AddressDetail, L as LoyaltySummary, S as Subscription, l as SubscriptionAction, m as PickupPointsInput, n as PickupPoint, o as ShippingMethodSummary, p as ShippingQuoteInput, q as ShippingQuote, r as CheckoutPaymentMethod, N as NewsletterSubscribeResult, s as NewsletterSubscribeInput, t as NewsletterUnsubscribeResult, O as OrderListItem, u as OrderDetail, v as OrderAccessRequestResponse, w as OrderAccessVerifyResponse, x as CheckoutInput, y as PageDetail, z as Page, D as ShopInfo, E as ShopScripts, G as ShopSeo, H as Bundle, I as ProductGroup, J as CrossSellItem, K as ActivePromotion, Q as GiftCardBalance, W as WishlistItem, T as ProductReviewsResponse, U as SubmitReviewInput, V as ReturnableOrder, X as ReturnStatus, Y as ReturnRequest, Z as SubmitReturnInput, _ as CookieConsent, $ as CookieConsentInput, a0 as QuoteRequest, a1 as SubmitQuoteInput, a2 as BackInStockSubscription } from './client-BgYibdTK.js';
-export { a3 as AddToCartInput, a4 as AuthTokens, a5 as BehioApiError, a6 as BundleItem, a7 as CartDiscount, a8 as CartItem, a9 as CheckoutAddress, aa as FulfillmentStatus, ab as LoginInput, ac as MessageResponse, ad as OrderItem, ae as OrderStatus, af as PaymentStatus, ag as ProductPrice, ah as ProductReview, ai as ProductVariant } from './client-BgYibdTK.js';
 import * as _tanstack_query_core from '@tanstack/query-core';
-export { EcommerceEventName, EcommerceItem, EcommercePayload, formatPrice, generateVisitorId, getStoredVisitorId, grantAnalyticsConsent, revokeAnalyticsConsent, trackEcommerceEvent } from './index.js';
 
 interface StorageAdapter {
     get(key: string): string | null;
@@ -57,6 +54,2760 @@ interface BehioProviderProps {
 }
 declare function BehioProvider({ apiKey, baseUrl, shopDomain, locale, currency, defaultCurrency, currencies, onCurrencyChange, persistCurrency, currencyCookieName, storage: storageOption, queryClient: externalQueryClient, children, }: BehioProviderProps): react_jsx_runtime.JSX.Element;
 
+interface BehioStorefrontConfig {
+    /** API key (public: pk_live_xxx or private: sk_live_xxx) */
+    apiKey: string;
+    /** Backend base URL. Default: https://be.behio.com */
+    baseUrl?: string;
+    /**
+     * The domain this storefront is served on (e.g. "mujshop.cz"), sent as
+     * X-Shop-Domain. Only needed when ONE deployment serves several domains with
+     * a single "all domains" API key (e.g. a Vercel app behind mujshop.cz +
+     * mujshop.sk) AND there's no Origin header (server-side rendering). A
+     * domain-bound key, or a browser request (Origin), doesn't need it.
+     */
+    shopDomain?: string;
+    /** Default locale for catalog requests. Default: none (uses shop default) */
+    locale?: string;
+    /** Default currency for price resolution. Default: none (uses shop default) */
+    currency?: string;
+    /** Custom fetch implementation (for Node.js < 18 or testing) */
+    fetch?: typeof fetch;
+    /** Request timeout in milliseconds. Default: 30000 (30s) */
+    timeout?: number;
+    /** Number of retries on network/5xx errors. Default: 1 */
+    retries?: number;
+    /** Base delay between retries in ms (multiplied by attempt). Default: 1000 */
+    retryDelay?: number;
+}
+interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+interface MessageResponse {
+    message: string;
+}
+/** How the shop wants the newsletter opt-in rendered at checkout. */
+type NewsletterOptInDefault = "CHECKED" | "UNCHECKED" | "HIDDEN";
+/** How sold-out products behave in the catalog. */
+type StockBehavior = "HIDE" | "BACKORDER" | "SHOW_SOLD_OUT";
+/**
+ * Shop-level stock mode preset. ALWAYS_AVAILABLE (reseller) and MADE_TO_ORDER
+ * (production) shops sell regardless of stock: `inStock` is always true,
+ * availability derives to "in-stock" / "on-order" and stock counts are hidden.
+ * Templates can hide stock UI entirely when the mode is not TRACKED.
+ */
+type StockMode = "TRACKED" | "ALWAYS_AVAILABLE" | "MADE_TO_ORDER";
+/**
+ * Merchant-configured checkout & cart rules the storefront MUST honour so the
+ * shop behaves exactly as it was configured in the admin. Mirrors the backend
+ * Eshop settings; the server also enforces the enforceable rules, so these are
+ * for UX (render required fields, consent checkboxes, cart limits, free-shipping
+ * progress) rather than a security boundary.
+ */
+interface CheckoutSettings {
+    /** Guests may order without an account (also on ShopInfo for back-compat). */
+    allowGuestCheckout: boolean;
+    /** Checkout requires a logged-in / registered account. */
+    requireAccount: boolean;
+    /** New registrations wait for merchant approval before ordering (B2B). */
+    requireRegistrationApproval: boolean;
+    /** Phone number is a required checkout field. */
+    requirePhone: boolean;
+    /** Tax id (IČO/DIČ) is a required checkout field. */
+    requireTaxId: boolean;
+    /** Customer may leave an order note. */
+    allowOrderNote: boolean;
+    /** Discount / coupon codes may be applied in the cart. */
+    allowDiscountCodes: boolean;
+    /** Gift cards may be applied in the cart / checkout. */
+    allowGiftCards: boolean;
+    /** Terms & conditions consent checkbox is required to place an order. */
+    requireTermsConsent: boolean;
+    /** GDPR / privacy consent checkbox is required to place an order. */
+    requireGdprConsent: boolean;
+    /** Default state of the newsletter opt-in on the checkout (or hide it). */
+    newsletterOptInDefault: NewsletterOptInDefault;
+    /** Minimum order value in the shop default currency, or null when unset. */
+    minOrderValue: number | null;
+    /** Maximum order value in the shop default currency, or null when unset. */
+    maxOrderValue: number | null;
+    /** Free-shipping threshold (shop default currency) for the cart progress bar. */
+    freeShippingThreshold: number | null;
+    /** Minimum number of items required in the cart to check out. */
+    minItemsInCart: number;
+    /** Maximum quantity of a single product per order, or null when unlimited. */
+    maxItemsPerProduct: number | null;
+    /**
+     * How sold-out products behave. The SERVER enforces the buying rules; the
+     * template mirrors them in UX:
+     * - `HIDE`: sold-out products are already filtered out of browse/search/
+     *   featured responses server-side; PDP direct links still resolve — render
+     *   them as sold out with the buy button disabled.
+     * - `SHOW_SOLD_OUT`: sold-out products render with a "Vyprodáno" state and
+     *   a disabled buy button; the API rejects over-stock adds with a 400.
+     * - `BACKORDER`: out-of-stock products stay purchasable (any quantity);
+     *   render "Na objednávku" instead of disabling the button.
+     * For HIDE/SHOW_SOLD_OUT cap quantity steppers at `stockQuantity` — the
+     * cart API 400s on anything above it.
+     */
+    stockBehavior: StockBehavior;
+    /** Stock mode preset; non-TRACKED shops are always purchasable. */
+    stockMode: StockMode;
+    /**
+     * Merchant enabled the "only X left" nudge. When true, products whose stock
+     * is within `lowStockThreshold` carry `lowStockRemaining` — render the badge
+     * from that field alone (it is null everywhere else).
+     */
+    showLowStock: boolean;
+    /** Stock level at (and below) which the low-stock nudge shows. */
+    lowStockThreshold: number;
+    /** Google Places address autocomplete is enabled; mount the UX when true. */
+    addressAutocompleteEnabled: boolean;
+    /**
+     * How prices are presented to the customer (GAP-30):
+     * - `INCL_VAT` (default, B2C): catalog/cart prices already include VAT; the
+     *   VAT breakdown is the portion contained within.
+     * - `EXCL_VAT` (B2B): prices are net; render "bez DPH" labels and show VAT
+     *   added on top.
+     * - `CUSTOMER_CHOICE`: the customer toggles incl/excl.
+     * Pair with per-line `taxRate` + cart/order `taxBreakdown` to render VAT rows.
+     */
+    priceDisplay: PriceDisplay;
+    /** Shop default VAT rate (percent, e.g. 21) for labelling a single-rate cart. */
+    vatRate: number;
+}
+/** Price presentation mode (Eshop.priceDisplay). See `CheckoutSettings.priceDisplay`. */
+type PriceDisplay = "INCL_VAT" | "EXCL_VAT" | "CUSTOMER_CHOICE";
+interface ShopInfo {
+    id: string;
+    name: string;
+    domain: string;
+    logo?: string;
+    favicon?: string;
+    isActive: boolean;
+    defaultLanguage: string;
+    supportedLanguages: string[];
+    defaultCurrency: string;
+    supportedCurrencies: string[];
+    metaTitle?: string;
+    metaDescription?: string;
+    allowGuestCheckout: boolean;
+    /** Shop runs in B2B / wholesale mode (unlocks B2B-oriented UX). */
+    b2bMode: boolean;
+    /**
+     * Whether quote requests ("Poptat množstevní cenu") make sense for this shop.
+     * Currently follows B2B mode. Gate the request-quote CTA on this flag rather
+     * than hardcoded template config.
+     */
+    quotesEnabled: boolean;
+    /** Full merchant checkout & cart contract. Honour these in cart + checkout. */
+    checkout: CheckoutSettings;
+    /**
+     * Public shop identity for SEO / structured data (GAP-31). Reads of existing
+     * merchant data — feed into the Organization JSON-LD and degrade gracefully
+     * on nulls. Optional because cached ShopInfo payloads predating the field
+     * may still be served.
+     */
+    seo?: ShopSeoIdentity;
+}
+/** Public shop identity for SEO / structured data (GAP-31). */
+interface ShopSeoIdentity {
+    /** Merchant shop description — Organization JSON-LD `description`. */
+    description: string | null;
+    /** Public contact e-mail (shop e-mail sender config) for ContactPoint. */
+    contactEmail: string | null;
+}
+interface NewsletterSubscribeInput {
+    email: string;
+    /** Preferred locale (ISO-639-1) captured at signup. */
+    locale?: string;
+    /** Where the opt-in came from, e.g. "footer" or "checkout". */
+    source?: string;
+    /** Honeypot: keep empty. A filled value is treated as a bot and ignored. */
+    website?: string;
+}
+interface NewsletterSubscribeResult {
+    success: boolean;
+    /** True when this email was already an active subscriber. */
+    alreadySubscribed: boolean;
+}
+interface NewsletterUnsubscribeResult {
+    success: boolean;
+}
+interface ShopSeo {
+    locale: string;
+    title: string | null;
+    description: string | null;
+    keywords: string | null;
+    ogTitle: string | null;
+    ogDescription: string | null;
+    ogImage: string | null;
+}
+/** Kind of merchant-defined script. Typed presets render the right snippet from
+ *  an id; RAW carries literal markup. */
+type ShopScriptType = "GA4" | "GTM" | "META_PIXEL" | "GOOGLE_VERIFICATION" | "RAW";
+/** Where in the document the script is injected. */
+type ShopScriptPlacement = "HEAD" | "BODY_START" | "BODY_END";
+/**
+ * A merchant-defined script delivered to the storefront for injection
+ * (analytics, pixels, verification, or arbitrary head/body markup).
+ * `value` is the id for typed entries, or the literal markup for RAW.
+ * When `consentRequired` is true the storefront must gate it behind the
+ * visitor's analytics cookie consent.
+ */
+interface ShopScript {
+    id: string;
+    type: ShopScriptType;
+    placement: ShopScriptPlacement;
+    value: string;
+    consentRequired: boolean;
+}
+interface ShopScripts {
+    scripts: ShopScript[];
+}
+/**
+ * Money amount displayed to a customer in a chosen currency.
+ *
+ * Two cases:
+ *  - **Fixed price** (preferred): merchant configured an explicit price for
+ *    this currency. `isApproximate` is `false`/absent and `fxSource` is `null`.
+ *  - **Approximate / FX-converted**: no fixed price for the requested
+ *    currency, so Behio converted from the eshop's default currency using
+ *    today's rate from `fxSource` (CNB or Frankfurter/ECB) plus the eshop's
+ *    safety margin. UI should show a `≈` hint and offer the base price too.
+ */
+/**
+ * Payment method available at checkout. Returned by
+ * `GET /storefront/v1/catalog/payment-methods` filtered for the customer's
+ * chosen currency. Credentials (API keys, merchant ids) stay server-side
+ * — only customer-safe fields appear here.
+ */
+interface CheckoutPaymentMethod {
+    id: string;
+    /** Merchant-chosen label, e.g. "Kartou (Stripe)" or "Převodem na účet". */
+    name: string;
+    description?: string | null;
+    /** Provider id: "stripe" | "gopay" | "comgate" | "bank_transfer" | "cod" | "custom". */
+    provider: string;
+    /** Currencies this method accepts. Empty = any. */
+    currencies: string[];
+    /** Optional fee added to the order total (e.g. COD surcharge). */
+    fee?: number | null;
+    feeCurrency?: string | null;
+    /** Customer-safe slice of config: bank account, IBAN, instructions, … */
+    publicConfig?: Record<string, unknown>;
+}
+interface ProductPrice {
+    amount: number;
+    currency: string;
+    compareAtPrice?: number | null;
+    /** `true` when this amount was FX-converted from the eshop default currency. */
+    isApproximate?: boolean;
+    /** Provider id ("cnb" | "frankfurter" | "manual") when FX-converted. */
+    fxSource?: string | null;
+    /** Original amount in the eshop default currency before conversion. */
+    baseAmount?: number | null;
+    /** ISO code of the currency `baseAmount` is denominated in. */
+    baseCurrency?: string | null;
+}
+interface ProductVolumePrice {
+    minQuantity: number;
+    price: number;
+    currency?: string;
+}
+interface ProductVariant {
+    /**
+     * Eshop product ID of this variant (each variant is its own sellable eshop
+     * product). Pass it straight to `cart.addItem({productId: variant.id})` to add
+     * the chosen variant.
+     */
+    id: string;
+    sku: string;
+    name: string;
+    /**
+     * Axis name/value pairs identifying this variant (e.g.
+     * `[{name: 'Barva', value: 'červená'}]`) — matches the wire shape the API
+     * actually sends. Join to `ProductDetail.variantAxes` by name + value.
+     */
+    attributes: Array<{
+        name: string;
+        value: string;
+    }>;
+    /** `null` when prices are gated behind login for guests (B2B mode). */
+    price: ProductPrice | null;
+    inStock: boolean;
+    /** Exact remaining stock, or `null` when the merchant hides the count
+     *  (showStockCount off) — treat null as "unknown", never as 0. */
+    stockQuantity?: number | null;
+    /** "Only X left" for this variant — same contract as ProductListItem.lowStockRemaining. */
+    lowStockRemaining?: number | null;
+    /**
+     * Cover image URL for the variant. Falls back to the parent product's
+     * cover when the variant has no photo of its own — see `imageIsInherited`.
+     */
+    imageUrl?: string | null;
+    /**
+     * `true` when `imageUrl` is borrowed from the parent product because the
+     * variant has no cover image of its own. Use this to render a hint like
+     * "default photo" or to render the picture in a subtler style.
+     */
+    imageIsInherited: boolean;
+}
+interface ProductLabel {
+    id: string;
+    slug: string;
+    name: string;
+    color?: string;
+}
+/**
+ * Resolved availability status of a product. Either a merchant preset
+ * ("skladem", "na objednávku", "předobjednávka", custom) or, when the product
+ * has none assigned, a status DERIVED from stock server-side. Render `label`
+ * as-is — it is already localized to the requested locale.
+ */
+interface ProductAvailability {
+    /**
+     * Stable machine code for styling hooks: a merchant preset slug (e.g.
+     * "preorder") or the derived `"in-stock"` / `"sold-out"`.
+     */
+    code: string;
+    /** Localized display label (requested locale → shop default → slug). */
+    label: string;
+    /** Optional merchant-configured hex badge color (e.g. "#f59e0b"). */
+    color?: string | null;
+    /**
+     * "Available from" date (epoch ms) for preorder / on-order style states.
+     * Render as "Skladem od 20. 7." when present; null when not scheduled.
+     */
+    restockAt?: number | null;
+}
+interface ProductListItem {
+    id: string;
+    slug: string;
+    name: string;
+    shortDescription?: string;
+    sku: string;
+    gtin?: string;
+    /** `null` when prices are gated behind login for guests (B2B mode). */
+    price: ProductPrice | null;
+    inStock: boolean;
+    /**
+     * Launch okno: sale window opens at this time (epoch ms); null/undefined =
+     * on sale since publish. Before it the product is visible but NOT
+     * purchasable — render a "Prodej startuje za ..." countdown instead of the
+     * buy button.
+     */
+    saleStartAt?: number | null;
+    /** Sale window closes at this time (epoch ms); null/undefined = never closes. */
+    saleEndAt?: number | null;
+    /**
+     * Server-resolved "can this be bought RIGHT NOW": the sale window is open
+     * AND the product can be ordered (in stock, or the shop sells beyond
+     * stock). The cart/checkout enforce the same rule server-side — use this to
+     * disable the buy button, never re-derive the rule client-side.
+     */
+    isPurchasable: boolean;
+    /**
+     * Early bird (time-based launch price) is active: `price.amount` already IS
+     * the discounted early-bird amount and the regular price sits in
+     * `price.compareAtPrice`. Applies in the eshop default currency only.
+     */
+    earlyBirdActive: boolean;
+    /** When the active early bird ends (epoch ms) — render "Early bird do ...".
+     *  Null when no early bird is active. */
+    earlyBirdUntil?: number | null;
+    /** Exact remaining stock, or `null` when the merchant hides the count
+     *  (showStockCount off) — treat null as "unknown", never as 0. */
+    stockQuantity?: number | null;
+    /**
+     * "Zbývá posledních X kusů" nudge, computed SERVER-side. Non-null ONLY when
+     * the merchant enabled the low-stock indicator AND 0 < stock <= threshold;
+     * the value is the exact remaining quantity. Render the badge whenever this
+     * is a number — no client-side threshold math needed.
+     */
+    lowStockRemaining?: number | null;
+    /** Resolved availability status (merchant preset or derived from stock). */
+    availability: ProductAvailability;
+    /** Cover image of the listing. The API returns an object (url + alt + order), never a bare string. */
+    image?: {
+        url: string;
+        alt: string | null;
+        order: number;
+    } | null;
+    labels: ProductLabel[];
+    isFeatured: boolean;
+    /**
+     * Minimum order quantity (units); null/undefined = no minimum. Start the
+     * quantity stepper here — the server rejects add-to-cart / checkout below it.
+     */
+    minOrderQuantity?: number | null;
+    /**
+     * Order quantity step / multiple (units); null/undefined = any quantity. The
+     * stepper moves by this amount and the server rejects non-multiple quantities.
+     */
+    orderQuantityStep?: number | null;
+    /**
+     * Cheapest applicable auto-promotion for this product (GAP-13), or null. Same
+     * priority-based selection the checkout uses, so a card badge matches what the
+     * customer pays. Render a badge chip + a STATIC end date ("do 20. 7.") on
+     * cards; keep the live countdown on the PDP only (no per-card tickers).
+     */
+    activePromotion?: ProductPromotionSummary | null;
+    /**
+     * Rollover image URL for the card (GAP-27), from the product's HOVER-role
+     * image when the merchant set one. Null/absent = no hover image (show the
+     * cover only). Crossfade to it on desktop hover (opacity only, no transform).
+     */
+    hoverImageUrl?: string | null;
+    /**
+     * Aggregate rating from APPROVED reviews (GAP-23): mean 1-5 rating, or null
+     * when the product has no approved reviews. Server-computed + cached. Render
+     * gold stars only when `ratingCount > 0`; do NOT compute this from the
+     * paginated reviews endpoint.
+     */
+    ratingAverage?: number | null;
+    /** Number of approved reviews behind `ratingAverage` (0 when none). */
+    ratingCount?: number;
+    /**
+     * Last modification of the product record (epoch ms) — sitemap `lastmod`
+     * and `dateModified` structured data (GAP-31).
+     */
+    updatedAt?: number;
+}
+/** Display-only summary of the promotion winning for a card (GAP-13). */
+interface ProductPromotionSummary {
+    promotionId: string;
+    /** Merchant badge label ("1+1"); null → render "-{discountValue} %" from the discount. */
+    badgeText: string | null;
+    /** Merchant hex badge color; null falls back to the shop's sale color. */
+    badgeColor: string | null;
+    discountType: "PERCENTAGE" | "FIXED_AMOUNT" | "BUY_X_GET_Y";
+    discountValue: number;
+    /** Promotion end (epoch ms), or null for open-ended. */
+    endsAt: number | null;
+    /** Merchant opted into a countdown (the PDP shows a ticker; cards stay static). */
+    showCountdown: boolean;
+}
+/** A single responsive derivative (size + format) of a media image. */
+interface ProductMediaVariant {
+    variant: "thumb" | "medium" | "large" | "xlarge";
+    format: "jpeg" | "webp" | "avif";
+    url: string;
+    width: number;
+    height: number;
+}
+/**
+ * A product gallery entry (image or video), sourced from the inventory item
+ * so it is shared across every storefront listing the product. Images carry
+ * responsive `variants` (webp/avif/jpeg in three sizes) for fast LCP; pick
+ * the smallest format the client supports.
+ */
+interface ProductMedia {
+    id: string;
+    type: "IMAGE" | "VIDEO";
+    /** Original uploaded file URL. */
+    url: string;
+    alt?: string | null;
+    isCover: boolean;
+    order: number;
+    variants: ProductMediaVariant[];
+}
+/** One value on a variant axis, with optional merchant-configured swatch data. */
+interface VariantAxisValue {
+    /** Human-readable value; matches `variant.attributes[].value` on this axis. */
+    value: string;
+    /** Hex color for SWATCH_COLOR rendering. */
+    swatchColor: string | null;
+    /** Image URL for SWATCH_IMAGE rendering. */
+    swatchImage: string | null;
+}
+/**
+ * A variant axis ("Barva", "Velikost") with the merchant's display
+ * configuration. `displayType` is "BUTTON" when the merchant has not
+ * configured the axis (the storefront's historical default). Join to
+ * `variants[].attributes` by axis `name` + `value`.
+ */
+interface VariantAxis {
+    name: string;
+    displayType: "DROPDOWN" | "BUTTON" | "SWATCH_COLOR" | "SWATCH_IMAGE";
+    order: number;
+    /** Values present among the purchasable variants, in admin-defined order. */
+    values: VariantAxisValue[];
+}
+/**
+ * One custom-field (data-group value) rendered as a spec-table row. BOOLEAN
+ * carries a typed `booleanValue` (value is null) so the storefront can localize
+ * Ano/Ne; MONEY carries its currency in `unit`; PERCENTAGE carries "%" in
+ * `unit`.
+ */
+interface ProductCustomField {
+    key: string;
+    name: string;
+    /** TEXT | NUMBER | DECIMAL | BOOLEAN | DATE | TIME | DATETIME | PERCENTAGE | MONEY | ITEM_LIST | ... */
+    type: string;
+    value: string | null;
+    booleanValue: boolean | null;
+    unit: string | null;
+}
+/** A spec-table section (one inventory data group) with its fields. */
+interface ProductCustomFieldGroup {
+    key: string;
+    name: string;
+    fields: ProductCustomField[];
+}
+interface ProductDetail extends ProductListItem {
+    longDescription?: string;
+    /**
+     * @deprecated Legacy per-listing images. Prefer `media`. Each carries its
+     * `role` (COVER | LISTING | HOVER | GALLERY) so the storefront can pick a
+     * specific image deliberately (GAP-27).
+     */
+    images: Array<{
+        url: string;
+        alt?: string;
+        order: number;
+        role?: string;
+    }>;
+    /** Product gallery (images + videos) with responsive derivatives. */
+    media: ProductMedia[];
+    categories: Array<{
+        id: string;
+        slug: string;
+        name: string;
+    }>;
+    variants: ProductVariant[];
+    /**
+     * Variant axes with display config (dropdown / buttons / swatches).
+     * Empty when the product has no variants.
+     */
+    variantAxes: VariantAxis[];
+    volumePricing: ProductVolumePrice[];
+    /**
+     * Structured product parameters from custom fields (inventory data groups),
+     * grouped into spec-table sections (GAP-12). Empty when the product has no
+     * data-group values. Distinct from `longDescription` (free HTML): this is
+     * machine-readable key/value data for a "Parametry" table + comparison
+     * engines. (Corrected from the old untyped `Record<string, unknown>` — the
+     * API never populated that; it now sends this structured shape.)
+     */
+    customFields: ProductCustomFieldGroup[];
+    seo: {
+        title?: string | null;
+        description?: string | null;
+        keywords?: string | null;
+        ogTitle?: string | null;
+        ogDescription?: string | null;
+        ogImage?: string | null;
+    };
+    productGroups?: Array<{
+        slug: string;
+        name: string;
+        products: ProductListItem[];
+    }>;
+    /** Product weight (from warehouse item) */
+    weight?: number | null;
+    /** Weight unit: GRAM, KILOGRAM, TONNE */
+    weightUnit?: string | null;
+    /**
+     * Digital product delivery (GAP-07): true when the product has at least one
+     * active digital asset (PDF, MP3, ...) delivered instantly after purchase.
+     */
+    isDigital?: boolean;
+}
+interface Category {
+    id: string;
+    slug: string;
+    name: string;
+    description?: string;
+    imageUrl?: string;
+    children: Category[];
+    productCount?: number;
+}
+/**
+ * Navigation menu built in the admin (Navigace). Matches the backend
+ * `GET /storefront/v1/catalog/menu/{handle}` response exactly. Item labels are
+ * resolved in the requested locale; typed refs resolve to {type, slug} at read
+ * time so category/page/product renames flow through automatically.
+ */
+type MenuItemType = "CATEGORY" | "PAGE" | "LINK" | "COLLECTION" | "PRODUCT";
+/** Resolved target of a typed menu item. Null on LINK items (use `url`). */
+interface MenuItemRef {
+    type: MenuItemType;
+    slug: string;
+}
+/**
+ * Badge tone preset for a menu item chip. Maps to storefront design tokens on
+ * the template side (SALE -> danger, NEW -> success, ACCENT -> primary,
+ * NEUTRAL -> current text color). Custom hex colors override the preset.
+ */
+type BadgeTone = "NEUTRAL" | "SALE" | "NEW" | "ACCENT";
+interface MenuItem {
+    id: string;
+    type: MenuItemType;
+    /** Resolved label in the requested locale. */
+    label: string;
+    description?: string | null;
+    /** LINK items only: the raw URL to navigate to. Null on typed items. */
+    url?: string | null;
+    /** Typed items (CATEGORY/PAGE/COLLECTION/PRODUCT): resolved {type, slug}. Null on LINK. */
+    ref?: MenuItemRef | null;
+    /** Optional badge chip text (e.g. "Novinka", "Sleva"). */
+    badgeText?: string | null;
+    /**
+     * Badge tone preset driving the chip colors from storefront tokens. Always
+     * present. Custom `badgeColor`/`badgeTextColor` override it when set.
+     */
+    badgeTone: BadgeTone;
+    /** Custom badge background hex (overrides `badgeTone`), or null. */
+    badgeColor?: string | null;
+    /** Custom badge text hex, or null. */
+    badgeTextColor?: string | null;
+    /** Custom hex for the item label text itself, or null to inherit. */
+    labelColor?: string | null;
+    /** Lucide icon slug rendered next to the label, or null. */
+    icon?: string | null;
+    /** Emphasize this item (bold/accent). */
+    isHighlighted: boolean;
+    /** LINK items: open the target in a new browser tab. Always false on typed items. */
+    openInNewTab: boolean;
+    /** Processed image URL for mega-menu tiles (null when no image set). */
+    imageUrl?: string | null;
+    /** Nested items, up to depth 3. */
+    children: MenuItem[];
+}
+interface Menu {
+    handle: string;
+    name: string;
+    /** Locale the labels are resolved in. */
+    locale: string;
+    items: MenuItem[];
+}
+interface CategoryDetail extends Category {
+    /**
+     * SEO/Open Graph for the category page. Matches the backend's nested `seo`
+     * shape (the old flat `seoTitle`/`seoDescription` never matched what the API
+     * returned). `keywords` is always null for categories.
+     */
+    seo?: {
+        title?: string | null;
+        description?: string | null;
+        keywords?: string | null;
+        ogTitle?: string | null;
+        ogDescription?: string | null;
+        ogImage?: string | null;
+    };
+}
+type DataGroupFieldType = "TEXT" | "NUMBER" | "DECIMAL" | "BOOLEAN" | "DATE" | "TIME" | "DATETIME" | "PERCENTAGE" | "MONEY" | "ASSET" | "ITEM_LIST" | "DYNAMIC_NUMBER_CALCULATION_FROM_OTHERS";
+interface FilterField {
+    key: string;
+    name: string;
+    type: DataGroupFieldType | string;
+    groupKey: string;
+    groupName: string;
+    values?: string[];
+}
+interface FacetValue {
+    /** Raw stored value (normalized), for exact filtering. */
+    value: string;
+    /** Human-readable label. */
+    label: string;
+    /** Stable URL slug for SEO landing pages (e.g. "cerna"); pass back via
+     *  `ProductsQuery.facets`. */
+    slug: string;
+    /** Count under the current selection (this facet excluded). 0 = present in
+     *  context but excluded by other filters — render disabled, don't hide. */
+    count: number;
+}
+interface FacetRange {
+    min: number | null;
+    max: number | null;
+}
+interface Facet {
+    key: string;
+    name: string;
+    /** "enum" (checkboxes), "range" (slider) or "boolean". */
+    type: "enum" | "range" | "boolean" | string;
+    groupKey: string;
+    groupName: string;
+    /** Underlying data-group field type (TEXT, NUMBER, MONEY, ...). */
+    fieldType: string;
+    /** enum/boolean facets: selectable values with counts. */
+    values?: FacetValue[];
+    /** range facets: numeric bounds within the current context. */
+    range?: FacetRange | null;
+    /** currency for MONEY range facets, "%" for PERCENTAGE, else null. */
+    unit?: string | null;
+}
+interface FacetPriceRange {
+    min: number | null;
+    max: number | null;
+    currency: string;
+}
+interface FacetRatingBucket {
+    from: number;
+    count: number;
+}
+interface FacetLabel {
+    slug: string;
+    name: string;
+    color?: string | null;
+    count: number;
+}
+interface FacetCategory {
+    slug: string;
+    name: string;
+    count: number;
+}
+interface FacetAvailability {
+    inStockCount: number;
+    outOfStockCount: number;
+}
+interface FacetsResponse {
+    priceRange: FacetPriceRange | null;
+    facets: Facet[];
+    availability: FacetAvailability;
+    rating: FacetRatingBucket[];
+    labels: FacetLabel[];
+    /** Child subcategories of the current category (or top-level), with counts. */
+    categories: FacetCategory[];
+}
+declare const ProductSort: {
+    readonly PRICE_ASC: "price_asc";
+    readonly PRICE_DESC: "price_desc";
+    readonly NAME_ASC: "name_asc";
+    readonly NAME_DESC: "name_desc";
+    readonly NEWEST: "newest";
+    readonly FEATURED: "featured";
+    readonly BESTSELLING: "bestselling";
+    readonly RATING: "rating";
+};
+type ProductSortValue = (typeof ProductSort)[keyof typeof ProductSort];
+declare const OrderStatuses: {
+    readonly PENDING: "PENDING";
+    readonly CONFIRMED: "CONFIRMED";
+    readonly PROCESSING: "PROCESSING";
+    readonly SHIPPED: "SHIPPED";
+    readonly DELIVERED: "DELIVERED";
+    readonly CANCELLED: "CANCELLED";
+    readonly REFUNDED: "REFUNDED";
+};
+declare const PaymentStatuses: {
+    readonly UNPAID: "UNPAID";
+    readonly PAID: "PAID";
+    readonly PARTIALLY_REFUNDED: "PARTIALLY_REFUNDED";
+    readonly REFUNDED: "REFUNDED";
+};
+declare const FulfillmentStatuses: {
+    readonly UNFULFILLED: "UNFULFILLED";
+    readonly PARTIALLY_FULFILLED: "PARTIALLY_FULFILLED";
+    readonly FULFILLED: "FULFILLED";
+};
+declare const AddressTypes: {
+    readonly SHIPPING: "SHIPPING";
+    readonly BILLING: "BILLING";
+};
+type AddressType = (typeof AddressTypes)[keyof typeof AddressTypes];
+interface ProductsQuery {
+    page?: number;
+    limit?: number;
+    /** Single category slug (OR logic with categories array) */
+    category?: string;
+    /** Multiple category slugs (OR logic — product in ANY of these categories) */
+    categories?: string[];
+    /** Single label slug */
+    label?: string;
+    priceMin?: number;
+    priceMax?: number;
+    currency?: string;
+    locale?: string;
+    sort?: ProductSortValue;
+    inStock?: boolean;
+    /** Minimum aggregate rating, e.g. 4 for "4 and up". */
+    ratingMin?: number;
+    search?: string;
+    /** Custom-field filters. A value may be an array = multi-select (OR within
+     *  the key), e.g. {"barva": ["cerna", "bila"]}. */
+    customFields?: Record<string, string | number | boolean | string[] | unknown>;
+    /** Slug-based facet selection for SEO URLs: facet key -> value slugs, e.g.
+     *  {"barva": ["cerna"]}. Resolved server-side to the underlying values. */
+    facets?: Record<string, string[]>;
+    /** Filter by specific product IDs (comma-separated in URL) */
+    ids?: string[];
+    /** Filter by specific product slugs */
+    slugs?: string[];
+    /** Multiple labels (AND logic — product must have ALL) */
+    labels?: string[];
+    /** Exclude specific product IDs (e.g. for "related products" excluding current) */
+    excludeIds?: string[];
+    /** Exclude products in specific categories */
+    excludeCategories?: string[];
+    /** Only products with compareAtPrice (on sale) */
+    hasDiscount?: boolean;
+    /** Only featured products */
+    isFeatured?: boolean;
+    /** Products created after timestamp (epoch ms) */
+    createdAfter?: number;
+}
+interface AuthTokens {
+    accessToken: string;
+    refreshToken: string;
+}
+/**
+ * Result of a registration. When the eshop requires admin approval,
+ * `pendingApproval` is true and the tokens are null (the account is created but
+ * inactive and can't log in until approved) — the storefront should show a
+ * "waiting for approval" message instead of a logged-in session.
+ */
+interface RegisterResult {
+    pendingApproval: boolean;
+    accessToken: string | null;
+    refreshToken: string | null;
+}
+interface RegisterInput {
+    email: string;
+    password: string;
+    firstName?: string;
+    lastName?: string;
+}
+interface LoginInput {
+    email: string;
+    password: string;
+}
+interface CartItemProduct {
+    slug: string;
+    name: string;
+    sku: string;
+    imageUrl?: string;
+    inStock: boolean;
+    currentPrice: number;
+    /** Minimum order quantity (units); null = no minimum. Clamp the cart
+     *  stepper's lower bound to this (GAP-48). */
+    minOrderQuantity?: number | null;
+    /** Order quantity step/multiple (units); null = any. Move the cart stepper
+     *  by this amount so quantities stay valid. */
+    orderQuantityStep?: number | null;
+}
+interface CartItem {
+    id: string;
+    /**
+     * Eshop product ID of the sellable unit on this line. A variant is its own
+     * product, so this is the exact product/variant the customer added — use it
+     * to deep-link back to the product page.
+     */
+    productId: string;
+    product: CartItemProduct;
+    quantity: number;
+    unitPrice: number;
+    totalPrice: number;
+    priceChanged: boolean;
+    volumePriceApplied: boolean;
+    /** VAT rate for this line in percent (e.g. 21). Estimated from the shop /
+     *  product rate; refined by the shipping country at checkout (GAP-30). */
+    taxRate: number;
+    /** Net amount for this line (without VAT) = totalPrice. */
+    netAmount: number;
+    /** VAT amount for this line at `taxRate`. */
+    taxAmount: number;
+    /** Gross amount for this line (net + VAT). */
+    grossAmount: number;
+}
+/** One VAT rate's slice of a cart or order (GAP-30). Render "DPH {rate} %:
+ *  {taxAmount}" summary rows from these. `netAmount + taxAmount = grossAmount`. */
+interface TaxBreakdownLine {
+    /** VAT rate in percent, e.g. 21 or 12 or 0. */
+    rate: number;
+    /** Base amount (net, without VAT) taxed at this rate. */
+    netAmount: number;
+    /** VAT amount charged at this rate. */
+    taxAmount: number;
+    /** Gross amount (net + VAT) at this rate. */
+    grossAmount: number;
+}
+interface CartDiscount {
+    code: string;
+    type: string;
+    value: number;
+}
+/** One automatically applied promotion, surfaced as a discount line on the cart.
+ *  Covers PERCENTAGE / FIXED_AMOUNT / BUY_X_GET_Y promos; the amount is already
+ *  netted into `grandTotal`. */
+interface CartPromotion {
+    slug: string;
+    name: string;
+    /** Total money saved on the cart by this promotion. */
+    discountAmount: number;
+}
+interface Cart {
+    id: string;
+    sessionToken?: string;
+    items: CartItem[];
+    subtotal: number;
+    discountTotal: number;
+    discount?: CartDiscount;
+    /** Auto-apply promotion discount lines (sale/BOGO). */
+    appliedPromotions: CartPromotion[];
+    /** Sum of `appliedPromotions[].discountAmount`; already reflected in `grandTotal`. */
+    promotionDiscountTotal: number;
+    grandTotal: number;
+    /** Total VAT contained in / added to the cart across all lines (GAP-30). An
+     *  estimate finalized at checkout once the shipping country is known. */
+    taxTotal: number;
+    /** VAT split by rate for "DPH 21 %: X Kč" summary rows. Empty for a
+     *  non-VAT-payer shop. */
+    taxBreakdown: TaxBreakdownLine[];
+    currency: string;
+    itemCount: number;
+    /** Applied gift cards (multi). They deduct at checkout (consumed in order, each
+     *  min(balance, remaining due), last one partially), so they do not change
+     *  `grandTotal` here; use them to list applied cards + balances in the cart. */
+    giftCards: GiftCardSummary[];
+    /** Bundle lines in the cart, separate from `items`. Manage with
+     *  `cart.updateBundleQuantity` / `cart.removeBundle`. */
+    bundleLines: CartBundleLine[];
+}
+/** One product inside a bundle line. */
+interface CartBundleLineItem {
+    productId: string;
+    name: string;
+    sku: string;
+    quantity: number;
+}
+/** A bundle added to the cart, with its own quantity + price snapshot. */
+interface CartBundleLine {
+    id: string;
+    bundleId: string;
+    bundleSlug: string;
+    bundleName: string;
+    quantity: number;
+    /** Snapshot of the bundle's per-unit price when it was added. */
+    bundlePriceSnapshot: number;
+    currency: string;
+    items: CartBundleLineItem[];
+}
+/** A gift card applied to the cart, with its current balance. */
+interface GiftCardSummary {
+    code: string;
+    balance: number;
+    currency: string;
+}
+interface AddToCartInput {
+    /**
+     * Eshop product ID of the sellable unit. A variant is its own eshop product,
+     * so to add a chosen variant just pass that variant's `id` (from
+     * `ProductDetail.variants[].id`) here — there is no separate variant field.
+     */
+    productId: string;
+    quantity: number;
+}
+interface CheckoutAddress {
+    firstName: string;
+    lastName: string;
+    company?: string;
+    /** Company registration number (IČO). Required when `ShopInfo.checkout`
+     *  requires tax ids; loosely validated (6-12 digits). */
+    companyId?: string;
+    /** VAT id (DIČ). Required alongside `companyId` when tax ids are required;
+     *  loosely validated (optional 2-letter country prefix + 6-12 digits). */
+    vatId?: string;
+    street: string;
+    city: string;
+    zip: string;
+    country: string;
+    phone?: string;
+}
+interface CheckoutInput {
+    /**
+     * Consent-gated Behio Analytics visitor id (behio_visitor_id). Optional;
+     * lets the backend attribute the order to the visitor journey. Send it only
+     * when the visitor granted analytics consent.
+     */
+    analyticsVisitorId?: string;
+    shippingAddress: CheckoutAddress;
+    billingAddress: CheckoutAddress;
+    email: string;
+    phone?: string;
+    customerNote?: string;
+    /**
+     * Legal / marketing consent echoed from the checkout checkboxes. Render the
+     * boxes from `ShopInfo.checkout` (requireTermsConsent / requireGdprConsent /
+     * newsletterOptInDefault) and send the customer's choice. The backend rejects
+     * the order when a required consent is not `true`.
+     */
+    termsConsent?: boolean;
+    gdprConsent?: boolean;
+    newsletterOptIn?: boolean;
+    /**
+     * Chosen shipping method. Required whenever the eshop has at least one
+     * enabled shipping method — the backend rejects the order without it.
+     * Prefer also sending `shippingQuoteId` from `shipping.quote()`; with only
+     * the method id the backend re-quotes the cart server-side.
+     */
+    shippingMethodId?: string;
+    /**
+     * Quote id from `shipping.quote()` — pins the exact server-computed price
+     * the customer saw. Expired quotes are re-quoted automatically; a consumed
+     * or foreign quote is rejected.
+     */
+    shippingQuoteId?: string;
+    /**
+     * Chosen pickup point `externalId` from `shipping.getPickupPoints()`.
+     * REQUIRED when the resolved shipping method has `supportsPickupPoints`;
+     * the backend rejects the order without it. Snapshotted onto the order.
+     */
+    pickupPointId?: string;
+    paymentMethodId?: string;
+    /**
+     * Loyalty points to redeem on this order. Validated server-side against the
+     * customer's actual balance and the program's redemption cap; ignored for
+     * guests. See `customer.getLoyalty()` for the available balance.
+     */
+    redeemLoyaltyPoints?: number;
+}
+type OrderStatus = (typeof OrderStatuses)[keyof typeof OrderStatuses];
+type PaymentStatus = (typeof PaymentStatuses)[keyof typeof PaymentStatuses];
+type FulfillmentStatus = (typeof FulfillmentStatuses)[keyof typeof FulfillmentStatuses];
+interface OrderListItem {
+    id: string;
+    orderNumber: string;
+    status: OrderStatus;
+    paymentStatus: PaymentStatus;
+    grandTotal: number;
+    currency: string;
+    itemCount: number;
+    createdAt: number;
+}
+interface OrderItem {
+    productName: string;
+    sku: string;
+    imageUrl?: string;
+    quantity: number;
+    unitPrice: number;
+    totalPrice: number;
+    totalPriceWithTax: number;
+}
+/**
+ * PII-minimized order view returned by `orders.track(token)`. The tracking
+ * token is shared in URLs and e-mails, so this deliberately omits full
+ * address, phone, billing and customer note, and masks the email.
+ */
+interface OrderTracking {
+    orderNumber: string;
+    status: OrderStatus;
+    paymentStatus: PaymentStatus;
+    fulfillmentStatus: FulfillmentStatus;
+    currency: string;
+    grandTotal: number;
+    /** Masked, e.g. "j***@e***.cz" */
+    emailMasked: string;
+    shippingCity: string | null;
+    shippingCountry: string | null;
+    items: OrderItem[];
+    createdAt: number;
+}
+interface OrderStatusHistory {
+    fromStatus?: OrderStatus;
+    toStatus: OrderStatus;
+    note?: string;
+    changedBy?: string;
+    createdAt: number;
+}
+interface OrderDetail extends OrderListItem {
+    items: OrderItem[];
+    shippingAddress: CheckoutAddress;
+    billingAddress: CheckoutAddress;
+    email: string;
+    phone?: string;
+    customerNote?: string;
+    subtotal: number;
+    taxTotal: number;
+    /** VAT split by rate (GAP-30), summed from the order lines. Render
+     *  "DPH 21 %: X Kč" rows. Empty for a non-VAT order. */
+    taxBreakdown: TaxBreakdownLine[];
+    shippingTotal: number;
+    discountTotal: number;
+    fulfillmentStatus: FulfillmentStatus;
+    statusHistory: OrderStatusHistory[];
+    trackingToken?: string;
+    /**
+     * Digital product delivery (GAP-07): download grants for any digital assets
+     * on this order. Populated only for PAID orders; empty otherwise. Mint a
+     * short-lived signed URL with `customer.getDownloadUrl(id)` (logged in) or the
+     * guest order-access URL flow.
+     */
+    downloads: DigitalDownload[];
+    /**
+     * For redirect payment gateways (GoPay, ...), the hosted URL the
+     * storefront must send the customer to in order to pay. Present only on
+     * the order returned by `checkout.createOrder()`. Null/absent for
+     * offline methods (bank transfer, COD) and zero-total orders.
+     */
+    paymentRedirectUrl?: string | null;
+}
+/** Generic response to `orders.requestAccessCode` — never reveals existence. */
+interface OrderAccessRequestResponse {
+    success: boolean;
+    message: string;
+}
+/** Response to a successful `orders.verifyAccessCode`. */
+interface OrderAccessVerifyResponse {
+    /** Short-lived JWT scoped to this single order (use with `getByAccessToken`). */
+    accessToken: string;
+    /** Token lifetime in seconds. */
+    expiresIn: number;
+    order: OrderDetail;
+}
+/**
+ * A download grant: the right to fetch one digital asset (PDF, MP3, ...) that
+ * a customer purchased. Enforced budget: `downloadCount` of `maxDownloads`
+ * (null = unlimited), optional `expiresAt`.
+ */
+interface DigitalDownload {
+    id: string;
+    /** Order this grant originates from (null for legacy/manual grants). */
+    orderId: string | null;
+    fileName: string;
+    /** Localized product name the file belongs to (may be null). */
+    productName: string | null;
+    /** Product slug for linking back to the PDP (may be null). */
+    productSlug: string | null;
+    fileSize: number;
+    mimeType: string;
+    version: string | null;
+    downloadCount: number;
+    /** Max downloads allowed (null = unlimited). */
+    maxDownloads: number | null;
+    /** Remaining downloads (null = unlimited). */
+    remainingDownloads: number | null;
+    lastDownloadAt: number | null;
+    /** Access expiry (epoch ms, null = never expires). */
+    expiresAt: number | null;
+    isExpired: boolean;
+    isMaxedOut: boolean;
+    createdAt: number;
+}
+/** One enrolled course on the customer's "My courses" list. */
+interface CourseListItem {
+    courseId: string;
+    /** Localized course (product) name, best-effort. */
+    name: string | null;
+    /** Product slug for linking to the PDP. */
+    slug: string;
+    imageUrl: string | null;
+    totalLessons: number;
+    completedLessons: number;
+    enrolledAt: number;
+    /** Access expiry (epoch ms, null = never expires). */
+    expiresAt: number | null;
+    isExpired: boolean;
+    /**
+     * Course content opens at this time (epoch ms); null/undefined = already
+     * open. While in the future, render "Startujeme ..." + countdown.
+     */
+    contentAvailableFrom?: number | null;
+}
+/** Downloadable attachment on a course lesson. */
+interface CourseAttachment {
+    name: string;
+    url: string;
+    fileSize?: number;
+}
+/**
+ * One lesson in the course player. Locked lessons (drip unlocking) expose
+ * only the title and `unlockAt` — `videoUrl`/`content`/`attachments` are
+ * null/empty until the lesson unlocks server-side.
+ */
+interface CourseLesson {
+    id: string;
+    title: string;
+    isPreview: boolean;
+    isUnlocked: boolean;
+    /** When a locked lesson unlocks (epoch ms). Null once unlocked. */
+    unlockAt: number | null;
+    isCompleted: boolean;
+    videoUrl: string | null;
+    content: string | null;
+    attachments: CourseAttachment[];
+    /**
+     * Number of quiz questions on this lesson (0 = no quiz). Load the quiz via
+     * `customer.getLessonQuiz()` once the lesson is unlocked.
+     */
+    quizQuestionCount: number;
+}
+interface CourseModule {
+    id: string;
+    title: string;
+    lessons: CourseLesson[];
+}
+/** Full course player payload for an enrolled customer. */
+interface CourseDetail {
+    courseId: string;
+    name: string | null;
+    slug: string;
+    imageUrl: string | null;
+    /** Welcome text shown at the top of the member area (markdown). */
+    welcomeText: string | null;
+    /**
+     * AI tutor ("Ask about this lesson") is available on unlocked lessons —
+     * render the tutor widget only when true.
+     */
+    aiTutorEnabled: boolean;
+    /**
+     * Lesson discussion (comments) is available on unlocked lessons — render
+     * the discussion widget only when true.
+     */
+    discussionEnabled: boolean;
+    /**
+     * Course content opens at this time (epoch ms); null/undefined = already
+     * open. While in the future EVERY lesson (including previews) is locked
+     * with `unlockAt >= contentAvailableFrom` — render "Startujeme ..." +
+     * countdown in the member area.
+     */
+    contentAvailableFrom?: number | null;
+    enrolledAt: number;
+    expiresAt: number | null;
+    totalLessons: number;
+    completedLessons: number;
+    modules: CourseModule[];
+    /**
+     * Completion certificate, present once the course is 100 % finished and the
+     * merchant has certificates enabled. Verify the code publicly via
+     * `certificates.verify(code)`.
+     */
+    certificate?: {
+        code: string;
+        issuedAt: number;
+    } | null;
+}
+/** Progress snapshot returned after completing a lesson. */
+interface CourseProgress {
+    courseId: string;
+    lessonId: string;
+    totalLessons: number;
+    completedLessons: number;
+}
+/** One quiz question. Correct answers are never exposed before submitting. */
+interface QuizQuestion {
+    id: string;
+    question: string;
+    /** Option texts in order; submit the chosen option's index. */
+    options: string[];
+}
+interface LessonQuiz {
+    courseId: string;
+    lessonId: string;
+    /** Minimum score (in %) that completes the lesson automatically. */
+    passPercent: number;
+    questions: QuizQuestion[];
+}
+interface QuizAnswerInput {
+    questionId: string;
+    /** Index of the chosen option (0-based). */
+    selectedIndex: number;
+}
+interface QuizAnswerResult {
+    questionId: string;
+    /** Echo of the submitted choice; null when unanswered or out of range. */
+    selectedIndex: number | null;
+    /** Correct option index, revealed only after submitting. */
+    correctIndex: number;
+    correct: boolean;
+}
+interface QuizResult {
+    courseId: string;
+    lessonId: string;
+    totalQuestions: number;
+    correctCount: number;
+    scorePercent: number;
+    passPercent: number;
+    passed: boolean;
+    /** True when the passing score marked the lesson completed. */
+    lessonCompleted: boolean;
+    results: QuizAnswerResult[];
+    /** Course progress after a passing submit; null when not passed. */
+    progress: {
+        totalLessons: number;
+        completedLessons: number;
+    } | null;
+}
+/** One exchange in the private AI tutor thread: question + answer. */
+interface CourseTutorMessage {
+    id: string;
+    /** The student's question. */
+    question: string;
+    /** The AI tutor's answer (plain text / light markdown). */
+    answer: string;
+    createdAt: number;
+}
+/** The student's private tutor thread for one lesson. */
+interface CourseTutorThread {
+    courseId: string;
+    lessonId: string;
+    /** False when the merchant disabled the AI tutor — hide the widget. */
+    enabled: boolean;
+    /** Oldest first. */
+    items: CourseTutorMessage[];
+}
+/** A one-level reply under a top-level lesson comment. */
+interface CourseCommentReply {
+    id: string;
+    /** Id of the parent (top-level) comment. */
+    parentId: string;
+    body: string;
+    /** Author's first name, or a masked e-mail when no name is known. */
+    authorName: string;
+    /** True when the logged-in customer wrote this reply (can delete it). */
+    isMine: boolean;
+    createdAt: number;
+}
+/** A top-level comment under a lesson, with one level of replies. */
+interface CourseComment {
+    id: string;
+    body: string;
+    /** Author's first name, or a masked e-mail when no name is known. */
+    authorName: string;
+    /** True when the logged-in customer wrote this comment (can delete it). */
+    isMine: boolean;
+    createdAt: number;
+    /** Oldest first. */
+    replies: CourseCommentReply[];
+}
+/** Paginated lesson discussion (top-level comments, newest first). */
+interface CourseCommentsList {
+    courseId: string;
+    lessonId: string;
+    /** False when the merchant disabled the discussion — hide the widget. */
+    enabled: boolean;
+    /** 1-based page of top-level comments. */
+    page: number;
+    pageSize: number;
+    /** Total count of top-level comments on the lesson. */
+    totalCount: number;
+    items: CourseComment[];
+}
+/** The comment (or reply) just posted by the logged-in customer. */
+interface CoursePostedComment {
+    id: string;
+    /** Id of the parent comment when this is a reply; null for top-level. */
+    parentId?: string | null;
+    body: string;
+    authorName: string;
+    isMine: boolean;
+    createdAt: number;
+}
+/** The student's private note for one lesson (visible only to them). */
+interface LessonNote {
+    courseId: string;
+    lessonId: string;
+    /** The note text; empty string when no note exists yet. */
+    body: string;
+    /** Last save time (epoch ms); null when no note exists yet. */
+    updatedAt: number | null;
+}
+/** One completion certificate on the customer's account. */
+interface CourseCertificate {
+    courseId: string;
+    courseName: string | null;
+    /** Public verification code (share it, verify via `certificates.verify`). */
+    code: string;
+    issuedAt: number;
+}
+/** Public verification payload for a certificate code. */
+interface CertificateVerification {
+    valid: boolean;
+    code: string;
+    courseId: string;
+    courseName: string | null;
+    /** Student's name, or a masked e-mail when no name is known. */
+    studentName: string;
+    issuedAt: number;
+}
+/** Short-lived signed URL to fetch a purchased digital file. */
+interface DownloadUrl {
+    /** Short-lived (15 min) signed URL. */
+    url: string;
+    fileName: string;
+    mimeType: string;
+    fileSize: number;
+    /** Remaining downloads after this one is counted (null = unlimited). */
+    remainingDownloads: number | null;
+    expiresAt: number | null;
+}
+interface CustomerProfile {
+    id: string;
+    email: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    emailVerified: boolean;
+    /**
+     * B2B approval gate (GAP-19). `false` = the account is awaiting merchant
+     * approval (or was deactivated) — show a "pending approval" banner and gate
+     * ordering. `true` = approved / active. New registrations on a shop with
+     * `requireRegistrationApproval` start unapproved and cannot log in until
+     * approved (register returns `pendingApproval`).
+     */
+    isApproved: boolean;
+}
+interface CustomerAddress {
+    id: string;
+    type: AddressType;
+    isDefault: boolean;
+    firstName: string;
+    lastName: string;
+    company?: string;
+    street: string;
+    city: string;
+    zip: string;
+    country: string;
+    phone?: string;
+}
+interface Page {
+    slug: string;
+    title: string;
+    isActive: boolean;
+    /** Last modification of the page record (epoch ms) — sitemap `lastmod` (GAP-31). */
+    updatedAt?: number;
+}
+interface PageDetail {
+    slug: string;
+    title: string;
+    content: unknown;
+    seoTitle?: string;
+    seoDescription?: string;
+    ogTitle?: string;
+    ogDescription?: string;
+    ogImage?: string;
+    /** Downloadable files attached to the page (e.g. legal form PDFs). */
+    attachments: PageAttachment[];
+}
+interface PageAttachment {
+    name: string;
+    description: string | null;
+    url: string;
+    mimeType: string;
+    fileSize: number;
+}
+type BehioErrorCode = "UNAUTHORIZED" | "FORBIDDEN" | "NOT_FOUND" | "VALIDATION_ERROR" | "CONFLICT" | "RATE_LIMITED" | "CART_EMPTY" | "PRODUCT_NOT_FOUND" | "INVALID_CREDENTIALS" | "INVALID_DISCOUNT" | "DISCOUNT_EXPIRED" | "TOKEN_EXPIRED" | "TOKEN_INVALID" | "EMAIL_ALREADY_EXISTS" | "ORDER_NOT_CANCELLABLE" | "INTERNAL_ERROR" | "NETWORK_ERROR" | "TIMEOUT" | "UNKNOWN";
+declare class BehioApiError extends Error {
+    readonly code: BehioErrorCode;
+    readonly status: number;
+    readonly body: unknown;
+    readonly isRetryable: boolean;
+    constructor(status: number, body: unknown, message?: string);
+    static resolveCode(status: number, body: unknown): BehioErrorCode;
+    /** Check if this is a specific error type */
+    is(code: BehioErrorCode): boolean;
+}
+/**
+ * Shape every SDK call returns. Destructure `{data, error}` — exactly
+ * one of them is non-null on any given call. No more try/catch for
+ * expected failures; the type system forces you to handle `error`
+ * before touching `data`.
+ *
+ *   const {data, error} = await behio.catalog.getProduct(slug);
+ *   if (error) return <ErrorState code={error.code} />;
+ *   return <ProductView product={data} />;
+ */
+type SdkResult<T> = {
+    data: T;
+    error: null;
+} | {
+    data: null;
+    error: SdkError;
+};
+/**
+ * Canonical error shape returned from every SDK call. Always carries a
+ * `code` you can branch on without parsing messages.
+ */
+interface SdkError {
+    /**
+     * High-level category. `BehioErrorCode` covers API errors; additional
+     * buckets are network/timeout/abort/unknown.
+     */
+    code: BehioErrorCode;
+    /** Human-readable message (fallback for unknown codes / dev logging). */
+    message: string;
+    /** HTTP status, if the error came from the API. Null for network / abort. */
+    status: number | null;
+    /** Raw API body, if present. */
+    body?: unknown;
+    /** Whether the operation is safe to retry (true for 5xx / 429 / network). */
+    isRetryable: boolean;
+    /** Preserves the original thrown instance for stack traces + rethrows. */
+    cause?: unknown;
+}
+type BehioEventType = "auth:login" | "auth:logout" | "auth:token-refresh" | "auth:token-refresh-failed" | "cart:updated" | "cart:cleared" | "order:created" | "error" | "request" | "response" | "rate-limit-warning";
+type BehioEventHandler = (data?: unknown) => void;
+interface RequestInterceptorConfig {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+}
+interface RequestInterceptor {
+    (config: RequestInterceptorConfig): RequestInterceptorConfig | Promise<RequestInterceptorConfig>;
+}
+interface ResponseInterceptorData {
+    status: number;
+    data: unknown;
+    headers: Headers;
+}
+interface ResponseInterceptor {
+    (response: ResponseInterceptorData): void | Promise<void>;
+}
+/** One product group ("collection") with its products as standard list items.
+ * Groups are curated in the admin (Product groups); storefronts render them
+ * as product bands, e.g. a home "collection" section. */
+interface ProductGroup {
+    id: string;
+    slug: string;
+    /** Group type, e.g. "similar" / "upsell" / "recommended" / "collection". */
+    type: string;
+    /** Name in the requested locale, falling back to the shop default language. */
+    name: string;
+    description: string | null;
+    items: ProductListItem[];
+}
+interface BundleItem {
+    productId: string;
+    slug: string | null;
+    name: string;
+    sku: string;
+    quantity: number;
+    imageUrl: string | null;
+    defaultPrice: number | null;
+}
+interface Bundle {
+    id: string;
+    slug: string;
+    name: string;
+    description: string | null;
+    bundlePrice: number;
+    currency: string;
+    coverImage: string | null;
+    endsAt: number | null;
+    itemsSum: number;
+    /** Absolute saving vs buying the components separately, in `currency`. */
+    savings: number;
+    /** Percentage saving, 0–100. 0 when `itemsSum` is zero. */
+    savingsPercent: number;
+    /** Minimum bundles per order. Default 1. */
+    minQuantity: number;
+    /** Maximum bundles per order. `null` = uncapped. */
+    maxQuantity: number | null;
+    /** Lifetime stock limit. `null` = uncapped. Once exceeded, add-to-cart fails. */
+    stockLimit: number | null;
+    /** Lifetime units sold (materialized counter). Used for "X sold" badges. */
+    soldCount: number;
+    items: BundleItem[];
+}
+/**
+ * Shape returned by `behio.shipping.listMethods()` — the merchant's
+ * configured shipping methods filtered by cart currency + destination
+ * country. Use this for the "always-on" picker; for live quotes, prefer
+ * `behio.shipping.quote()` which can dispatch to the meta-provider
+ * (Zaslat, Shippo, …) for a live carrier rate per address.
+ */
+interface ShippingMethodSummary {
+    id: string;
+    name: string;
+    description: string | null;
+    /** Internal routing id ("zaslat", "ppl_direct", "manual", …). Not for display. */
+    provider: string;
+    /** "fixed" = price known upfront; "live_quote" = must call shipping.quote() with address. */
+    priceStrategy: "fixed" | "live_quote";
+    currency: string | null;
+    /** Final customer-facing price. Null for live_quote methods (call quote() to resolve). */
+    price: number | null;
+    /** Per-currency base price from the merchant's config. Null for live_quote. */
+    basePrice: number | null;
+    isFreeShipping: boolean;
+    freeShippingThreshold: number | null;
+    /** "address" | "pickup_point" | "in_store" | "digital". */
+    deliveryType: string;
+    supportsPickupPoints: boolean;
+    etaDaysMin: number | null;
+    etaDaysMax: number | null;
+    allowedCountries: string[];
+    /** Customer-safe config fields the merchant filled in (pickup address, instructions). */
+    publicConfig: Record<string, unknown>;
+}
+/**
+ * Input for `behio.shipping.quote()`. At minimum requires the destination
+ * country — passing more (zip, weight per item, cart total) lets the
+ * meta-provider return better-fitting carriers and triggers free-shipping
+ * thresholds correctly.
+ */
+interface ShippingQuoteInput {
+    destinationAddress: {
+        country: string;
+        zip?: string;
+        city?: string;
+        street?: string;
+    };
+    items?: Array<{
+        whItemId: string;
+        quantity: number;
+        weightKg?: number;
+    }>;
+    cartTotal?: number;
+    currency?: string;
+}
+/**
+ * One option returned by `behio.shipping.quote()`. Methods configured for
+ * fixed pricing always come back with `available: true` and the merchant's
+ * configured price. Methods configured for live quoting come back available
+ * only when the upstream meta-provider returned a rate for the destination
+ * — otherwise `available: false` with a `reason` (e.g. `"no_rate_returned"`,
+ * `"live_quote_not_implemented"`). Filter `available: true` in your
+ * checkout picker.
+ */
+interface ShippingQuote extends ShippingMethodSummary {
+    /** `"fixed"` uses `pricing` rows; `"live_quote"` came from the upstream provider. */
+    strategy: "fixed" | "live_quote";
+    available: boolean;
+    reason: string | null;
+    /** Server-generated quote ID. Null for fixed-price methods. Pass to checkout for tamper-proof pricing. */
+    quoteId: string | null;
+    /** Quote expiry (epoch ms). Null for fixed-price methods. */
+    expiresAt: number | null;
+}
+/**
+ * A pickup point (parcel shop / locker) for a shipping method with
+ * `supportsPickupPoints`. Fetch with `behio.shipping.getPickupPoints()`,
+ * then send the chosen `externalId` as `checkout.pickupPointId`.
+ */
+interface PickupPoint {
+    /** Carrier-native id. Send this back as `checkout.pickupPointId`. */
+    externalId: string;
+    name: string;
+    street: string | null;
+    city: string;
+    zip: string;
+    country: string;
+    latitude: number | null;
+    longitude: number | null;
+    cashOnDelivery: boolean;
+    cardPayment: boolean;
+    /** Per-day opening hours; empty when the provider gives none. */
+    openingHours: PickupPointHours[];
+}
+/** One day's opening-hours block for a pickup point. */
+interface PickupPointHours {
+    /** Provider-native day key (e.g. weekday name or index). */
+    day: string;
+    /** Morning open time. */
+    from1: string | null;
+    /** Morning close time. */
+    to1: string | null;
+    /** Afternoon open time. */
+    from2: string | null;
+    /** Afternoon close time. */
+    to2: string | null;
+}
+/** Input for `behio.shipping.getPickupPoints()`. */
+interface PickupPointsInput {
+    /** Shipping method id (must have `supportsPickupPoints`). */
+    methodId: string;
+    /** Free-text search over name / city / zip. */
+    query?: string;
+    /** ISO 3166-1 alpha-2 country filter; defaults to the method's first
+     *  allowed country or CZ. */
+    country?: string;
+    /** Max results (default 30, capped at 100). */
+    limit?: number;
+}
+/** Public terms of the eshop's loyalty program. */
+interface LoyaltyProgram {
+    name: string;
+    pointName: string;
+    pointNamePlural: string;
+    /** 1 point = `pointValueRatio` currency units. */
+    pointValueRatio: number;
+    currency: string;
+    minRedemptionPoints: number;
+    maxRedemptionPercent: number;
+    combineWithDiscounts: boolean;
+    description: string | null;
+    iconUrl: string | null;
+}
+interface LoyaltyBalance {
+    currentPoints: number;
+    /** `currentPoints` valued in the program currency. */
+    currentPointsValue: number;
+    lifetimePointsEarned: number;
+    lifetimePointsRedeemed: number;
+    lifetimeSpend: number;
+}
+interface LoyaltyTier {
+    name: string;
+    slug: string;
+    color: string | null;
+    earnMultiplier: number;
+    /** Tier perks (human-readable perk lines), or null when the tier has none. */
+    perks: LoyaltyTierPerks | null;
+}
+/** Perks attached to a loyalty tier. */
+interface LoyaltyTierPerks {
+    /** Human-readable perk lines shown on the tier. */
+    list: string[];
+}
+interface LoyaltyNextTier {
+    name: string;
+    slug: string;
+    color: string | null;
+    thresholdType: string;
+    thresholdValue: number;
+    currentValue: number;
+    remaining: number;
+    /** 0-100 progress toward this tier. */
+    progressPercent: number;
+}
+interface LoyaltyTransaction {
+    type: string;
+    /** Positive = earned, negative = redeemed / expired. */
+    points: number;
+    balanceAfter: number;
+    eventType: string | null;
+    description: string | null;
+    createdAt: number;
+}
+/**
+ * Loyalty summary for the logged-in customer. `hasProgram` is false when the
+ * eshop runs no program; `enrolled` is false when the customer has not yet
+ * joined (then `program` still carries the public terms so you can render a
+ * "join and earn" CTA).
+ */
+interface LoyaltySummary {
+    hasProgram: boolean;
+    enrolled: boolean;
+    program: LoyaltyProgram | null;
+    balance: LoyaltyBalance | null;
+    currentTier: LoyaltyTier | null;
+    nextTier: LoyaltyNextTier | null;
+    referralCode: string | null;
+    transactions: LoyaltyTransaction[];
+}
+interface CrossSellItem {
+    productId: string;
+    slug: string | null;
+    /** Localized product name (resolved for the requested locale, falls back to
+     * the eshop default language). */
+    name: string;
+    sku: string;
+    /** Price in the requested currency (or eshop default), including any price
+     * list override for the authenticated customer. `null` when hidden (B2B). */
+    price: number | null;
+    /** Original (crossed-out) price in the same currency, when on sale. */
+    compareAtPrice: number | null;
+    /** Currency code the `price` / `compareAtPrice` are expressed in. */
+    currency: string;
+    imageUrl: string | null;
+    /** Cached stock quantity of the recommended product. */
+    stockCached: number;
+    /** Convenience flag: `stockCached > 0`. */
+    inStock: boolean;
+    /** Merchant-editable note ("proč se to hodí") resolved for the requested
+     * locale (falls back to the eshop default language). `null` when unset. */
+    note?: string | null;
+}
+interface ActivePromotion {
+    id: string;
+    name: string;
+    slug: string;
+    type: string;
+    discountType: string;
+    discountValue: number;
+    startsAt: number;
+    endsAt: number | null;
+    badgeText: string | null;
+    badgeColor: string | null;
+    showCountdown: boolean;
+    couponRequired: boolean;
+}
+interface GiftCardBalance {
+    valid: boolean;
+    balance: number;
+    currency: string;
+}
+/** Customer gift card purchase (GAP-39): amount + recipient + optional payment method. */
+interface GiftCardPurchaseInput {
+    /** Gift card value in whole units of the currency (50 to 50000). */
+    amount: number;
+    /** Must be supported by the shop; defaults to the shop default currency. */
+    currency?: string;
+    /** Buyer contact; owns the order and gets the order confirmation. */
+    buyerEmail: string;
+    /** Receives the gift card code once the order is paid. */
+    recipientEmail: string;
+    recipientName?: string;
+    personalMessage?: string;
+    /** Online payment method id (from listPaymentMethods) to start payment right away. */
+    paymentMethodId?: string;
+    locale?: string;
+}
+interface GiftCardPurchaseResult {
+    orderId: string;
+    orderNumber: string;
+    grandTotal: number;
+    currency: string;
+    /**
+     * Hosted gateway URL to pay the order, or null (offline method / no method /
+     * gateway init failed). The gift card is generated and emailed to the
+     * recipient only AFTER the order is paid.
+     */
+    paymentRedirectUrl: string | null;
+}
+interface WishlistItem {
+    id: string;
+    productId: string;
+    productName: string;
+    productSku: string;
+    productSlug: string | null;
+    imageUrl: string | null;
+    price: number | null;
+    stockCached: number;
+    createdAt: number;
+}
+type SubscriptionStatus = "ACTIVE" | "PAUSED" | "CANCELLED" | "EXPIRED" | "PAYMENT_FAILED";
+type SubscriptionFrequency = "WEEKLY" | "BIWEEKLY" | "MONTHLY" | "BIMONTHLY" | "QUARTERLY" | "EVERY_6_MONTHS" | "YEARLY" | "CUSTOM_DAYS";
+interface SubscriptionItem {
+    id: string;
+    productId: string;
+    product: {
+        id: string;
+        slug: string | null;
+    };
+    quantity: number;
+    unitPriceSnapshot: number;
+    currency: string;
+}
+interface Subscription {
+    id: string;
+    status: SubscriptionStatus;
+    frequency: SubscriptionFrequency;
+    /** For CUSTOM_DAYS frequency: order every N days. */
+    customDays: number | null;
+    /** Unix ms of the next scheduled order. */
+    nextOrderAt: number;
+    /** Unix ms of the last generated order, if any. */
+    lastOrderAt: number | null;
+    totalOrders: number;
+    /** Max number of orders before the subscription expires (null = unlimited). */
+    maxOrders: number | null;
+    /** Subscriber discount percent applied to each generated order. */
+    discountPercent: number | null;
+    items: SubscriptionItem[];
+    orderCount: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface SubscriptionAction {
+    id: string;
+    status: SubscriptionStatus;
+    /** Present after resume — the newly scheduled next order (Unix ms). */
+    nextOrderAt?: number | null;
+    updatedAt: number;
+}
+interface ProductReview {
+    id: string;
+    authorName: string;
+    rating: number;
+    title: string | null;
+    content: string | null;
+    imageUrls: string[];
+    isVerifiedPurchase: boolean;
+    helpfulCount: number;
+    unhelpfulCount: number;
+    replyContent: string | null;
+    replyAt: number | null;
+    createdAt: number;
+}
+interface ProductReviewsResponse {
+    reviews: ProductReview[];
+    total: number;
+    page: number;
+    limit: number;
+    averageRating: number;
+    reviewCount: number;
+}
+/** Returned by `catalog.notifyWhenAvailable()` — back-in-stock subscription. */
+interface BackInStockSubscription {
+    id: string;
+    eshopId: string;
+    productId: string;
+    email: string;
+    createdAt: number;
+}
+interface SubmitReviewInput {
+    productId: string;
+    rating: number;
+    title?: string;
+    content?: string;
+    authorName: string;
+    authorEmail?: string;
+    imageUrls?: string[];
+}
+interface ReturnableOrderItem {
+    orderItemId: string;
+    productName: string;
+    /** Quantity ordered */
+    quantity: number;
+    /** Units still returnable (ordered minus active return claims) */
+    returnableQuantity: number;
+}
+/**
+ * Result of the guest order lookup used by the EU withdrawal form:
+ * the customer enters their order number + email and gets back the
+ * internal ids needed to submit a return. No account required.
+ */
+interface ReturnableOrder {
+    orderId: string;
+    orderNumber: string;
+    status: string;
+    items: ReturnableOrderItem[];
+    createdAt: number;
+}
+interface ReturnRequestItem {
+    id: string;
+    orderItemId: string;
+    productName: string;
+    quantity: number;
+    reason: string | null;
+    imageUrls: string[];
+}
+/** Returned by `returns.submit()` — the acknowledged withdrawal request. */
+interface ReturnRequest {
+    id: string;
+    eshopId: string;
+    orderId: string;
+    /** REQUESTED | APPROVED | SHIPPED_BACK | RECEIVED | REFUNDED | REJECTED | CLOSED */
+    status: string;
+    reason: string;
+    customerNote: string | null;
+    items: ReturnRequestItem[];
+    createdAt: number;
+}
+interface ReturnStatusItem {
+    id: string;
+    productName: string;
+    quantity: number;
+    reason: string | null;
+}
+/** Returned by `returns.getStatus()` — the full public view of a return. */
+interface ReturnStatus {
+    id: string;
+    orderNumber: string;
+    /** REQUESTED | APPROVED | SHIPPED_BACK | RECEIVED | REFUNDED | REJECTED | CLOSED */
+    status: string;
+    reason: string;
+    customerNote: string | null;
+    refundMethod: string | null;
+    refundAmount: number | null;
+    refundedAt: number | null;
+    returnTrackingNumber: string | null;
+    items: ReturnStatusItem[];
+    createdAt: number;
+    updatedAt: number;
+}
+interface SubmitReturnInput {
+    orderId: string;
+    /**
+     * Email used on the order. Required — it is the ownership gate for guest
+     * withdrawals; the backend rejects submissions whose email doesn't match.
+     */
+    email: string;
+    reason: string;
+    customerNote?: string;
+    items: {
+        orderItemId: string;
+        productName: string;
+        quantity: number;
+        reason?: string;
+        imageUrls?: string[];
+    }[];
+}
+interface CookieConsent {
+    necessary: boolean;
+    analytics: boolean;
+    marketing: boolean;
+    preferences: boolean;
+    consentedAt: number;
+}
+interface CookieConsentInput {
+    visitorId: string;
+    analytics: boolean;
+    marketing: boolean;
+    preferences: boolean;
+}
+interface QuoteItem {
+    productId: string;
+    quantity: number;
+    requestedPrice: number | null;
+    quotedPrice: number | null;
+}
+interface QuoteRequest {
+    id: string;
+    /** PENDING | QUOTED | ACCEPTED | REJECTED | EXPIRED */
+    status: string;
+    contactName: string;
+    contactEmail: string;
+    companyName: string | null;
+    quotedTotal: number | null;
+    quotedCurrency: string | null;
+    quotedNote: string | null;
+    expiresAt: number | null;
+    items: QuoteItem[];
+    createdAt: number;
+}
+interface SubmitQuoteInput {
+    contactName: string;
+    contactEmail: string;
+    contactPhone?: string;
+    companyName?: string;
+    companyIco?: string;
+    message?: string;
+    items: {
+        productId: string;
+        quantity: number;
+        requestedPrice?: number;
+    }[];
+}
+
+declare class BehioStorefront {
+    private baseUrl;
+    private apiKey;
+    /** Consent-gated persistent visitor id — set by the analytics tracker. */
+    private analyticsVisitorId;
+    private shopDomain?;
+    private defaultLocale?;
+    private defaultCurrency?;
+    private fetchFn;
+    private timeout;
+    private retries;
+    private retryDelay;
+    private accessToken?;
+    private refreshToken?;
+    private isRefreshing;
+    private refreshPromise;
+    private cartSession?;
+    private listeners;
+    private requestInterceptors;
+    private responseInterceptors;
+    private rateLimitRemaining;
+    private rateLimitReset;
+    constructor(config: BehioStorefrontConfig);
+    readonly catalog: CatalogModule;
+    readonly auth: AuthModule;
+    readonly cart: CartModule;
+    readonly checkout: CheckoutModule;
+    readonly orders: OrdersModule;
+    readonly customer: CustomerModule;
+    readonly pages: PagesModule;
+    readonly wishlist: WishlistModule;
+    readonly reviews: ReviewsModule;
+    readonly returns: ReturnsModule;
+    readonly consent: ConsentModule;
+    readonly quotes: QuotesModule;
+    readonly addresses: AddressModule;
+    readonly shipping: ShippingModule;
+    readonly newsletter: NewsletterModule;
+    readonly subscriptions: SubscriptionsModule;
+    readonly certificates: CourseCertificatesModule;
+    /**
+     * 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: string | null): void;
+    /** The consent-gated visitor id, if analytics consent was granted. */
+    getAnalyticsVisitorId(): string | null;
+    /**
+     * 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.
+     */
+    sendAnalyticsEvents(input: {
+        sessionId?: string;
+        /** Persistent consent-gated visitor id (behio_visitor_id). */
+        visitorId?: string;
+        events: Array<{
+            type: "pageview" | "ecommerce" | "custom";
+            name?: string;
+            ts?: number;
+            path?: string;
+            referrer?: string;
+            utmSource?: string;
+            utmMedium?: string;
+            utmCampaign?: string;
+            utmTerm?: string;
+            utmContent?: string;
+            gclid?: string;
+            fbclid?: string;
+            dwellMs?: number;
+            value?: number;
+            currency?: string;
+            props?: Record<string, unknown>;
+        }>;
+    }): Promise<void>;
+    /**
+     * Personal behavioral offers for this visitor (consent-gated id). Returns
+     * only the visitor's own offers; requires the analytics visitor id.
+     */
+    getPersonalOffers(visitorId: string): Promise<SdkResult<{
+        items: Array<{
+            id: string;
+            productId: string;
+            percent: number;
+            status: string;
+            code: string | null;
+            expiresAt: number;
+        }>;
+    }>>;
+    /** Email-gate completion: trade an e-mail for the personal discount code. */
+    claimOfferByEmail(offerId: string, input: {
+        visitorId: string;
+        email: string;
+    }): Promise<SdkResult<{
+        code: string;
+        percent: number;
+        expiresAt: number;
+    }>>;
+    /** Get basic shop info */
+    getShopInfo(): Promise<SdkResult<ShopInfo>>;
+    /** Get SEO metadata for the shop homepage in the given locale (defaults to shop default). */
+    getShopSeo(locale?: string): Promise<SdkResult<ShopSeo>>;
+    /**
+     * 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.
+     */
+    getShopScripts(): Promise<SdkResult<ShopScripts>>;
+    /** Set auth tokens (e.g. from localStorage) */
+    setTokens(tokens: {
+        accessToken: string;
+        refreshToken: string;
+    }): void;
+    /** Clear auth tokens */
+    clearTokens(): void;
+    /** Get current access token */
+    getAccessToken(): string | undefined;
+    /** Get current refresh token */
+    getRefreshToken(): string | undefined;
+    /** Set cart session token (e.g. from cookie) */
+    setCartSession(token: string): void;
+    /** Get cart session token */
+    getCartSession(): string | undefined;
+    /** Clear cart session */
+    clearCartSession(): void;
+    /**
+     * 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: string | undefined): void;
+    /** Get the current default currency, if any. */
+    getCurrency(): string | undefined;
+    /** Set the default locale sent on every catalog request (per-call wins). */
+    setLocale(locale: string | undefined): void;
+    /** Get the current default locale, if any. */
+    getLocale(): string | undefined;
+    /** Subscribe to SDK events. Returns an unsubscribe function. */
+    on(event: BehioEventType, handler: BehioEventHandler): () => void;
+    /** @internal Emit an event (fire-and-forget, handler errors are swallowed) */
+    emit(event: BehioEventType, data?: unknown): void;
+    /** Add a request interceptor. Returns an unsubscribe function. */
+    addRequestInterceptor(fn: RequestInterceptor): () => void;
+    /** Add a response interceptor. Returns an unsubscribe function. */
+    addResponseInterceptor(fn: ResponseInterceptor): () => void;
+    /** Get current rate limit info from latest response headers */
+    getRateLimitInfo(): {
+        remaining: number | null;
+        reset: number | null;
+    };
+    private handleTokenRefresh;
+    /**
+     * 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.
+     */
+    request<T>(method: string, path: string, options?: {
+        body?: unknown;
+        query?: Record<string, string | number | boolean | undefined | string[] | number[]>;
+        auth?: boolean;
+        signal?: AbortSignal;
+        headers?: Record<string, string>;
+    }): Promise<SdkResult<T>>;
+    /**
+     * 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).
+     */
+    requestBlob(path: string): Promise<SdkResult<Blob>>;
+    /**
+     * 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.
+     */
+    private rawRequest;
+}
+declare class CatalogModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /** List products with filtering, pagination, search */
+    getProducts(query?: ProductsQuery): Promise<SdkResult<PaginatedResponse<ProductListItem>>>;
+    /** Get product detail by slug */
+    getProduct(slug: string, options?: {
+        locale?: string;
+        currency?: string;
+    }): Promise<SdkResult<ProductDetail>>;
+    /** Get category tree */
+    getCategories(locale?: string): Promise<SdkResult<{
+        categories: Category[];
+    }>>;
+    /** Get category detail by slug */
+    getCategory(slug: string, locale?: string): Promise<SdkResult<CategoryDetail>>;
+    /** Get products in a category */
+    getCategoryProducts(slug: string, query?: ProductsQuery): Promise<SdkResult<PaginatedResponse<ProductListItem>>>;
+    /**
+     * 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.
+     */
+    getMenu(handle: string, options?: {
+        locale?: string;
+    }): Promise<SdkResult<Menu>>;
+    /** Get all labels */
+    getLabels(locale?: string): Promise<SdkResult<{
+        labels: ProductLabel[];
+    }>>;
+    /** Get featured products */
+    getFeatured(options?: {
+        locale?: string;
+        currency?: string;
+    }): Promise<SdkResult<PaginatedResponse<ProductListItem>>>;
+    /** Get available filter fields for dynamic filter UI */
+    getFilters(): Promise<SdkResult<{
+        filters: FilterField[];
+    }>>;
+    /**
+     * 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.
+     */
+    getFacets(query?: ProductsQuery): Promise<SdkResult<FacetsResponse>>;
+    /** Search products */
+    search(query: string, options?: {
+        page?: number;
+        limit?: number;
+    }): Promise<SdkResult<PaginatedResponse<ProductListItem>>>;
+    /** List all active bundles */
+    getBundles(): Promise<SdkResult<{
+        items: Bundle[];
+    }>>;
+    /** Get a single bundle by slug */
+    getBundle(slug: string): Promise<SdkResult<Bundle>>;
+    /**
+     * 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.
+     */
+    getProductGroup(slug: string, options?: {
+        locale?: string;
+        currency?: string;
+    }): Promise<SdkResult<ProductGroup>>;
+    /**
+     * 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`.
+     */
+    getCrossSell(productSlug: string, options?: {
+        locale?: string;
+        currency?: string;
+    }): Promise<SdkResult<{
+        related: CrossSellItem[];
+        upsell: CrossSellItem[];
+        crossSell: CrossSellItem[];
+    }>>;
+    /** Active promotions applicable to a product (with countdown end time) */
+    /** Back-in-stock notification subscription for a sold-out product. */
+    notifyWhenAvailable(productId: string, email: string): Promise<SdkResult<BackInStockSubscription>>;
+    getProductPromotions(productSlug: string): Promise<SdkResult<{
+        items: ActivePromotion[];
+    }>>;
+    /** Check a gift card code — returns validity and remaining balance */
+    checkGiftCard(code: string): Promise<SdkResult<GiftCardBalance>>;
+    /**
+     * 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.
+     */
+    purchaseGiftCard(input: GiftCardPurchaseInput): Promise<SdkResult<GiftCardPurchaseResult>>;
+    /** List configured payment methods (filtered by currency). */
+    listPaymentMethods(opts?: {
+        currency?: string;
+    }): Promise<SdkResult<{
+        items: CheckoutPaymentMethod[];
+    }>>;
+}
+declare class AuthModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /** Register a new customer */
+    register(input: RegisterInput): Promise<SdkResult<RegisterResult>>;
+    /** Login with email and password */
+    login(input: LoginInput): Promise<SdkResult<AuthTokens>>;
+    /** Refresh access token using refresh token */
+    refresh(refreshToken?: string): Promise<SdkResult<AuthTokens>>;
+    /** Logout (invalidate refresh token) */
+    logout(refreshToken?: string): Promise<SdkResult<MessageResponse>>;
+    /** Request password reset email */
+    forgotPassword(email: string): Promise<SdkResult<MessageResponse>>;
+    /** Reset password with token */
+    resetPassword(token: string, newPassword: string): Promise<SdkResult<MessageResponse>>;
+    /** Verify email with token */
+    verifyEmail(token: string): Promise<SdkResult<MessageResponse>>;
+    /** Check if user is logged in (has access token) */
+    isLoggedIn(): boolean;
+}
+declare class CartModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /** Get current cart */
+    get(): Promise<SdkResult<Cart>>;
+    /** Add item to cart */
+    addItem(input: AddToCartInput): Promise<SdkResult<Cart & {
+        newSessionToken?: string;
+    }>>;
+    /** Update item quantity */
+    updateQuantity(itemId: string, quantity: number): Promise<SdkResult<Cart>>;
+    /** Remove item from cart */
+    removeItem(itemId: string): Promise<SdkResult<Cart>>;
+    /** Clear entire cart */
+    clear(): Promise<SdkResult<void>>;
+    /** Apply a gift card code to the cart. Balance is deducted at checkout. */
+    applyGiftCard(code: string): Promise<SdkResult<Cart>>;
+    /** Remove a specific applied gift card from the cart by its code. */
+    removeGiftCard(code: string): Promise<SdkResult<Cart>>;
+    /**
+     * 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.
+     */
+    addBundle(identifier: string | {
+        id: string;
+    } | {
+        slug: string;
+    }, quantity?: number): Promise<SdkResult<Cart>>;
+    /** Update quantity of a bundle already in the cart */
+    updateBundleQuantity(bundleId: string, quantity: number): Promise<SdkResult<Cart>>;
+    /** Remove a bundle from the cart */
+    removeBundle(bundleId: string): Promise<SdkResult<Cart>>;
+    /** Merge anonymous cart into authenticated customer cart */
+    merge(): Promise<SdkResult<Cart>>;
+    /** Apply discount code */
+    applyDiscount(code: string): Promise<SdkResult<Cart>>;
+    /** Remove discount code */
+    removeDiscount(): Promise<SdkResult<Cart>>;
+}
+declare class CheckoutModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /** Create order from cart */
+    createOrder(input: CheckoutInput): Promise<SdkResult<OrderDetail>>;
+}
+declare class OrdersModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /** List customer orders (requires auth) */
+    list(options?: {
+        page?: number;
+        limit?: number;
+    }): Promise<SdkResult<PaginatedResponse<OrderListItem>>>;
+    /** Get order detail (requires auth) */
+    get(orderNumber: string): Promise<SdkResult<OrderDetail>>;
+    /** Cancel a PENDING order (requires auth) */
+    cancel(orderNumber: string): Promise<SdkResult<OrderDetail>>;
+    /**
+     * 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.
+     */
+    track(trackingToken: string): Promise<SdkResult<OrderTracking>>;
+    /**
+     * 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.
+     */
+    requestAccessCode(orderNumber: string, email: string): Promise<SdkResult<OrderAccessRequestResponse>>;
+    /**
+     * 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.
+     */
+    verifyAccessCode(orderNumber: string, email: string, code: string): Promise<SdkResult<OrderAccessVerifyResponse>>;
+    /**
+     * 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.
+     */
+    getByAccessToken(accessToken: string): Promise<SdkResult<OrderDetail>>;
+    /**
+     * 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.
+     */
+    getAccessDownloadUrl(accessToken: string, downloadId: string): Promise<SdkResult<DownloadUrl>>;
+}
+declare class CustomerModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /** Get customer profile */
+    getProfile(): Promise<SdkResult<CustomerProfile>>;
+    /** Update customer profile */
+    updateProfile(data: Partial<Pick<CustomerProfile, "firstName" | "lastName" | "phone">>): Promise<SdkResult<CustomerProfile>>;
+    /** Change password */
+    changePassword(currentPassword: string, newPassword: string): Promise<SdkResult<MessageResponse>>;
+    /** List addresses */
+    getAddresses(): Promise<SdkResult<{
+        items: CustomerAddress[];
+    }>>;
+    /** Create address */
+    createAddress(address: Omit<CustomerAddress, "id">): Promise<SdkResult<CustomerAddress>>;
+    /** Update address */
+    updateAddress(addressId: string, data: Partial<CustomerAddress>): Promise<SdkResult<CustomerAddress>>;
+    /** Delete address */
+    deleteAddress(addressId: string): Promise<SdkResult<void>>;
+    /**
+     * 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.
+     */
+    getLoyalty(): Promise<SdkResult<LoyaltySummary>>;
+    /**
+     * 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.
+     */
+    getDownloads(): Promise<SdkResult<{
+        items: DigitalDownload[];
+    }>>;
+    /**
+     * 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.
+     */
+    getDownloadUrl(downloadId: string): Promise<SdkResult<DownloadUrl>>;
+    /**
+     * 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.
+     */
+    getCourses(): Promise<SdkResult<{
+        items: CourseListItem[];
+    }>>;
+    /**
+     * 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`.
+     */
+    getCourse(courseId: string): Promise<SdkResult<CourseDetail>>;
+    /** Mark an unlocked lesson as completed (idempotent). */
+    completeLesson(courseId: string, lessonId: string): Promise<SdkResult<CourseProgress>>;
+    /**
+     * Quiz for an unlocked lesson. Correct answers are never included — scoring
+     * happens server-side in `submitLessonQuiz`. Locked lessons return 403.
+     */
+    getLessonQuiz(courseId: string, lessonId: string): Promise<SdkResult<LessonQuiz>>;
+    /**
+     * Submit quiz answers: returns the score, reveals correct answers and, when
+     * the score reaches `passPercent` (70 %), marks the lesson completed
+     * automatically.
+     */
+    submitLessonQuiz(courseId: string, lessonId: string, answers: QuizAnswerInput[]): Promise<SdkResult<QuizResult>>;
+    /**
+     * Completion certificates of the logged-in customer. Each carries a public
+     * verification code for sharing (LinkedIn, CV).
+     */
+    getCourseCertificates(): Promise<SdkResult<{
+        items: CourseCertificate[];
+    }>>;
+    /**
+     * 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.
+     */
+    getLessonTutorThread(courseId: string, lessonId: string): Promise<SdkResult<CourseTutorThread>>;
+    /**
+     * 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.
+     */
+    askLessonTutor(courseId: string, lessonId: string, question: string): Promise<SdkResult<CourseTutorMessage>>;
+    /**
+     * 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.
+     */
+    getLessonComments(courseId: string, lessonId: string, page?: number): Promise<SdkResult<CourseCommentsList>>;
+    /**
+     * 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.
+     */
+    postLessonComment(courseId: string, lessonId: string, body: string, parentId?: string): Promise<SdkResult<CoursePostedComment>>;
+    /**
+     * Delete the customer's OWN comment (including its replies). Someone
+     * else's comment returns 404.
+     */
+    deleteLessonComment(courseId: string, lessonId: string, commentId: string): Promise<SdkResult<void>>;
+    /**
+     * 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.
+     */
+    getLessonNote(courseId: string, lessonId: string): Promise<SdkResult<LessonNote>>;
+    /**
+     * Save (upsert) the student's private lesson note. Autosave-friendly; an
+     * empty string clears the note. Max 20 000 characters.
+     */
+    saveLessonNote(courseId: string, lessonId: string, body: string): Promise<SdkResult<LessonNote>>;
+}
+declare class CourseCertificatesModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /**
+     * Publicly verify a certificate code (no customer login needed) — build a
+     * `/certifikat/{code}` page with this. Unknown codes return a 404 error.
+     */
+    verify(code: string): Promise<SdkResult<CertificateVerification>>;
+    /**
+     * Download the certificate as a branded PDF (A5 landscape). Returns a Blob;
+     * trigger a browser download via `URL.createObjectURL(blob)`.
+     */
+    downloadPdf(code: string): Promise<SdkResult<Blob>>;
+}
+declare class PagesModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /** List CMS pages */
+    list(locale?: string): Promise<SdkResult<{
+        pages: Page[];
+    }>>;
+    /** Get page by slug */
+    get(slug: string, locale?: string): Promise<SdkResult<PageDetail>>;
+}
+declare class WishlistModule {
+    private client;
+    constructor(client: BehioStorefront);
+    get(): Promise<SdkResult<{
+        items: WishlistItem[];
+    }>>;
+    add(productId: string): Promise<SdkResult<{
+        success: boolean;
+    }>>;
+    remove(productId: string): Promise<SdkResult<{
+        success: boolean;
+    }>>;
+    isInWishlist(productId: string): Promise<SdkResult<{
+        inWishlist: boolean;
+    }>>;
+}
+declare class SubscriptionsModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /**
+     * 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.
+     */
+    list(): Promise<SdkResult<{
+        items: Subscription[];
+    }>>;
+    /** Pause an active subscription (no orders are generated while paused). */
+    pause(subscriptionId: string): Promise<SdkResult<SubscriptionAction>>;
+    /** Resume a paused subscription (re-schedules the next order). */
+    resume(subscriptionId: string): Promise<SdkResult<SubscriptionAction>>;
+    /** Cancel a subscription permanently (no more orders). */
+    cancel(subscriptionId: string): Promise<SdkResult<SubscriptionAction>>;
+}
+declare class ReviewsModule {
+    private client;
+    constructor(client: BehioStorefront);
+    getProductReviews(productId: string, page?: number, limit?: number): Promise<SdkResult<ProductReviewsResponse>>;
+    submit(input: SubmitReviewInput): Promise<SdkResult<{
+        id: string;
+    }>>;
+    voteHelpful(reviewId: string, helpful: boolean): Promise<SdkResult<{
+        success: boolean;
+    }>>;
+}
+declare class ReturnsModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /**
+     * 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.
+     */
+    lookupOrder(orderNumber: string, email: string): Promise<SdkResult<ReturnableOrder>>;
+    submit(input: SubmitReturnInput): Promise<SdkResult<ReturnRequest>>;
+    /** Email is the ownership gate; POST so it never lands in a URL / log. */
+    getStatus(returnId: string, email: string): Promise<SdkResult<ReturnStatus>>;
+}
+declare class ConsentModule {
+    private client;
+    constructor(client: BehioStorefront);
+    record(input: CookieConsentInput): Promise<SdkResult<CookieConsent>>;
+    get(visitorId: string): Promise<SdkResult<CookieConsent | null>>;
+    revoke(visitorId: string): Promise<SdkResult<{
+        success: boolean;
+    }>>;
+}
+declare class QuotesModule {
+    private client;
+    constructor(client: BehioStorefront);
+    submit(input: SubmitQuoteInput): Promise<SdkResult<QuoteRequest>>;
+    accept(quoteId: string, email: string): Promise<SdkResult<QuoteRequest>>;
+    /** 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. */
+    getStatus(quoteId: string, email: string): Promise<SdkResult<QuoteRequest>>;
+    /**
+     * 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.
+     */
+    listMine(): Promise<SdkResult<{
+        items: QuoteRequest[];
+    }>>;
+}
+interface AddressSuggestion {
+    placeId: string;
+    description: string;
+    street: string;
+    city: string;
+    zip: string;
+    country: string;
+    countryCode: string;
+}
+interface AddressDetail {
+    street: string;
+    streetNumber: string;
+    city: string;
+    zip: string;
+    country: string;
+    countryCode: string;
+    formattedAddress: string;
+    lat: number;
+    lng: number;
+}
+declare class AddressModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /** Search for address suggestions (debounce on your side, or use the React hook) */
+    autocomplete(query: string, country: string): Promise<SdkResult<{
+        suggestions: AddressSuggestion[];
+    }>>;
+    /** Get full structured address from a suggestion's placeId */
+    getDetail(placeId: string): Promise<SdkResult<AddressDetail>>;
+}
+/**
+ * Storefront shipping module — list configured methods and fetch live
+ * quotes for a destination + cart. Use `listMethods` for the always-on
+ * picker (sidebar, info page) and `quote` once the customer enters a
+ * destination address so live-quote providers (Zaslat etc.) can return
+ * destination-specific prices.
+ */
+declare class ShippingModule {
+    private client;
+    constructor(client: BehioStorefront);
+    /**
+     * 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.
+     */
+    listMethods(opts?: {
+        currency?: string;
+        country?: string;
+        cartTotal?: number;
+        cartWeightKg?: number;
+    }): Promise<SdkResult<{
+        items: ShippingMethodSummary[];
+    }>>;
+    /**
+     * 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.
+     */
+    quote(input: ShippingQuoteInput): Promise<SdkResult<{
+        items: ShippingQuote[];
+    }>>;
+    /**
+     * 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`.
+     */
+    getPickupPoints(input: PickupPointsInput): Promise<SdkResult<{
+        items: PickupPoint[];
+    }>>;
+}
+/**
+ * First-party newsletter opt-in. Use for the footer signup block and the
+ * checkout newsletter checkbox (render its default from
+ * `ShopInfo.checkout.newsletterOptInDefault`). Subscribing is idempotent and
+ * re-activates a previously unsubscribed email. Pass the hidden `website`
+ * honeypot field straight through from your form: a filled value is silently
+ * accepted but stored nowhere.
+ */
+declare class NewsletterModule {
+    private client;
+    constructor(client: BehioStorefront);
+    subscribe(input: NewsletterSubscribeInput): Promise<SdkResult<NewsletterSubscribeResult>>;
+    unsubscribe(email: string): Promise<SdkResult<NewsletterUnsubscribeResult>>;
+}
+
 interface BehioContextValue {
     client: BehioStorefront;
     storage: StorageAdapter;
@@ -332,6 +3083,154 @@ declare function useLoyalty(options?: UseLoyaltyOptions): {
     refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<LoyaltySummary>, Error>>;
 };
 
+interface UseCoursesOptions {
+    enabled?: boolean;
+}
+/**
+ * "My courses" list for the logged-in customer: enrolled courses with
+ * progress. Enrollment happens automatically when an order containing a
+ * course product is paid. Only runs when a customer is authenticated.
+ */
+declare function useCourses(options?: UseCoursesOptions): {
+    courses: CourseListItem[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<{
+        items: CourseListItem[];
+    }>, Error>>;
+};
+interface UseCourseOptions {
+    enabled?: boolean;
+}
+/**
+ * Course player payload: modules and lessons in order with drip-unlock
+ * state, plus a `completeLesson` mutation that records progress and
+ * refreshes the course. Locked lessons carry no content — render the
+ * title + `unlockAt` and let the server decide when content appears.
+ */
+declare function useCourse(courseId: string | null, options?: UseCourseOptions): {
+    course: NoInfer<CourseDetail> | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<CourseDetail>, Error>>;
+    completeLesson: (lessonId: string) => Promise<CourseProgress>;
+    isCompleting: boolean;
+};
+interface UseLessonQuizOptions {
+    enabled?: boolean;
+}
+/**
+ * Quiz for an unlocked lesson plus a `submit` mutation. The quiz payload never
+ * contains correct answers; `submit` returns the score, reveals the correct
+ * options and (at a passing score) marks the lesson completed, refreshing the
+ * course queries.
+ */
+declare function useLessonQuiz(courseId: string | null, lessonId: string | null, options?: UseLessonQuizOptions): {
+    quiz: NoInfer<LessonQuiz> | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<LessonQuiz>, Error>>;
+    submitQuiz: (answers: QuizAnswerInput[]) => Promise<QuizResult>;
+    isSubmitting: boolean;
+    result: QuizResult | null;
+};
+interface UseCourseCertificatesOptions {
+    enabled?: boolean;
+}
+/**
+ * Completion certificates of the logged-in customer. Each has a public
+ * verification `code`; download the branded PDF via
+ * `client.certificates.downloadPdf(code)`.
+ */
+declare function useCourseCertificates(options?: UseCourseCertificatesOptions): {
+    certificates: CourseCertificate[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<{
+        items: CourseCertificate[];
+    }>, Error>>;
+};
+interface UseCertificateVerificationOptions {
+    enabled?: boolean;
+}
+/**
+ * Public certificate verification by code (no login needed) — for the
+ * `/certifikat/{code}` page. Unknown codes surface as a NOT_FOUND error.
+ */
+declare function useCertificateVerification(code: string | null, options?: UseCertificateVerificationOptions): {
+    verification: NoInfer<CertificateVerification> | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<CertificateVerification>, Error>>;
+};
+
+interface UseLessonTutorOptions {
+    enabled?: boolean;
+}
+/**
+ * AI tutor "Zeptejte se AI" under a lesson: the student's private thread plus
+ * an `ask` mutation. Render the widget only when `enabled` is true (the
+ * merchant can turn the tutor off). Locked lessons surface as a 403 error.
+ */
+declare function useLessonTutor(courseId: string | null, lessonId: string | null, options?: UseLessonTutorOptions): {
+    messages: CourseTutorMessage[];
+    /** False when the merchant disabled the AI tutor — hide the widget. */
+    enabled: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<CourseTutorThread>, Error>>;
+    ask: (question: string) => Promise<CourseTutorMessage>;
+    isAsking: boolean;
+    askError: Error | null;
+};
+
+interface UseLessonCommentsOptions {
+    enabled?: boolean;
+    /** 1-based page of top-level comments (newest first). Default 1. */
+    page?: number;
+}
+/**
+ * Lesson discussion: paginated top-level comments (newest first) with one
+ * level of replies, plus `postComment` / `deleteComment` mutations. Render
+ * the widget only when `enabled` is true (the merchant can turn the
+ * discussion off). Only enrolled customers with the lesson unlocked.
+ */
+declare function useLessonComments(courseId: string | null, lessonId: string | null, options?: UseLessonCommentsOptions): {
+    comments: CourseComment[];
+    totalCount: number;
+    page: number;
+    pageSize: number;
+    /** False when the merchant disabled the discussion — hide the widget. */
+    enabled: boolean;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<CourseCommentsList>, Error>>;
+    postComment: (body: string, parentId?: string) => Promise<CoursePostedComment>;
+    isPosting: boolean;
+    deleteComment: (commentId: string) => Promise<void>;
+    isDeleting: boolean;
+};
+
+interface UseLessonNoteOptions {
+    enabled?: boolean;
+}
+/**
+ * The student's private note for one lesson (autosave textarea). `body` is
+ * an empty string until the student writes something; `save` upserts and an
+ * empty string clears the note. Visible only to the logged-in student.
+ */
+declare function useLessonNote(courseId: string | null, lessonId: string | null, options?: UseLessonNoteOptions): {
+    note: NoInfer<LessonNote> | null;
+    body: string;
+    updatedAt: number | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<LessonNote>, Error>>;
+    save: (body: string) => Promise<LessonNote>;
+    isSaving: boolean;
+    saveError: Error | null;
+};
+
 interface UseSubscriptionsOptions {
     enabled?: boolean;
 }
@@ -1293,4 +4192,127 @@ declare function useNotifyWhenAvailable(): _tanstack_react_query.UseMutationResu
  */
 declare function useBehioClient(): BehioStorefront;
 
-export { ActivePromotion, type AnalyticsEventInput, BehioAnalyticsTracker, BehioProvider, type BehioProviderProps, Bundle, Cart, Category, CategoryDetail, CheckoutInput, CookieConsent, CookieConsentInput, CrossSellItem, CurrencySwitcher, type CurrencySwitcherProps, type CurrencySwitcherRenderProps, CustomerAddress, CustomerProfile, FilterField, GiftCardBalance, OrderDetail, OrderListItem, Page, PageDetail, PaginatedResponse, type PersonalOffer, ProductDetail, ProductLabel, ProductListItem, ProductReviewsResponse, ProductsQuery, QuoteRequest, RegisterInput, ReturnRequest, ShopInfo, ShopSeo, type StorageAdapter, StorefrontScripts, type StorefrontScriptsProps, SubmitQuoteInput, SubmitReturnInput, SubmitReviewInput, type UseAddressAutocompleteOptions, type UseAddressAutocompleteReturn, type UseAddressesOptions, type UseCartCountOptions, type UseCartOptions, type UseCategoriesOptions, type UseCategoryOptions, type UseCurrencyResult, type UseCustomerOptions, type UseFacetsOptions, type UseFeaturedOptions, type UseFiltersOptions, type UseLabelsOptions, type UseLoyaltyOptions, type UseMenuOptions, type UseOrderOptions, type UseOrdersOptions, type UsePageOptions, type UsePagesOptions, type UsePaymentMethodsOptions, type UsePersonalOffersOptions, type UseProductOptions, type UseProductsOptions, type UseSearchOptions, type UseShippingMethodsOptions, type UseShippingQuoteOptions, type UseShopInfoOptions, type UseShopScriptsOptions, type UseShopSeoOptions, type UseSubscriptionsOptions, WishlistItem, cookieStorage, createMemoryStorage, detectStorage, localStorageAdapter, memoryStorage, useAddressAutocomplete, useAddresses, useAnalyticsEvents, useAuth, useBehio, useBehioClient, useBundle, useBundles, useCart, useCartCount, useCategories, useCategory, useCheckout, useCookieConsent, useCrossSell, useCurrency, useCustomer, useFacets, useFeatured, useFilters, useGiftCardBalance, useIsInWishlist, useLabels, 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 };
+/**
+ * Format a price amount with currency using Intl.NumberFormat.
+ *
+ * @param amount - The price amount (e.g. 1499, 24.99)
+ * @param currency - ISO 4217 currency code (e.g. "CZK", "EUR", "USD")
+ * @param locale - BCP 47 locale string (e.g. "cs", "en", "de"). Defaults to "cs".
+ * @returns Formatted price string (e.g. "1 499 Kč", "24,99 €")
+ */
+declare function formatPrice(amount: number, currency: string, locale?: string): string;
+
+/**
+ * GA4 e-commerce event helper.
+ *
+ * Fires standard GA4 ecommerce/engagement events (view_item, add_to_cart,
+ * begin_checkout, purchase, search, ...) into whatever analytics runtime the
+ * shop has injected via `<StorefrontScripts/>`, and — crucially — into Behio
+ * Analytics via the sink the tracker registers. One call, both systems.
+ *
+ * Sinks:
+ * - Behio Analytics (`__behioEcommerceSink`) — always, when the tracker is
+ *   mounted. Records the ORIGINAL event name so Behio-exclusive signals
+ *   (variant_selected, newsletter_signup) stay distinct.
+ * - direct GA4 (`gtag` present) -> `gtag("event", name, payload)`
+ * - GTM (`dataLayer` array present) -> `dataLayer.push({event, ecommerce})`
+ *   (with the recommended `ecommerce: null` reset push first)
+ * - neither present (no analytics configured, or consent not granted yet so
+ *   the consent-gated script never loaded) -> silent no-op for the GA path
+ *
+ * Behio-only signal names that have a GA4 recommended equivalent are remapped
+ * for the GA path only (see `GA4_NAME_MAP`), so merchants keep clean GA4
+ * reports while Behio keeps the richer signal.
+ *
+ * Consent stays the script layer's job: this helper never loads anything, it
+ * only talks to runtimes that already exist on the page.
+ */
+type EcommerceEventName = "view_item" | "view_item_list" | "select_item" | "add_to_cart" | "remove_from_cart" | "view_cart" | "add_to_wishlist" | "view_promotion" | "select_promotion" | "begin_checkout" | "add_payment_info" | "add_shipping_info" | "search" | "generate_lead" | "purchase" | "variant_selected" | "newsletter_signup";
+type EcommerceItem = {
+    item_id: string;
+    item_name: string;
+    price?: number;
+    quantity?: number;
+    item_variant?: string;
+    item_category?: string;
+    /** Position in the list (1-based) — for select_item rail/list attribution. */
+    index?: number;
+};
+type EcommercePayload = {
+    currency?: string;
+    /** Order / cart total in `currency`. */
+    value?: number;
+    /** Required for `purchase` — the order number. */
+    transaction_id?: string;
+    shipping?: number;
+    /** Optional for non-item events (search, add_shipping_info, newsletter). */
+    items?: EcommerceItem[];
+    /** search event: the query string. */
+    search_term?: string;
+    /** add_shipping_info: the selected shipping method label. */
+    shipping_tier?: string;
+    /** add_payment_info: the selected payment method type. */
+    payment_type?: string;
+    /** view_item_list / select_item: the list id (shop|category|search|rail:*). */
+    item_list_id?: string;
+    /** view_item_list / select_item: human-readable list name. */
+    item_list_name?: string;
+    /**
+     * Behio-only extra props forwarded verbatim into the Behio event `props`
+     * (ignored by GA4). Use for signals GA4 can't model: resultsCount,
+     * zeroResults, variantId, listId, position, source, ...
+     */
+    props?: Record<string, unknown>;
+};
+declare function trackEcommerceEvent(event: EcommerceEventName, payload: EcommercePayload): void;
+
+/**
+ * Consent-gated visitor identity helpers.
+ *
+ * Behio Analytics has three identity tiers (see BehioAnalyticsTracker):
+ * anonymous (cookieless server hash), consented (persistent behio_visitor_id),
+ * and customer-linked (server stitches at checkout/login). The persistent
+ * `behio_visitor_id` is what unlocks returning-visitor metrics, the customer
+ * journey and Smart Offers.
+ *
+ * Historically the SDK only READ that id and left generation/writing to each
+ * shop's consent banner — so any storefront that forgot the write stayed 100%
+ * anonymous. These helpers move the write into the SDK: the consent banner just
+ * calls `grantAnalyticsConsent(client)` / `revokeAnalyticsConsent(client)` and
+ * everything (id generation, storage, server record, tracker refresh) is
+ * handled here, identically for every template and AI-generated shop.
+ */
+
+/** Read the persistent visitor id (localStorage first, cookie fallback for SSR-set ids). */
+declare function getStoredVisitorId(): string | null;
+/**
+ * Generate a fresh, URL-safe visitor id in the range the ingest DTO accepts
+ * (8..64 chars, [A-Za-z0-9_-]). Uses crypto when available, falling back to
+ * Math.random so it never throws in a locked-down runtime.
+ */
+declare function generateVisitorId(): string;
+/**
+ * Grant analytics consent: ensure a persistent `behio_visitor_id` exists, store
+ * it, record the consent server-side, wire the id into the client (so orders /
+ * logins can be attributed) and notify the tracker to start sending it.
+ *
+ * Returns the visitor id (or an SdkResult error if the server record failed —
+ * the id is still stored locally so tracking works and can retry later).
+ *
+ * @param categories optional marketing/preferences flags (default false); the
+ *                   analytics flag is always true here.
+ */
+declare function grantAnalyticsConsent(client: BehioStorefront, categories?: {
+    marketing?: boolean;
+    preferences?: boolean;
+}): Promise<SdkResult<CookieConsent>>;
+/**
+ * Revoke analytics consent: tell the server, stop sending the id and notify the
+ * tracker. The stored id is kept (consent record now says analytics=false) so a
+ * later re-grant reuses the same visitor rather than fragmenting the journey.
+ */
+declare function revokeAnalyticsConsent(client: BehioStorefront): Promise<SdkResult<{
+    success: boolean;
+}>>;
+
+export { type ActivePromotion, type AddToCartInput, type AnalyticsEventInput, type AuthTokens, BehioAnalyticsTracker, BehioApiError, BehioProvider, type BehioProviderProps, type Bundle, type BundleItem, type Cart, type CartDiscount, type CartItem, type Category, type CategoryDetail, type CheckoutAddress, type CheckoutInput, type CookieConsent, type CookieConsentInput, type CrossSellItem, CurrencySwitcher, type CurrencySwitcherProps, type CurrencySwitcherRenderProps, type CustomerAddress, type CustomerProfile, type EcommerceEventName, type EcommerceItem, type EcommercePayload, type FilterField, type FulfillmentStatus, type GiftCardBalance, type LoginInput, type MessageResponse, type OrderDetail, type OrderItem, type OrderListItem, type OrderStatus, type Page, type PageDetail, type PaginatedResponse, type PaymentStatus, type PersonalOffer, type ProductDetail, type ProductLabel, type ProductListItem, type ProductPrice, type ProductReview, type ProductReviewsResponse, type ProductVariant, type ProductsQuery, type QuoteRequest, type RegisterInput, type ReturnRequest, type ShopInfo, type ShopSeo, type StorageAdapter, StorefrontScripts, type StorefrontScriptsProps, type SubmitQuoteInput, type SubmitReturnInput, type SubmitReviewInput, type UseAddressAutocompleteOptions, type UseAddressAutocompleteReturn, type UseAddressesOptions, type UseCartCountOptions, type UseCartOptions, type UseCategoriesOptions, type UseCategoryOptions, type UseCertificateVerificationOptions, type UseCourseCertificatesOptions, type UseCourseOptions, type UseCoursesOptions, type UseCurrencyResult, type UseCustomerOptions, type UseFacetsOptions, type UseFeaturedOptions, type UseFiltersOptions, type UseLabelsOptions, type UseLessonCommentsOptions, type UseLessonNoteOptions, type UseLessonQuizOptions, type UseLessonTutorOptions, type UseLoyaltyOptions, type UseMenuOptions, type UseOrderOptions, type UseOrdersOptions, type UsePageOptions, type UsePagesOptions, type UsePaymentMethodsOptions, type UsePersonalOffersOptions, type UseProductOptions, type UseProductsOptions, type UseSearchOptions, type UseShippingMethodsOptions, type UseShippingQuoteOptions, type UseShopInfoOptions, type UseShopScriptsOptions, type UseShopSeoOptions, type UseSubscriptionsOptions, type WishlistItem, 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 };