@behio/storefront-sdk 0.3.0 → 0.5.0

package/dist/index.d.ts

@@ -50,10 +50,50 @@ interface ShopSeo {
     ogDescription: string | null;
     ogImage: string | null;
 }
+/**
+ * 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;
@@ -68,6 +108,17 @@ interface ProductVariant {
     price: ProductPrice;
     inStock: boolean;
     stockQuantity?: number;
+    /**
+     * 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;
@@ -371,6 +422,51 @@ declare class BehioNetworkError extends Error {
     readonly isRetryable = true;
     constructor(message: string, isTimeout?: 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;
+}
+declare function ok<T>(data: T): SdkResult<T>;
+declare function err<T = never>(error: SdkError): SdkResult<T>;
+/**
+ * Converts any thrown value into a canonical SdkError. Used by the
+ * request wrapper when catching internal throws.
+ */
+declare function toSdkError(err: unknown): SdkError;
 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 {
@@ -409,10 +505,85 @@ interface Bundle {
     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;
+    currency: string | null;
+    /** Final customer-facing price. Equals `basePrice` unless free-shipping kicks in. */
+    price: number;
+    /** Per-currency base price from the merchant's config. */
+    basePrice: number;
+    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;
+}
 interface CrossSellItem {
     productId: string;
     slug: string | null;
@@ -572,10 +743,11 @@ declare class BehioStorefront {
     readonly consent: ConsentModule;
     readonly quotes: QuotesModule;
     readonly addresses: AddressModule;
+    readonly shipping: ShippingModule;
     /** Get basic shop info */
-    getShopInfo(): Promise<ShopInfo>;
+    getShopInfo(): Promise<SdkResult<ShopInfo>>;
     /** Get SEO metadata for the shop homepage in the given locale (defaults to shop default). */
-    getShopSeo(locale?: string): Promise<ShopSeo>;
+    getShopSeo(locale?: string): Promise<SdkResult<ShopSeo>>;
     /** Set auth tokens (e.g. from localStorage) */
     setTokens(tokens: {
         accessToken: string;
@@ -607,88 +779,99 @@ declare class BehioStorefront {
         reset: number | null;
     };
     private handleTokenRefresh;
-    /** @internal */
+    /**
+     * 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;
-        /** @internal Prevents infinite refresh loops */
-        _isRetryAfterRefresh?: boolean;
-    }): Promise<T>;
+    }): Promise<SdkResult<T>>;
+    /**
+     * 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<PaginatedResponse<ProductListItem>>;
+    getProducts(query?: ProductsQuery): Promise<SdkResult<PaginatedResponse<ProductListItem>>>;
     /** Get product detail by slug */
     getProduct(slug: string, options?: {
         locale?: string;
         currency?: string;
-    }): Promise<ProductDetail>;
+    }): Promise<SdkResult<ProductDetail>>;
     /** Get category tree */
-    getCategories(locale?: string): Promise<{
+    getCategories(locale?: string): Promise<SdkResult<{
         categories: Category[];
-    }>;
+    }>>;
     /** Get category detail by slug */
-    getCategory(slug: string, locale?: string): Promise<CategoryDetail>;
+    getCategory(slug: string, locale?: string): Promise<SdkResult<CategoryDetail>>;
     /** Get products in a category */
-    getCategoryProducts(slug: string, query?: ProductsQuery): Promise<PaginatedResponse<ProductListItem>>;
+    getCategoryProducts(slug: string, query?: ProductsQuery): Promise<SdkResult<PaginatedResponse<ProductListItem>>>;
     /** Get all labels */
-    getLabels(locale?: string): Promise<{
+    getLabels(locale?: string): Promise<SdkResult<{
         labels: ProductLabel[];
-    }>;
+    }>>;
     /** Get featured products */
     getFeatured(options?: {
         locale?: string;
         currency?: string;
-    }): Promise<PaginatedResponse<ProductListItem>>;
+    }): Promise<SdkResult<PaginatedResponse<ProductListItem>>>;
     /** Get available filter fields for dynamic filter UI */
-    getFilters(): Promise<{
+    getFilters(): Promise<SdkResult<{
         filters: FilterField[];
-    }>;
+    }>>;
     /** Search products */
     search(query: string, options?: {
         page?: number;
         limit?: number;
-    }): Promise<PaginatedResponse<ProductListItem>>;
+    }): Promise<SdkResult<PaginatedResponse<ProductListItem>>>;
     /** List all active bundles */
