@viu/emporix-sdk-react 2.4.0 → 2.5.1

package/dist/use-returns-Dspo-4xb.d.ts

@@ -0,0 +1,649 @@
+import { Customer, AuthContext, Product, PaginatedItems, ShoppingListItem, ShoppingListDraft, ShoppingList, Category, CategoryNode, Cart, CartItemInput, CartItemUpdate, CartAddress, CartCreated, CreateCartInput, CheckoutResult, CheckoutInput, QuoteCheckoutInput, PaymentMode, PriceMatchByContextInput, PriceMatch, Media, SegmentCategoryTree, SegmentItem, Segment, PasswordChangeInput, CustomerUpdateInput, Address, AddressCreateInput, AddressUpdateInput, PasswordResetRequestInput, PasswordResetConfirmInput, Site, LegalEntity, ContactAssignment, Location, IamGroup, ContactAssignmentCreate, LegalEntityCreate, LocationCreate, LegalEntityUpdate, ContactAssignmentUpdate, LocationUpdate, OrderStatus, Order, SalesOrderPatch, Availability, RedemptionInput, RedemptionCreated, PointsSummary, RedeemOptionList, RedeemCouponResult, RedeemMyPointsInput, ReturnCreated, ReturnInput, ReturnList, Return } from '@viu/emporix-sdk';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { UseQueryResult, UseInfiniteQueryResult, UseMutationResult } from '@tanstack/react-query';
+import { S as SiteContextValue } from './provider-fvcYdqqX.js';
+
+/** Customer authentication state and actions. */
+interface CustomerSessionApi {
+    customerToken: string | null;
+    customer: Customer | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    /** Current refresh token (in-session; set by `login`). */
+    refreshToken: string | null;
+    login: (input: {
+        email: string;
+        password: string;
+    }) => Promise<void>;
+    signup: (input: {
+        email: string;
+        password: string;
+    }) => Promise<void>;
+    /** Authorization-Code SSO: exchanges an IdP `code` for a customer session. */
+    socialLogin: (input: {
+        code: string;
+        redirectUri: string;
+        codeVerifier?: string;
+        sessionId?: string;
+    }) => Promise<void>;
+    /** RFC 8693 token exchange: exchanges an external IdP JWT for a session. */
+    exchangeToken: (input: {
+        subjectToken: string;
+        config?: string;
+    }) => Promise<void>;
+    /** Server-side logout (best-effort), then clears the local session. */
+    logout: () => Promise<void>;
+    /** Refetches the `me` profile query. */
+    refresh: () => Promise<void>;
+    /**
+     * Exchanges the stored refresh token for a fresh customer token (same
+     * sessionId) and updates the stored token. No-op if there is no refresh
+     * token. Throws if the refresh itself fails.
+     */
+    refreshSession: () => Promise<void>;
+}
+/** Manages the customer session: login/signup/logout and the `me` query. */
+declare function useCustomerSession(): CustomerSessionApi;
+
+/** Options accepted by every read hook to override the per-call auth context. */
+interface QueryOpts {
+    auth?: AuthContext;
+}
+
+/** Fetches one product. Default auth: customer if logged in, else anonymous. */
+declare function useProduct(productId: string, options?: QueryOpts): UseQueryResult<Product>;
+/** Fetches one page of products. */
+declare function useProducts(params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}, options?: QueryOpts): UseQueryResult<PaginatedItems<Product>>;
+/** Infinite product list — terminates on `hasNextPage=false`. */
+declare function useProductsInfinite(params?: {
+    pageSize?: number;
+}, options?: QueryOpts): UseInfiniteQueryResult<{
+    pages: PaginatedItems<Product>[];
+    pageParams: number[];
+}>;
+/** Fetches one product by its `code` (URL slug). Disabled when code is empty. */
+declare function useProductByCode(code: string | undefined, options?: QueryOpts): UseQueryResult<Product>;
+/** Full-text product search. Disabled when query is empty/whitespace. */
+declare function useProductSearch(query: string | undefined, params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}, options?: QueryOpts): UseQueryResult<PaginatedItems<Product>>;
+/**
+ * Bulk-fetches products by `code`. Order is not guaranteed — re-index by
+ * `code` if needed. Disabled when `codes` is empty.
+ */
+declare function useProductsByCodes(codes: string[], options?: {
+    chunkSize?: number;
+} & QueryOpts): UseQueryResult<Product[]>;
+
+/** The caller's shopping lists (customer-only). Optionally filtered by name. */
+declare function useShoppingLists(opts?: {
+    name?: string;
+}): UseQueryResult<ShoppingList[]>;
+/** Create a shopping list. */
+declare function useCreateShoppingList(): UseMutationResult<{
+    id: string;
+}, unknown, ShoppingListDraft>;
+/** Delete a named list (or all the customer's lists when `name` is omitted). */
+declare function useDeleteShoppingList(): UseMutationResult<void, unknown, {
+    customerId: string;
+    name?: string;
+}>;
+/** Add/replace an item in a list. */
+declare function useAddToShoppingList(): UseMutationResult<void, unknown, {
+    customerId: string;
+    listName: string;
+    item: ShoppingListItem;
+}>;
+/** Remove an item from a list by productId. */
+declare function useRemoveFromShoppingList(): UseMutationResult<void, unknown, {
+    customerId: string;
+    listName: string;
+    productId: string;
+}>;
+/** Set an item's quantity (0 removes it). */
+declare function useSetShoppingListItemQuantity(): UseMutationResult<void, unknown, {
+    customerId: string;
+    listName: string;
+    productId: string;
+    quantity: number;
+}>;
+
+type UseVariantChildrenOptions = QueryOpts & {
+    pageSize?: number;
+};
+/**
+ * Resolves the VARIANT children of a PARENT_VARIANT product via
+ * `products.listVariantChildren`. The cache key contains `parentVariantId`.
+ * Disabled until `parentVariantId` is a non-empty string.
+ */
+declare function useVariantChildren(parentVariantId: string | undefined, options?: UseVariantChildrenOptions): UseQueryResult<Product[]>;
+
+/** Fetches one category. */
+declare function useCategory(categoryId: string, options?: QueryOpts): UseQueryResult<Category>;
+/** Fetches one page of categories. */
+declare function useCategories(params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}, options?: QueryOpts): UseQueryResult<PaginatedItems<Category>>;
+/** Infinite category list — terminates on `hasNextPage=false`. */
+declare function useCategoriesInfinite(params?: {
+    pageSize?: number;
+}, options?: QueryOpts): UseInfiniteQueryResult<{
+    pages: PaginatedItems<Category>[];
+    pageParams: number[];
+}>;
+/** Fetches the category tree. */
+declare function useCategoryTree(rootId?: string, options?: QueryOpts): UseQueryResult<CategoryNode>;
+/** One page of products in a category. Disabled when categoryId is empty. */
+declare function useProductsInCategory(categoryId: string | undefined, params?: {
+    pageNumber?: number;
+    pageSize?: number;
+}, options?: QueryOpts): UseQueryResult<PaginatedItems<Product>>;
+/** Infinite-scroll product list for a category. Terminates on `hasNextPage=false`. */
+declare function useProductsInCategoryInfinite(categoryId: string | undefined, params?: {
+    pageSize?: number;
+}, options?: QueryOpts): UseInfiniteQueryResult<{
+    pages: PaginatedItems<Product>[];
+    pageParams: number[];
+}>;
+
+/** Fetches a cart by id. Falls back to `storage.getCartId()` when no argument is passed; disabled when neither is set. */
+declare function useCart(cartId?: string, options?: QueryOpts): UseQueryResult<Cart>;
+type Mut<TVars> = UseMutationResult<Cart, unknown, TVars, {
+    previous: Cart | undefined;
+}>;
+/** Cart write operations with optimistic cache updates and rollback. */
+interface CartMutationsApi {
+    addItem: Mut<CartItemInput>;
+    updateItem: Mut<{
+        itemId: string;
+        patch: CartItemUpdate;
+    }>;
+    removeItem: Mut<{
+        itemId: string;
+    }>;
+    clear: Mut<void>;
+    applyCoupon: Mut<{
+        code: string;
+    }>;
+    removeCoupon: Mut<{
+        code: string;
+    }>;
+    setShippingAddress: Mut<CartAddress>;
+    setBillingAddress: Mut<CartAddress>;
+}
+/**
+ * Cart write operations with optimistic cache updates and rollback.
+ *
+ * `cartId` is optional — when omitted, `storage.getCartId()` is resolved at
+ * **mutate-time** (inside `mutationFn`/`onMutate`), so post-mount writes from
+ * `useActiveCart({ create: true })` work without a render race. Throws
+ * `EmporixError("useCartMutations: no cartId available — …")` when storage
+ * is still empty at mutate-time.
+ */
+declare function useCartMutations(cartId?: string): CartMutationsApi;
+/**
+ * Creates a cart. Auto-detects auth (customer if a token is stored, else
+ * anonymous). On success, persists `cartId` via `storage.setCartId` so a later
+ * page reload can resume the same cart with the same anonymous session, then
+ * invalidates `["emporix","cart"]` so `useActiveCart` re-reads storage on the
+ * next render.
+ *
+ * Note: the SDK's `carts.create` returns `CartCreated = { cartId, yrn }`, not
+ * the full `Cart`. The full cart is loaded on demand by `useCart(cartId)` /
+ * `useActiveCart()`.
+ */
+declare function useCreateCart(): UseMutationResult<CartCreated, unknown, CreateCartInput | undefined>;
+/**
+ * Resolves to "the active cart": the cart matching `storage.cartId` if one is
+ * present. With `create: true`, bootstraps a new cart via
+ * `client.carts.getCurrent({siteCode, create: true})` when storage is empty —
+ * useful on cart-page mounts where you want a cart unconditionally.
+ *
+ * Internally delegates to `useCart` so both hooks share the canonical
+ * `["emporix","cart", id, …]` cache entry — optimistic updates from
+ * `useCartMutations` propagate automatically.
+ *
+ * Returns `UseQueryResult<Cart | null>`. `data: null` means "no cart yet and
+ * create was not requested" — a deliberate signal so an empty-state can
+ * render without confusing it with the loading state.
+ */
+declare function useActiveCart(opts?: {
+    create?: boolean;
+    type?: string;
+    legalEntityId?: string;
+    auth?: AuthContext;
+}): UseQueryResult<Cart | null>;
+
+/** Checkout actions bound to the stored customer session. */
+interface CheckoutApi {
+    placeOrder: UseMutationResult<CheckoutResult, unknown, {
+        input: CheckoutInput;
+        saasToken?: string;
+        siteCode?: string;
+    }>;
+    placeOrderFromQuote: UseMutationResult<CheckoutResult, unknown, {
+        input: QuoteCheckoutInput;
+        saasToken?: string;
+        siteCode?: string;
+    }>;
+}
+/** React bindings for the checkout flow. */
+declare function useCheckout(): CheckoutApi;
+/** Lists frontend payment modes for the logged-in customer. */
+declare function usePaymentModes(options?: {
+    enabled?: boolean;
+}): UseQueryResult<PaymentMode[]>;
+
+/**
+ * Resolves prices for `input.items` via `prices.matchByContext`. Defaults to
+ * the anonymous session token (context bound at anonymous-login); pass a
+ * customer token for personalized pricing. The SDK does not cache prices —
+ * control freshness via the query key / `enabled` (re-run before checkout).
+ */
+declare function useMatchPrices(input: PriceMatchByContextInput, options?: {
+    enabled?: boolean;
+    customerToken?: string | null;
+}): UseQueryResult<PriceMatch[]>;
+
+/**
+ * Like {@link useMatchPrices} but chunks large `items` arrays via
+ * `prices.matchByContextChunked` (default 50 items per request, 4 in flight).
+ * Result order is not guaranteed — match by `priceId` / `itemRef.id`.
+ */
+declare function useMatchPricesChunked(input: PriceMatchByContextInput, options?: {
+    enabled?: boolean;
+    customerToken?: string | null;
+    chunkSize?: number;
+    concurrency?: number;
+}): UseQueryResult<PriceMatch[]>;
+
+/**
+ * Reads `productMedia` from the existing product query — no Media-Service
+ * call (those need a server-only scope). For admin/server flows, use
+ * `client.media.listForProduct(productId)` instead.
+ */
+declare function useProductMedia(productId: string): {
+    data: Media[] | undefined;
+    isLoading: boolean;
+    error: unknown;
+};
+
+/** Segments the logged-in customer belongs to (`segment_read_own`). */
+declare function useMySegments(query?: {
+    q?: string;
+    pageNumber?: number;
+    pageSize?: number;
+}): UseQueryResult<Segment[]>;
+/** Item assignments (PRODUCT + CATEGORY) across the caller's active segments. */
+declare function useMySegmentItems(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+}): UseQueryResult<SegmentItem[]>;
+/** Category tree filtered to the caller's segments. */
+declare function useMySegmentCategoryTree(query?: {
+    siteCode?: string;
+    legalEntityId?: string;
+}): UseQueryResult<SegmentCategoryTree>;
+/** Hydrated PRODUCT page for the caller's segments (single-page). */
+declare function useMySegmentProducts(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+    pageNumber?: number;
+    pageSize?: number;
+}): UseQueryResult<PaginatedItems<Product>>;
+/**
+ * Hydrated PRODUCT pages — infinite scroll. `data.pages` is an array of
+ * pages; call `fetchNextPage()` to load the next one. Terminates when
+ * the source segment-items page is not full.
+ */
+declare function useMySegmentProductsInfinite(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+    pageSize?: number;
+}): _tanstack_react_query.UseInfiniteQueryResult<{
+    pages: PaginatedItems<Product>[];
+    pageParams: number[];
+}>;
+/** Hydrated CATEGORY page for the caller's segments (single-page). */
+declare function useMySegmentCategories(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+    pageNumber?: number;
+    pageSize?: number;
+}): UseQueryResult<PaginatedItems<Category>>;
+/**
+ * Hydrated CATEGORY pages — infinite scroll. Same semantics as
+ * {@link useMySegmentProductsInfinite}.
+ */
+declare function useMySegmentCategoriesInfinite(query?: {
+    q?: string;
+    siteCode?: string;
+    legalEntityId?: string;
+    onlyActive?: boolean;
+    pageSize?: number;
+}): _tanstack_react_query.UseInfiniteQueryResult<{
+    pages: PaginatedItems<{
+        id: string;
+        parentId?: string | null;
+        localizedName: {
+            [key: string]: string;
+        };
+        localizedDescription?: {
+            [key: string]: string;
+        };
+        localizedSlug?: {
+            [key: string]: string;
+        };
+        name?: string;
+        description?: string;
+        code?: string;
+        ecn?: Array<string>;
+        validity?: {
+            from?: string;
+            to?: string;
+        };
+        position: number;
+        published: boolean;
+        supercategoriesIds?: Array<string>;
+        ownClassificationMixins?: Array<{
+            name: string;
+            schemaUrl: string;
+            required?: boolean;
+        }>;
+        classificationMixins?: Array<{
+            name: string;
+            mixinPath?: string;
+            schemaUrl: string;
+            required?: boolean;
+            sourceCategoryId?: string;
+        }>;
+        mixins?: {
+            [key: string]: unknown;
+        };
+        metadata: {
+            createdAt?: string;
+            modifiedAt?: string;
+        } & {
+            version?: number;
+        } & {
+            mixins?: {
+                [key: string]: string;
+            };
+        };
+        media: Array<{
+            id?: string;
+            url?: string;
+            contentType?: string;
+            metadata?: {
+                createdAt?: string;
+                modifiedAt?: string;
+            } & unknown;
+            customAttributes?: {
+                id?: string;
+                height?: number;
+                width?: number;
+                sizeKB?: number;
+                type?: string;
+                name?: string;
+            } & unknown;
+        }>;
+    }>[];
+    pageParams: number[];
+}>;
+
+/** Updates the logged-in customer's profile and invalidates the `me` query. */
+declare function useUpdateCustomer(): UseMutationResult<Customer, unknown, CustomerUpdateInput>;
+/**
+ * Changes the customer's password. No cache invalidation — no read query
+ * surfaces the password.
+ */
+declare function useChangePassword(): UseMutationResult<void, unknown, PasswordChangeInput>;
+
+/**
+ * Lists the logged-in customer's addresses. Disabled when no customer token
+ * is in storage (returns idle state, not an error).
+ */
+declare function useCustomerAddresses(options?: QueryOpts): UseQueryResult<Address[]>;
+/** Address CRUD mutations. Each invalidates `customer.addresses` on success. */
+interface AddressMutationsApi {
+    add: UseMutationResult<Address, unknown, AddressCreateInput>;
+    update: UseMutationResult<Address, unknown, {
+        id: string;
+        patch: AddressUpdateInput;
+    }>;
+    remove: UseMutationResult<void, unknown, {
+        id: string;
+    }>;
+}
+declare function useAddressMutations(): AddressMutationsApi;
+
+/**
+ * The 2-step anonymous password-reset flow. `request` triggers the reset
+ * email; `confirm` consumes the token + new password. Both use anonymous
+ * auth — the user is by definition locked out when running this flow.
+ */
+interface PasswordResetApi {
+    request: UseMutationResult<void, unknown, PasswordResetRequestInput>;
+    confirm: UseMutationResult<void, unknown, PasswordResetConfirmInput>;
+}
+declare function usePasswordReset(): PasswordResetApi;
+
+/** Lists active sites for the tenant. */
+declare function useSites(options?: QueryOpts): UseQueryResult<Site[]>;
+/** Convenience: the tenant's default site (the one flagged `default: true`). */
+declare function useDefaultSite(options?: QueryOpts): UseQueryResult<Site>;
+
+/**
+ * Returns the active site context: `{ siteCode, currency, targetLocation,
+ * setSite }`. In MS-2, `currency` and `targetLocation` are always `null`;
+ * they auto-populate in MS-4. `setSite(code)` is sync void in MS-2; it
+ * becomes async in MS-3 (PATCHing `/session-context/{tenant}/me/context`).
+ */
+declare function useSiteContext(): SiteContextValue;
+
+/** Lists the legal entities the calling customer is assigned to. */
+declare function useMyCompanies(): UseQueryResult<LegalEntity[]>;
+
+/** Fetches one legal entity by id. Disabled until a customer token is stored. */
+declare function useCompany(legalEntityId: string | undefined): UseQueryResult<LegalEntity>;
+
+/** Lists contact assignments for one legal entity. */
+declare function useCompanyContacts(legalEntityId: string | undefined): UseQueryResult<ContactAssignment[]>;
+
+/** Lists locations owned by one legal entity. */
+declare function useCompanyLocations(legalEntityId: string | undefined): UseQueryResult<Location[]>;
+
+/** Lists IAM customer-groups for one legal entity. */
+declare function useCompanyGroups(legalEntityId: string | undefined): UseQueryResult<IamGroup[]>;
+
+declare function useCreateCompany(): UseMutationResult<{
+    id: string;
+}, unknown, LegalEntityCreate>;
+declare function useUpdateCompany(): UseMutationResult<LegalEntity, unknown, {
+    id: string;
+    patch: LegalEntityUpdate;
+}>;
+declare function useDeleteCompany(): UseMutationResult<void, unknown, string>;
+declare function useAssignContact(): UseMutationResult<{
+    id: string;
+}, unknown, ContactAssignmentCreate>;
+declare function useUpdateContactAssignment(): UseMutationResult<ContactAssignment, unknown, {
+    id: string;
+    patch: ContactAssignmentUpdate;
+}>;
+declare function useUnassignContact(): UseMutationResult<void, unknown, string>;
+declare function useCreateLocation(): UseMutationResult<{
+    id: string;
+}, unknown, LocationCreate>;
+declare function useUpdateLocation(): UseMutationResult<Location, unknown, {
+    id: string;
+    patch: LocationUpdate;
+}>;
+declare function useDeleteLocation(): UseMutationResult<void, unknown, string>;
+
+interface CompanySwitcherApi {
+    companies: LegalEntity[];
+    active: LegalEntity | null;
+    status: "idle" | "loading" | "switching" | "error";
+    switch: (legalEntityId: string) => Promise<void>;
+    clear: () => Promise<void>;
+}
+/** UI-friendly wrapper around useActiveCompany — exposes switch/clear pair. */
+declare function useCompanySwitcher(): CompanySwitcherApi;
+
+/** Options for `useMyOrders`. Passing `legalEntityId: null` disables the active-company auto-default. */
+interface UseMyOrdersOptions {
+    pageNumber?: number;
+    pageSize?: number;
+    status?: OrderStatus;
+    /** `undefined` = default from `useActiveCompany`. `null` = no filter. */
+    legalEntityId?: string | null;
+    saasToken?: string;
+}
+/** Paginated read of the customer's own orders. Disabled without a customer token. */
+declare function useMyOrders(options?: UseMyOrdersOptions): UseQueryResult<PaginatedItems<Order>>;
+
+interface UseMyOrdersInfiniteOptions {
+    pageSize?: number;
+    status?: OrderStatus;
+    legalEntityId?: string | null;
+    saasToken?: string;
+}
+/** Infinite paginated read of customer orders. Same defaulting rules as useMyOrders. */
+declare function useMyOrdersInfinite(options?: UseMyOrdersInfiniteOptions): UseInfiniteQueryResult<{
+    pages: PaginatedItems<Order>[];
+    pageParams: number[];
+}>;
+
+interface UseOrderOptions {
+    saasToken?: string;
+}
+/** Single-order read by id. Disabled without a customer token or when orderId is undefined. */
+declare function useOrder(orderId: string | undefined, options?: UseOrderOptions): UseQueryResult<Order>;
+
+interface UseCancelOrderVars {
+    orderId: string;
+    saasToken?: string;
+}
+/** Cancels (transitions to DECLINED) a customer's order. Invalidates ["emporix","orders"] on success. */
+declare function useCancelOrder(): UseMutationResult<void, unknown, string | UseCancelOrderVars>;
+
+interface UseOrderTransitionVars {
+    orderId: string;
+    status: OrderStatus;
+    comment?: string;
+    saasToken?: string;
+}
+/** Generic status transition. Server enforces legality. Invalidates ["emporix","orders"] on success. */
+declare function useOrderTransition(): UseMutationResult<void, unknown, UseOrderTransitionVars>;
+
+interface UseReorderVars {
+    orderId: string;
+    saasToken?: string;
+}
+interface UseReorderResult {
+    added: number;
+    errors: unknown[];
+}
+/**
+ * Re-populates the active cart from a past order via a single
+ * `cart.addItemsBatch` call. Best-effort: item-level failures land in
+ * `errors[]` instead of throwing; partial-success result shape stays
+ * `{ added, errors }`.
+ *
+ * Emporix's batch endpoint caps at 200 items per request. Orders with more
+ * line-items are not supported here — extend with chunking if a real use
+ * case appears.
+ */
+declare function useReorder(): UseMutationResult<UseReorderResult, unknown, UseReorderVars>;
+
+/** Service-account read of a single sales-order. Disabled when `auth` is undefined. */
+declare function useSalesOrder(orderId: string | undefined, authCtx: AuthContext | undefined): UseQueryResult<Order>;
+
+interface UseUpdateSalesOrderVars {
+    orderId: string;
+    patch: SalesOrderPatch;
+    auth: AuthContext;
+    recalculate?: boolean;
+}
+/**
+ * Service-account update of a sales-order. Invalidates both
+ * ["emporix","salesorders",id] and ["emporix","orders",id] (the customer-view
+ * cache for the same order) on success.
+ */
+declare function useUpdateSalesOrder(): UseMutationResult<Order, unknown, UseUpdateSalesOrderVars>;
+
+interface UseAvailabilityOptions {
+    enabled?: boolean;
+    customerToken?: string | null;
+    defaultAvailableOnNotFound?: boolean;
+}
+/**
+ * Reads availability for one product on one site via `availability.get`.
+ * Defaults to the anonymous token; pass `customerToken` for a customer context.
+ */
+declare function useAvailability(productId: string, siteCode: string, options?: UseAvailabilityOptions): UseQueryResult<Availability>;
+
+interface UseAvailabilitiesOptions {
+    enabled?: boolean;
+    customerToken?: string | null;
+    defaultAvailableOnNotFound?: boolean;
+}
+/**
+ * Reads availability for many products on one site via `availability.getMany`
+ * (a single batch request). Returns records in input order; missing products
+ * are `{ available: false }` (or `{ available: true }` with
+ * `defaultAvailableOnNotFound`).
+ */
+declare function useAvailabilities(productIds: string[], siteCode: string, options?: UseAvailabilitiesOptions): UseQueryResult<Availability[]>;
+
+/** Variables for the coupon action hooks. */
+interface CouponActionVars {
+    code: string;
+    redemption: RedemptionInput;
+}
+/**
+ * Check whether a coupon can be redeemed for the current shopper. Resolves on
+ * success (redeemable); the mutation enters `isError` when the coupon is not
+ * redeemable. Uses the browser auth context (customer if logged in, else
+ * anonymous) — never the service token.
+ */
+declare function useValidateCoupon(): UseMutationResult<void, unknown, CouponActionVars>;
+/**
+ * Redeem a coupon for the current shopper (creates a redemption). Invalidates
+ * the `["emporix", "coupons"]` cache on success.
+ */
+declare function useRedeemCoupon(): UseMutationResult<RedemptionCreated, unknown, CouponActionVars>;
+
+/** The signed-in customer's reward-points balance (customer-only). */
+declare function useMyRewardPoints(): UseQueryResult<number>;
+/** The signed-in customer's reward-points summary (customer-only). */
+declare function useMyRewardPointsSummary(): UseQueryResult<PointsSummary>;
+/** List redeem options (works for guests and customers). */
+declare function useRedeemOptions(): UseQueryResult<RedeemOptionList>;
+/** Redeem the signed-in customer's points for a coupon code. */
+declare function useRedeemRewardPoints(): UseMutationResult<RedeemCouponResult, unknown, RedeemMyPointsInput>;
+
+/** The signed-in customer's returns (customer-only). */
+declare function useMyReturns(opts?: {
+    query?: Record<string, string | number>;
+}): UseQueryResult<ReturnList>;
+/** A single return by id (customer-only). */
+declare function useReturn(returnId: string | undefined): UseQueryResult<Return>;
+/** Create a return for the signed-in customer. Invalidates the returns list. */
+declare function useCreateReturn(): UseMutationResult<ReturnCreated, unknown, ReturnInput>;
+
+export { useMyOrdersInfinite as $, type AddressMutationsApi as A, useCategoryTree as B, type CartMutationsApi as C, useChangePassword as D, useCheckout as E, useCompany as F, useCompanyContacts as G, useCompanyGroups as H, useCompanyLocations as I, useCompanySwitcher as J, useCreateCart as K, useCreateCompany as L, useCreateLocation as M, useCreateReturn as N, useCreateShoppingList as O, type PasswordResetApi as P, useCustomerAddresses as Q, useCustomerSession as R, useDefaultSite as S, useDeleteCompany as T, type UseAvailabilitiesOptions as U, useDeleteLocation as V, useDeleteShoppingList as W, useMatchPrices as X, useMatchPricesChunked as Y, useMyCompanies as Z, useMyOrders as _, type CheckoutApi as a, useMyReturns as a0, useMyRewardPoints as a1, useMyRewardPointsSummary as a2, useMySegmentCategories as a3, useMySegmentCategoriesInfinite as a4, useMySegmentCategoryTree as a5, useMySegmentItems as a6, useMySegmentProducts as a7, useMySegmentProductsInfinite as a8, useMySegments as a9, useUpdateContactAssignment as aA, useUpdateCustomer as aB, useUpdateLocation as aC, useUpdateSalesOrder as aD, useValidateCoupon as aE, useVariantChildren as aF, useOrder as aa, useOrderTransition as ab, usePasswordReset as ac, usePaymentModes as ad, useProduct as ae, useProductByCode as af, useProductMedia as ag, useProductSearch as ah, useProducts as ai, useProductsByCodes as aj, useProductsInCategory as ak, useProductsInCategoryInfinite as al, useProductsInfinite as am, useRedeemCoupon as an, useRedeemOptions as ao, useRedeemRewardPoints as ap, useRemoveFromShoppingList as aq, useReorder as ar, useReturn as as, useSalesOrder as at, useSetShoppingListItemQuantity as au, useShoppingLists as av, useSiteContext as aw, useSites as ax, useUnassignContact as ay, useUpdateCompany as az, type CompanySwitcherApi as b, type CouponActionVars as c, type CustomerSessionApi as d, type UseAvailabilityOptions as e, type UseCancelOrderVars as f, type UseMyOrdersInfiniteOptions as g, type UseMyOrdersOptions as h, type UseOrderOptions as i, type UseOrderTransitionVars as j, type UseReorderResult as k, type UseReorderVars as l, type UseUpdateSalesOrderVars as m, type UseVariantChildrenOptions as n, useAddToShoppingList as o, useAddressMutations as p, useAssignContact as q, useAvailabilities as r, useAvailability as s, useCancelOrder as t, useActiveCart as u, useCart as v, useCartMutations as w, useCategories as x, useCategoriesInfinite as y, useCategory as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viu/emporix-sdk-react",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "React bindings for the Emporix SDK",
   "license": "MIT",
   "author": {
@@ -71,7 +71,7 @@
   "peerDependencies": {
     "@tanstack/react-query": "^5.51.0",
     "react": "^18.0.0 || ^19.0.0",
-    "@viu/emporix-sdk": "^2.4.0"
+    "@viu/emporix-sdk": "^2.5.0"
   },
   "devDependencies": {
     "@tanstack/react-query": "^5.51.0",
@@ -93,7 +93,7 @@
     "undici": "^6.19.0",
     "typescript": "^5.6.0",
     "vitest": "^2.0.0",
-    "@viu/emporix-sdk": "2.4.0"
+    "@viu/emporix-sdk": "2.5.0"
   },
   "scripts": {
     "build": "tsup",