-    getBundles(): Promise<{
+    getBundles(): Promise<SdkResult<{
         items: Bundle[];
-    }>;
+    }>>;
     /** Get a single bundle by slug */
-    getBundle(slug: string): Promise<Bundle>;
+    getBundle(slug: string): Promise<SdkResult<Bundle>>;
     /** Cross-sell / related / upsell products for a product */
-    getCrossSell(productSlug: string): Promise<{
+    getCrossSell(productSlug: string): Promise<SdkResult<{
         related: CrossSellItem[];
         upsell: CrossSellItem[];
         crossSell: CrossSellItem[];
-    }>;
+    }>>;
     /** Active promotions applicable to a product (with countdown end time) */
-    getProductPromotions(productSlug: string): Promise<{
+    getProductPromotions(productSlug: string): Promise<SdkResult<{
         items: ActivePromotion[];
-    }>;
+    }>>;
     /** Check a gift card code — returns validity and remaining balance */
-    checkGiftCard(code: string): Promise<GiftCardBalance>;
+    checkGiftCard(code: string): Promise<SdkResult<GiftCardBalance>>;
 }
 declare class AuthModule {
     private client;
     constructor(client: BehioStorefront);
     /** Register a new customer */
-    register(input: RegisterInput): Promise<AuthTokens>;
+    register(input: RegisterInput): Promise<SdkResult<AuthTokens>>;
     /** Login with email and password */
-    login(input: LoginInput): Promise<AuthTokens>;
+    login(input: LoginInput): Promise<SdkResult<AuthTokens>>;
     /** Refresh access token using refresh token */
-    refresh(refreshToken?: string): Promise<AuthTokens>;
+    refresh(refreshToken?: string): Promise<SdkResult<AuthTokens>>;
     /** Logout (invalidate refresh token) */
-    logout(refreshToken?: string): Promise<MessageResponse>;
+    logout(refreshToken?: string): Promise<SdkResult<MessageResponse>>;
     /** Request password reset email */
-    forgotPassword(email: string): Promise<MessageResponse>;
+    forgotPassword(email: string): Promise<SdkResult<MessageResponse>>;
     /** Reset password with token */
-    resetPassword(token: string, newPassword: string): Promise<MessageResponse>;
+    resetPassword(token: string, newPassword: string): Promise<SdkResult<MessageResponse>>;
     /** Verify email with token */
-    verifyEmail(token: string): Promise<MessageResponse>;
+    verifyEmail(token: string): Promise<SdkResult<MessageResponse>>;
     /** Check if user is logged in (has access token) */
     isLoggedIn(): boolean;
 }
@@ -696,39 +879,59 @@ declare class CartModule {
     private client;
     constructor(client: BehioStorefront);
     /** Get current cart */
-    get(): Promise<Cart>;
+    get(): Promise<SdkResult<Cart>>;
     /** Add item to cart */
-    addItem(input: AddToCartInput): Promise<Cart & {
+    addItem(input: AddToCartInput): Promise<SdkResult<Cart & {
         newSessionToken?: string;
-    }>;
+    }>>;
     /** Update item quantity */
-    updateQuantity(itemId: string, quantity: number): Promise<Cart>;
+    updateQuantity(itemId: string, quantity: number): Promise<SdkResult<Cart>>;
     /** Remove item from cart */
-    removeItem(itemId: string): Promise<Cart>;
+    removeItem(itemId: string): Promise<SdkResult<Cart>>;
     /** Clear entire cart */
-    clear(): Promise<void>;
+    clear(): Promise<SdkResult<void>>;
     /** Apply a gift card code to the cart. Balance is deducted at checkout. */
-    applyGiftCard(code: string): Promise<Cart>;
+    applyGiftCard(code: string): Promise<SdkResult<Cart>>;
     /** Remove a gift card from the cart */
-    removeGiftCard(): Promise<Cart>;
-    /** Add a bundle to the cart (price is locked at the bundle's current price) */
-    addBundle(bundleId: string, quantity?: number): Promise<Cart>;
+    removeGiftCard(): 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<Cart>;
+    updateBundleQuantity(bundleId: string, quantity: number): Promise<SdkResult<Cart>>;
     /** Remove a bundle from the cart */
-    removeBundle(bundleId: string): Promise<Cart>;
+    removeBundle(bundleId: string): Promise<SdkResult<Cart>>;
     /** Merge anonymous cart into authenticated customer cart */
-    merge(): Promise<Cart>;
+    merge(): Promise<SdkResult<Cart>>;
     /** Apply discount code */
-    applyDiscount(code: string): Promise<Cart>;
+    applyDiscount(code: string): Promise<SdkResult<Cart>>;
     /** Remove discount code */
-    removeDiscount(): Promise<Cart>;
+    removeDiscount(): Promise<SdkResult<Cart>>;
 }
 declare class CheckoutModule {
     private client;
     constructor(client: BehioStorefront);
     /** Create order from cart */
-    createOrder(input: CheckoutInput): Promise<OrderDetail>;
+    createOrder(input: CheckoutInput): Promise<SdkResult<OrderDetail>>;
 }
 declare class OrdersModule {
     private client;
@@ -737,92 +940,92 @@ declare class OrdersModule {
     list(options?: {
         page?: number;
         limit?: number;
-    }): Promise<PaginatedResponse<OrderListItem>>;
+    }): Promise<SdkResult<PaginatedResponse<OrderListItem>>>;
     /** Get order detail (requires auth) */
-    get(orderNumber: string): Promise<OrderDetail>;
+    get(orderNumber: string): Promise<SdkResult<OrderDetail>>;
     /** Cancel a PENDING order (requires auth) */
-    cancel(orderNumber: string): Promise<OrderDetail>;
+    cancel(orderNumber: string): Promise<SdkResult<OrderDetail>>;
     /** Track order by tracking token (no customer login required, only API key) */
-    track(trackingToken: string): Promise<OrderDetail>;
+    track(trackingToken: string): Promise<SdkResult<OrderDetail>>;
 }
 declare class CustomerModule {
     private client;
     constructor(client: BehioStorefront);
     /** Get customer profile */
-    getProfile(): Promise<CustomerProfile>;
+    getProfile(): Promise<SdkResult<CustomerProfile>>;
     /** Update customer profile */
-    updateProfile(data: Partial<Pick<CustomerProfile, "firstName" | "lastName" | "phone">>): Promise<CustomerProfile>;
+    updateProfile(data: Partial<Pick<CustomerProfile, "firstName" | "lastName" | "phone">>): Promise<SdkResult<CustomerProfile>>;
     /** Change password */
-    changePassword(currentPassword: string, newPassword: string): Promise<MessageResponse>;
+    changePassword(currentPassword: string, newPassword: string): Promise<SdkResult<MessageResponse>>;
     /** List addresses */
-    getAddresses(): Promise<{
+    getAddresses(): Promise<SdkResult<{
         items: CustomerAddress[];
-    }>;
+    }>>;
     /** Create address */
-    createAddress(address: Omit<CustomerAddress, "id">): Promise<CustomerAddress>;
+    createAddress(address: Omit<CustomerAddress, "id">): Promise<SdkResult<CustomerAddress>>;
     /** Update address */
-    updateAddress(addressId: string, data: Partial<CustomerAddress>): Promise<CustomerAddress>;
+    updateAddress(addressId: string, data: Partial<CustomerAddress>): Promise<SdkResult<CustomerAddress>>;
     /** Delete address */
-    deleteAddress(addressId: string): Promise<void>;
+    deleteAddress(addressId: string): Promise<SdkResult<void>>;
 }
 declare class PagesModule {
     private client;
     constructor(client: BehioStorefront);
     /** List CMS pages */
-    list(locale?: string): Promise<{
+    list(locale?: string): Promise<SdkResult<{
         pages: Page[];
-    }>;
+    }>>;
     /** Get page by slug */
-    get(slug: string, locale?: string): Promise<PageDetail>;
+    get(slug: string, locale?: string): Promise<SdkResult<PageDetail>>;
 }
 declare class WishlistModule {
     private client;
     constructor(client: BehioStorefront);
-    get(): Promise<{
+    get(): Promise<SdkResult<{
         items: WishlistItem[];
-    }>;
-    add(productId: string): Promise<{
+    }>>;
+    add(productId: string): Promise<SdkResult<{
         success: boolean;
-    }>;
-    remove(productId: string): Promise<{
+    }>>;
+    remove(productId: string): Promise<SdkResult<{
         success: boolean;
-    }>;
-    isInWishlist(productId: string): Promise<{
+    }>>;
+    isInWishlist(productId: string): Promise<SdkResult<{
         inWishlist: boolean;
-    }>;
+    }>>;
 }
 declare class ReviewsModule {
     private client;
     constructor(client: BehioStorefront);
-    getProductReviews(productId: string, page?: number, limit?: number): Promise<ProductReviewsResponse>;
-    submit(input: SubmitReviewInput): Promise<{
+    getProductReviews(productId: string, page?: number, limit?: number): Promise<SdkResult<ProductReviewsResponse>>;
+    submit(input: SubmitReviewInput): Promise<SdkResult<{
         id: string;
-    }>;
-    voteHelpful(reviewId: string, helpful: boolean): Promise<{
+    }>>;
+    voteHelpful(reviewId: string, helpful: boolean): Promise<SdkResult<{
         success: boolean;
-    }>;
+    }>>;
 }
 declare class ReturnsModule {
     private client;
     constructor(client: BehioStorefront);
-    submit(input: SubmitReturnInput): Promise<ReturnRequest>;
-    getStatus(returnId: string, email: string): Promise<ReturnRequest>;
+    submit(input: SubmitReturnInput): Promise<SdkResult<ReturnRequest>>;
+    getStatus(returnId: string, email: string): Promise<SdkResult<ReturnRequest>>;
 }
 declare class ConsentModule {
     private client;
     constructor(client: BehioStorefront);
-    record(input: CookieConsentInput): Promise<CookieConsent>;
-    get(visitorId: string): Promise<CookieConsent | null>;
-    revoke(visitorId: string): Promise<{
+    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<QuoteRequest>;
-    accept(quoteId: string, email: string): Promise<QuoteRequest>;
-    getStatus(quoteId: string): Promise<QuoteRequest>;
+    submit(input: SubmitQuoteInput): Promise<SdkResult<QuoteRequest>>;
+    accept(quoteId: string, email: string): Promise<SdkResult<QuoteRequest>>;
+    getStatus(quoteId: string): Promise<SdkResult<QuoteRequest>>;
 }
 interface AddressSuggestion {
     placeId: string;
@@ -848,11 +1051,52 @@ 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<{
+    autocomplete(query: string, country: string): Promise<SdkResult<{
         suggestions: AddressSuggestion[];
-    }>;
+    }>>;
     /** Get full structured address from a suggestion's placeId */
-    getDetail(placeId: string): Promise<AddressDetail>;
+    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[];
+    }>>;
 }
 
-export { type ActivePromotion, type AddToCartInput, type AddressDetail, type AddressSuggestion, type AddressType, AddressTypes, type AuthTokens, BehioApiError, type BehioErrorCode, type BehioEventHandler, type BehioEventType, BehioNetworkError, BehioStorefront, type BehioStorefrontConfig, type Bundle, type BundleItem, type Cart, type CartDiscount, type CartItem, type CartItemProduct, type Category, type CategoryDetail, type CheckoutAddress, type CheckoutInput, type CookieConsent, type CookieConsentInput, type CrossSellItem, type CustomerAddress, type CustomerProfile, type DataGroupFieldType, type FilterField, type FulfillmentStatus, FulfillmentStatuses, type GiftCardBalance, type LoginInput, type MessageResponse, type OrderDetail, type OrderItem, type OrderListItem, type OrderStatus, type OrderStatusHistory, OrderStatuses, type Page, type PageDetail, type PaginatedResponse, type PaymentStatus, PaymentStatuses, type ProductDetail, type ProductLabel, type ProductListItem, type ProductPrice, type ProductReview, type ProductReviewsResponse, ProductSort, type ProductSortValue, type ProductVariant, type ProductVolumePrice, type ProductsQuery, type QuoteRequest, type RegisterInput, type RequestInterceptor, type RequestInterceptorConfig, type ResponseInterceptor, type ResponseInterceptorData, type ReturnRequest, type ShopInfo, type ShopSeo, type SubmitQuoteInput, type SubmitReturnInput, type SubmitReviewInput, type WishlistItem };
+export { type ActivePromotion, type AddToCartInput, type AddressDetail, type AddressSuggestion, type AddressType, AddressTypes, type AuthTokens, BehioApiError, type BehioErrorCode, type BehioEventHandler, type BehioEventType, BehioNetworkError, BehioStorefront, type BehioStorefrontConfig, type Bundle, type BundleItem, type Cart, type CartDiscount, type CartItem, type CartItemProduct, type Category, type CategoryDetail, type CheckoutAddress, type CheckoutInput, type CheckoutPaymentMethod, type CookieConsent, type CookieConsentInput, type CrossSellItem, type CustomerAddress, type CustomerProfile, type DataGroupFieldType, type FilterField, type FulfillmentStatus, FulfillmentStatuses, type GiftCardBalance, type LoginInput, type MessageResponse, type OrderDetail, type OrderItem, type OrderListItem, type OrderStatus, type OrderStatusHistory, OrderStatuses, type Page, type PageDetail, type PaginatedResponse, type PaymentStatus, PaymentStatuses, type ProductDetail, type ProductLabel, type ProductListItem, type ProductPrice, type ProductReview, type ProductReviewsResponse, ProductSort, type ProductSortValue, type ProductVariant, type ProductVolumePrice, type ProductsQuery, type QuoteRequest, type RegisterInput, type RequestInterceptor, type RequestInterceptorConfig, type ResponseInterceptor, type ResponseInterceptorData, type ReturnRequest, type SdkError, type SdkResult, type ShippingMethodSummary, type ShippingQuote, type ShippingQuoteInput, type ShopInfo, type ShopSeo, type SubmitQuoteInput, type SubmitReturnInput, type SubmitReviewInput, type WishlistItem, err, ok, toSdkError };

package/dist/index.js

@@ -7,14 +7,20 @@
 
 
 
-var _chunkZEPWNT56js = require('./chunk-ZEPWNT56.js');
 
 
 
+var _chunkKRGDHGTYjs = require('./chunk-KRGDHGTY.js');
 
 
 
 
 
 
-exports.AddressTypes = _chunkZEPWNT56js.AddressTypes; exports.BehioApiError = _chunkZEPWNT56js.BehioApiError; exports.BehioNetworkError = _chunkZEPWNT56js.BehioNetworkError; exports.BehioStorefront = _chunkZEPWNT56js.BehioStorefront; exports.FulfillmentStatuses = _chunkZEPWNT56js.FulfillmentStatuses; exports.OrderStatuses = _chunkZEPWNT56js.OrderStatuses; exports.PaymentStatuses = _chunkZEPWNT56js.PaymentStatuses; exports.ProductSort = _chunkZEPWNT56js.ProductSort;
+
+
+
+
+
+
+exports.AddressTypes = _chunkKRGDHGTYjs.AddressTypes; exports.BehioApiError = _chunkKRGDHGTYjs.BehioApiError; exports.BehioNetworkError = _chunkKRGDHGTYjs.BehioNetworkError; exports.BehioStorefront = _chunkKRGDHGTYjs.BehioStorefront; exports.FulfillmentStatuses = _chunkKRGDHGTYjs.FulfillmentStatuses; exports.OrderStatuses = _chunkKRGDHGTYjs.OrderStatuses; exports.PaymentStatuses = _chunkKRGDHGTYjs.PaymentStatuses; exports.ProductSort = _chunkKRGDHGTYjs.ProductSort; exports.err = _chunkKRGDHGTYjs.err; exports.ok = _chunkKRGDHGTYjs.ok; exports.toSdkError = _chunkKRGDHGTYjs.toSdkError;

package/dist/index.mjs

@@ -6,8 +6,11 @@ import {
   FulfillmentStatuses,
   OrderStatuses,
   PaymentStatuses,
-  ProductSort
-} from "./chunk-45FTJKSW.mjs";
+  ProductSort,
+  err,
+  ok,
+  toSdkError
+} from "./chunk-3GOQSB25.mjs";
 export {
   AddressTypes,
   BehioApiError,
@@ -16,5 +19,8 @@ export {
   FulfillmentStatuses,
   OrderStatuses,
   PaymentStatuses,
-  ProductSort
+  ProductSort,
+  err,
+  ok,
+  toSdkError
 };