@simpleapps-com/augur-hooks 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,674 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import * as zustand from 'zustand';
+import * as _simpleapps_com_augur_utils from '@simpleapps-com/augur-utils';
+import { TCartLine, TItemsFilters, TPriceData, TInvMastDoc, TCategory, TItemDetails, TProductCategory, TProductItem } from '@simpleapps-com/augur-utils';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { QueryKey } from '@tanstack/react-query';
+
+/**
+ * Minimal type for the augur-api SDK instance.
+ * Consumers provide their concrete AugurAPI instance; we keep the type
+ * loose so augur-hooks doesn't need to depend directly on the SDK package.
+ */
+type AugurApiClient = any;
+interface AugurHooksProviderProps {
+    api: AugurApiClient;
+    children: ReactNode;
+}
+/**
+ * Provides the augur-api SDK instance to all hooks in the tree.
+ *
+ * ```tsx
+ * import { AugurAPI } from "@simpleapps-com/augur-api";
+ * const api = new AugurAPI({ baseUrl: "...", token: "..." });
+ *
+ * <AugurHooksProvider api={api}>
+ *   <App />
+ * </AugurHooksProvider>
+ * ```
+ */
+declare function AugurHooksProvider({ api, children }: AugurHooksProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Returns the augur-api SDK instance from context.
+ * Throws if called outside of `<AugurHooksProvider>`.
+ */
+declare function useAugurApi(): AugurApiClient;
+
+/**
+ * Hook-specific types that don't belong in augur-utils.
+ * These describe hook parameters and API response shapes.
+ */
+/** Parameters for product search queries. */
+type PageData = {
+    categoryIdList?: string;
+    filters?: any;
+    limit: number;
+    page: number;
+    offset: number;
+    q: string;
+    sortBy: string;
+    tagslist?: string;
+    itemCategoryUid?: number;
+};
+/** A single search suggestion from OpenSearch. */
+type SearchSuggestion = {
+    suggestionsUid: number;
+    queryStringUid: number;
+    suggestionsString: string;
+    suggestionsMetaphone: string | null;
+    avgTotalResults: number;
+    dateCreated: string;
+    dateLastModified: string;
+    updateCd: number;
+    statusCd: number;
+    processCd: number;
+    score: number;
+};
+/** Response shape from the search suggestions endpoint. */
+type SearchSuggestionsResponse = {
+    count: number;
+    data: SearchSuggestion[];
+    message: string;
+    options: unknown[];
+    params: unknown[];
+    status: number;
+    total: number;
+    totalResults: number;
+};
+/** API options for item category queries. */
+interface GetItemCategoryApiOptions {
+    childrenFilter?: string;
+    childrenLimit?: number;
+    childrenOffset?: number;
+    classId5List?: string;
+    filters?: Record<string, any>;
+    orderBy?: string;
+    path?: string;
+    productCollection?: string;
+    rootItemCategoryId?: string;
+}
+
+interface CartState {
+    cartHdrUid: number | string | undefined;
+    cartLines: TCartLine[];
+    cartItemCount: number;
+    setCartHdrUid: (cartHdrUid: number | string | undefined) => void;
+    setCartLines: (cartLines: TCartLine[]) => void;
+}
+declare const useCartStore: zustand.UseBoundStore<Omit<zustand.StoreApi<CartState>, "setState" | "devtools"> & {
+    setState(partial: CartState | Partial<CartState> | ((state: CartState) => CartState | Partial<CartState>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: CartState | ((state: CartState) => CartState), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}>;
+declare const useCartHdrUid: () => string | number | undefined;
+declare const useCartLines: () => TCartLine[];
+declare const useCartItemCount: () => number;
+declare const useSetCartHdrUid: () => (cartHdrUid: number | string | undefined) => void;
+declare const useSetCartLines: () => (cartLines: TCartLine[]) => void;
+
+interface ItemsFiltersState {
+    initialFiltersState: TItemsFilters;
+    itemsFilters: TItemsFilters;
+    setItemsFilters: (itemFilters: TItemsFilters) => void;
+}
+declare const useItemFiltersStore: zustand.UseBoundStore<Omit<zustand.StoreApi<ItemsFiltersState>, "setState" | "devtools"> & {
+    setState(partial: ItemsFiltersState | Partial<ItemsFiltersState> | ((state: ItemsFiltersState) => ItemsFiltersState | Partial<ItemsFiltersState>), replace?: false | undefined, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    setState(state: ItemsFiltersState | ((state: ItemsFiltersState) => ItemsFiltersState), replace: true, action?: (string | {
+        [x: string]: unknown;
+        [x: number]: unknown;
+        [x: symbol]: unknown;
+        type: string;
+    }) | undefined): void;
+    devtools: {
+        cleanup: () => void;
+    };
+}>;
+
+/**
+ * Debounces a rapidly-changing value.
+ * Returns the latest value only after `delay` ms of inactivity.
+ */
+declare function useDebounce<T>(value: T, delay?: number): T;
+
+/**
+ * Hook that returns a price formatter.
+ * Wraps Intl.NumberFormat with configurable locale/currency.
+ */
+declare function useFormatPrice(locale?: string, currency?: string): {
+    formatPrice: (price: number) => string;
+};
+
+interface UseItemPriceOptions {
+    enabled?: boolean;
+    /** Override the default queryFn (e.g. with a cached server action). */
+    queryFn?: () => Promise<TPriceData>;
+}
+declare const PRICE_CACHE_OPTIONS: {
+    readonly refetchOnReconnect: true;
+    readonly refetchOnWindowFocus: false;
+    readonly meta: {
+        readonly persist: true;
+    };
+    readonly staleTime: number;
+    readonly gcTime: number;
+};
+/**
+ * Generates a consistent query key for item price queries.
+ * Usable in both client hooks and server-side prefetch.
+ */
+declare const getItemPriceKey: (itemId: string | undefined, customerId: string | number | undefined, quantity?: number) => readonly ["price", string, string | number | undefined, number];
+/**
+ * Query options for item price. Accepts the SDK instance so it works
+ * in both client (via provider) and server (via direct construction).
+ */
+declare const getItemPriceOptions: (api: AugurApiClient, itemId: string | undefined, customerId: string | number | undefined, quantity?: number) => {
+    refetchOnReconnect: true;
+    refetchOnWindowFocus: false;
+    meta: {
+        readonly persist: true;
+    };
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["price", string, string | number | undefined, number];
+    queryFn: () => Promise<TPriceData>;
+};
+/**
+ * Fetches and caches item pricing via the augur-api SDK.
+ *
+ * Pass `options.queryFn` to override with a cached server action:
+ * ```ts
+ * useItemPrice(itemId, customerId, 1, {
+ *   queryFn: () => getItemPriceCached(itemId, customerId, 1),
+ * });
+ * ```
+ */
+declare function useItemPrice(itemId: string | undefined, customerId: string | number | undefined, quantity?: number, options?: UseItemPriceOptions): _tanstack_react_query.UseQueryResult<TPriceData, Error>;
+
+interface UseInvMastDocOptions {
+    enabled?: boolean;
+    includePricing?: "Y" | "N";
+    /** Initial data from server -- enables instant render without loading state. */
+    initialData?: TInvMastDoc;
+    /** Override the default queryFn (e.g. with a cached server action). */
+    queryFn?: () => Promise<TInvMastDoc>;
+}
+declare const INV_MAST_DOC_CACHE_OPTIONS: {
+    readonly staleTime: number;
+    readonly gcTime: number;
+};
+/**
+ * Generates a consistent query key for inv mast doc queries.
+ * Usable in both client hooks and server-side prefetch.
+ */
+declare const getInvMastDocKey: (invMastUid: number, itemId: string, includePricing: "Y" | "N") => readonly ["invMastDoc", number, string, "Y" | "N"];
+/**
+ * Query options for inv mast doc. Accepts the SDK instance so it works
+ * in both client (via provider) and server (via direct construction).
+ */
+declare const getInvMastDocOptions: (api: AugurApiClient, invMastUid: number, itemId: string, includePricing: "Y" | "N") => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["invMastDoc", number, string, "Y" | "N"];
+    queryFn: () => Promise<TInvMastDoc>;
+};
+/**
+ * Fetches and caches an inventory master document via the augur-api SDK.
+ */
+declare function useInvMastDoc(invMastUid: number, itemId: string, options?: UseInvMastDocOptions): {
+    item: TInvMastDoc | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+
+interface UseItemCategoryOptions {
+    enabled?: boolean;
+    apiOptions?: GetItemCategoryApiOptions;
+    /** Override the default queryFn (e.g. with a cached server action). */
+    queryFn?: () => Promise<TCategory>;
+}
+declare const CATEGORY_CACHE_OPTIONS: {
+    readonly staleTime: number;
+    readonly gcTime: number;
+};
+type ItemCategoryQueryKey = readonly [
+    "itemCategory",
+    number,
+    GetItemCategoryApiOptions | undefined
+];
+/**
+ * Generates a consistent query key for item category queries.
+ * Usable in both client hooks and server-side prefetch.
+ */
+declare const getItemCategoryKey: (itemCategoryUid: number, apiOptions?: GetItemCategoryApiOptions) => ItemCategoryQueryKey;
+/**
+ * Query options for item category. Accepts the SDK instance so it works
+ * in both client (via provider) and server (via direct construction).
+ */
+declare const getItemCategoryOptions: (api: AugurApiClient, itemCategoryUid: number, apiOptions?: GetItemCategoryApiOptions) => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: ItemCategoryQueryKey;
+    queryFn: () => Promise<TCategory>;
+};
+/**
+ * Fetches and caches item category data via the augur-api SDK.
+ */
+declare function useItemCategory(itemCategoryUid: number, options?: UseItemCategoryOptions): {
+    category: TCategory | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+
+interface UseInvMastOptions {
+    enabled?: boolean;
+    queryFn?: () => Promise<TItemDetails>;
+}
+declare const INV_MAST_CACHE_OPTIONS: {
+    readonly staleTime: number;
+    readonly gcTime: number;
+};
+declare const getInvMastKey: (invMastUid: number, itemId: string) => readonly ["invMast", number, string];
+declare const getInvMastOptions: (api: AugurApiClient, invMastUid: number, itemId: string) => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["invMast", number, string];
+    queryFn: () => Promise<TItemDetails>;
+};
+declare function useInvMast(invMastUid: number, itemId: string, options?: UseInvMastOptions): {
+    item: TItemDetails | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+
+interface UseInvMastStockOptions {
+    enabled?: boolean;
+    queryFn?: () => Promise<number>;
+}
+declare const getInvMastStockKey: (invMastUid: number | string) => readonly ["invMastStock", string | number];
+declare const getInvMastStockOptions: (api: AugurApiClient, invMastUid: number | string) => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["invMastStock", string | number];
+    queryFn: () => Promise<number>;
+};
+declare function useInvMastStock(invMastUid: number | string, options?: UseInvMastStockOptions): {
+    qtyOnHand: number | null;
+    loading: boolean;
+    error: Error | null;
+};
+
+type ProductCategoryResponse = {
+    itemCategoryDesc: string;
+    childrenTotal: number;
+    children: TProductCategory[];
+    categoryImage: string | null;
+};
+interface UseProductCategoryOptions {
+    enabled?: boolean;
+    queryFn?: () => Promise<ProductCategoryResponse>;
+}
+declare const getProductCategoryKey: (itemCategoryUid: number | string | null) => readonly ["productCategory", string | number | null];
+declare const getProductCategoryOptions: (api: AugurApiClient, itemCategoryUid: number | string) => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["productCategory", string | number | null];
+    queryFn: () => Promise<ProductCategoryResponse>;
+};
+declare function useProductCategory(itemCategoryUid: number | string | null, options?: UseProductCategoryOptions): {
+    childrenTotal: number;
+    itemCategoryDesc: string;
+    productCategories: TProductCategory[] | null;
+    productCategoryImage: string | null;
+    loading: boolean;
+    error: Error | null;
+};
+
+interface UseItemDetailsOptions {
+    enabled?: boolean;
+    queryFn?: () => Promise<TItemDetails>;
+}
+declare const getItemDetailsKey: (itemId: number | string) => readonly ["itemDetails", string | number];
+declare const getItemDetailsOptions: (api: AugurApiClient, itemId: number | string) => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["itemDetails", string | number];
+    queryFn: () => Promise<TItemDetails>;
+};
+declare function useItemDetails(itemId: number | string | undefined, options?: UseItemDetailsOptions): {
+    itemCategoryUid: number | null | undefined;
+    itemDetails: TItemDetails | null;
+    loading: boolean;
+    error: Error | null;
+};
+
+interface UseItemAttributesOptions {
+    enabled?: boolean;
+    queryFn?: () => Promise<{
+        attributes: any[];
+    }>;
+}
+declare const getItemAttributesKey: (itemCategoryUid: number | string | null) => readonly ["itemAttributes", string | number | null];
+declare const getItemAttributesOptions: (api: AugurApiClient, itemCategoryUid: number | string) => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["itemAttributes", string | number | null];
+    queryFn: () => Promise<any>;
+};
+declare function useItemAttributes(itemCategoryUid: number | string | null, options?: UseItemAttributesOptions): {
+    attributes: any;
+    loading: boolean;
+    error: Error | null;
+};
+
+type ProductSearchResponse = {
+    items: TProductItem[];
+    totalResults: number;
+};
+interface UseProductSearchOptions {
+    /** Override the default queryFn (e.g. with a cached server action). */
+    queryFn?: () => Promise<ProductSearchResponse>;
+}
+/**
+ * Generates a consistent query key for product search queries.
+ */
+declare const getProductSearchKey: (pageData: PageData) => readonly ["productSearch", string, number, number, string, number | undefined];
+/**
+ * Query options for product search. Accepts the SDK instance so it works
+ * in both client (via provider) and server (via direct construction).
+ */
+declare const getProductSearchOptions: (api: AugurApiClient, pageData: PageData) => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["productSearch", string, number, number, string, number | undefined];
+    queryFn: () => Promise<ProductSearchResponse>;
+};
+/**
+ * Searches products via the augur-api OpenSearch endpoint.
+ * Replaces the ampro-online pattern of fetching from a Next.js API route.
+ */
+declare function useProductSearch(pageData: PageData, options?: UseProductSearchOptions): {
+    productItems: TProductItem[] | null;
+    total: number;
+    loading: boolean;
+    error: Error | null;
+};
+
+interface UseSearchSuggestionsOptions {
+    enabled?: boolean;
+    limit?: number;
+    offset?: number;
+    /** Override the default queryFn (e.g. with a cached server action). */
+    queryFn?: () => Promise<SearchSuggestionsResponse>;
+}
+/**
+ * Generates a consistent query key for search suggestion queries.
+ */
+declare const getSearchSuggestionsKey: (query: string, limit: number, offset: number) => readonly ["searchSuggestions", string, number, number];
+/**
+ * Query options for search suggestions. Accepts the SDK instance so it works
+ * in both client (via provider) and server (via direct construction).
+ */
+declare const getSearchSuggestionsOptions: (api: AugurApiClient, query: string, limit?: number, offset?: number) => {
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["searchSuggestions", string, number, number];
+    queryFn: () => Promise<SearchSuggestionsResponse>;
+};
+/**
+ * Fetches search suggestions via the augur-api OpenSearch endpoint.
+ * Replaces the ampro-online pattern of fetching from a Next.js API route.
+ */
+declare function useSearchSuggestions(query: string, options?: UseSearchSuggestionsOptions): {
+    suggestions: SearchSuggestion[];
+    total: number;
+    isLoading: boolean;
+    error: Error | null;
+};
+
+type CartLineInput = Pick<TCartLine, "invMastUid" | "quantity" | "unitOfMeasure"> & {
+    cartHdrUid?: number | string | undefined;
+};
+/** Site-specific callbacks injected into useCartActions. */
+interface CartActionCallbacks {
+    /** Add items to cart via API. Returns true on success. */
+    addToCart: (cartHdrUid: number, items: Array<{
+        cartHdrUid: number;
+        invMastUid: number;
+        quantity: number;
+        unitOfMeasure: string;
+    }>) => Promise<boolean | unknown>;
+    /** Update cart lines via API. Returns true on success. */
+    updateCartLines: (cartHdrUid: number, lines: TCartLine[]) => Promise<boolean | unknown>;
+    /** Delete all items from cart via API. Returns true on success. */
+    deleteItemsFromCart: (cartHdrUid: number) => Promise<boolean | unknown>;
+    /** Optional toast notification callback. */
+    toast?: {
+        info?: (message: string) => void;
+        error?: (message: string) => void;
+        success?: (message: string) => void;
+    };
+}
+interface CartActionOptions {
+    showToast?: boolean;
+    itemId?: string;
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+}
+/**
+ * Optimistic cart actions hook with automatic rollback on failure.
+ *
+ * Accepts site-specific server action callbacks so the hook itself
+ * has no dependency on any particular server action implementation.
+ *
+ * @example
+ * ```tsx
+ * import { useCartActions } from "@simpleapps-com/augur-hooks";
+ * import { addToCart, updateCartLines, deleteItemsFromCart } from "@/lib/actions/commerce";
+ * import { toast } from "react-toastify";
+ *
+ * const cart = useCartActions({
+ *   addToCart, updateCartLines, deleteItemsFromCart,
+ *   toast: { info: toast.info, error: toast.error },
+ * });
+ *
+ * await cart.addToCart({ invMastUid: 123, quantity: 1, unitOfMeasure: "EA" });
+ * ```
+ */
+declare function useCartActions(callbacks: CartActionCallbacks): {
+    addToCart: (item: CartLineInput, options?: CartActionOptions) => Promise<boolean>;
+    updateQuantity: (invMastUid: number, newQuantity: number, options?: CartActionOptions) => Promise<boolean>;
+    removeFromCart: (invMastUid: number, options?: CartActionOptions) => Promise<boolean>;
+    clearCart: (options?: Omit<CartActionOptions, "itemId">) => Promise<boolean>;
+    isInCart: (invMastUid: number) => boolean;
+    getItemQuantity: (invMastUid: number) => number;
+    cartHdrUid: string | number | undefined;
+    cartLines: TCartLine[];
+    invalidateCartCache: () => void;
+};
+
+/** Session info passed from the consumer's auth system. */
+interface CartSessionInfo {
+    /** Auth status: "loading" | "authenticated" | "unauthenticated" */
+    status: "loading" | "authenticated" | "unauthenticated";
+    /** User's ID (e.g., Joomla user ID). Undefined if not authenticated. */
+    userId?: string | number;
+    /** Cart header UID from the auth session, if available. */
+    cartHdrUid?: number;
+}
+/** Site-specific callbacks injected into useCartInitialization. */
+interface CartInitCallbacks {
+    /** Look up or create a cart header. Returns { cartHdrUid, cartToken? }. */
+    cartHdrLookup: (userId: string | number, cartToken: string) => Promise<{
+        cartHdrUid: number;
+        cartToken?: string;
+    } | null>;
+    /** Fetch cart line items for a given cart header UID. */
+    getCartLines: (cartHdrUid: number) => Promise<TCartLine[]>;
+    /** Get the current cart token from cookies. */
+    getCartToken: () => string | null;
+    /** Save cart token to cookies. */
+    saveCartToken: (token: string) => void;
+    /** Generate a new unique cart token (e.g., uuidv4). */
+    generateCartToken: () => string;
+}
+/**
+ * Initialize cart state from session (authenticated) or cookie (guest).
+ * Call once in the root layout.
+ *
+ * @example
+ * ```tsx
+ * import { useCartInitialization } from "@simpleapps-com/augur-hooks";
+ * import { useSession } from "next-auth/react";
+ * import { cartHdrLookup, getCartLines } from "@/lib/actions/commerce";
+ * import { getCookie, setCookie } from "cookies-next/client";
+ * import { v4 as uuidv4 } from "uuid";
+ *
+ * function CartInitializer() {
+ *   const { data: session, status } = useSession();
+ *
+ *   useCartInitialization(
+ *     {
+ *       status,
+ *       userId: session?.user?.id,
+ *       cartHdrUid: session?.user?.cartHdrUid,
+ *     },
+ *     {
+ *       cartHdrLookup,
+ *       getCartLines,
+ *       getCartToken: () => getCookie("cartToken") as string | null,
+ *       saveCartToken: (token) => setCookie("cartToken", token, { maxAge: 604800, path: "/" }),
+ *       generateCartToken: uuidv4,
+ *     },
+ *   );
+ *
+ *   return null;
+ * }
+ * ```
+ */
+declare function useCartInitialization(session: CartSessionInfo, callbacks: CartInitCallbacks): {
+    cartHdrUid: string | number | undefined;
+    isInitializing: boolean;
+    retryCount: number;
+};
+
+interface CartPriceData {
+    unitPrice: number;
+    priceData: Record<string, unknown> | null;
+}
+interface CartPricingResult {
+    /** Map of itemId -> price data (with quantity-specific pricing) */
+    prices: Record<string, CartPriceData>;
+    /** Get unit price for an item (returns 0 if not found) */
+    getUnitPrice: (itemId: string) => number;
+    /** Get total price for an item (unitPrice * quantity) */
+    getItemTotal: (itemId: string, quantity: number) => number;
+    /** Cart subtotal (sum of all item totals) */
+    subtotal: number;
+    /** True if any price is still loading */
+    isLoading: boolean;
+    /** True if all prices loaded successfully */
+    isSuccess: boolean;
+    /** True if any price failed to load */
+    isError: boolean;
+}
+interface UseCartPricingOptions {
+    customerId?: string | number;
+}
+/**
+ * Centralized hook for cart/checkout pricing.
+ *
+ * Fetches prices for ALL cart items with their actual quantities
+ * to support quantity-based price breaks. React Query dedupes
+ * identical calls across components.
+ */
+declare function useCartPricing(options?: UseCartPricingOptions): CartPricingResult;
+/**
+ * Get cart pricing query options for prefetching or parent components.
+ */
+declare function getCartPricingQueryOptions(api: ReturnType<typeof useAugurApi>, cartLines: Array<{
+    itemId: string;
+    quantity: number;
+}>, customerId: string | number | undefined): {
+    enabled: boolean;
+    refetchOnReconnect: true;
+    refetchOnWindowFocus: false;
+    meta: {
+        readonly persist: true;
+    };
+    staleTime: number;
+    gcTime: number;
+    queryKey: readonly ["price", string, string | number | undefined, number];
+    queryFn: () => Promise<_simpleapps_com_augur_utils.TPriceData>;
+}[];
+
+interface UsePaginationPrefetchOptions {
+    /** Query key for the paginated data */
+    queryKey: QueryKey;
+    /** Function to fetch a page of data */
+    queryFn: (offset: number) => Promise<unknown>;
+    /** Number of items per page */
+    pageSize: number;
+    /** Stale time in ms (defaults to 10 minutes) */
+    staleTime?: number;
+    /** GC time in ms (defaults to 30 minutes) */
+    gcTime?: number;
+    enabled?: boolean;
+}
+/**
+ * Prefetch adjacent pages on hover for instant pagination.
+ * Accepts a generic queryFn so it works with any paginated resource.
+ */
+declare const usePaginationPrefetch: ({ queryKey, queryFn, pageSize, staleTime, gcTime, enabled, }: UsePaginationPrefetchOptions) => {
+    prefetchPage: (page: number) => Promise<void>;
+    handlePaginationHover: (page: number) => () => void;
+};
+
+interface CategoryItemsInfiniteResponse {
+    data: TProductItem[];
+    total: number;
+    nextCursor?: number;
+}
+interface UseCategoryItemsInfiniteOptions {
+    enabled?: boolean;
+}
+declare const getCategoryItemsInfiniteKey: (itemCategoryUid: number, itemsFilters: TItemsFilters) => readonly ["categoryItemsInfinite", number, string];
+/**
+ * Infinite scroll for category product listings.
+ * Fetches pages of products via the augur-api SDK.
+ */
+declare function useCategoryItemsInfinite(itemCategoryUid: number, itemsFilters: TItemsFilters, options?: UseCategoryItemsInfiniteOptions): _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<CategoryItemsInfiniteResponse, unknown>, Error>;
+
+interface ItemSearchInfiniteResponse {
+    data: TProductItem[];
+    total: number;
+    nextCursor?: number;
+}
+interface UseItemSearchInfiniteOptions {
+    enabled?: boolean;
+}
+declare const getItemSearchInfiniteKey: (itemsFilters: TItemsFilters, itemCategoryUid?: number | string) => readonly ["itemSearchInfinite", string, string | number | undefined];
+/**
+ * Infinite scroll for search results.
+ * Fetches pages of products via the augur-api SDK OpenSearch endpoint.
+ */
+declare function useItemSearchInfinite(itemsFilters: TItemsFilters, itemCategoryUid?: number | string, options?: UseItemSearchInfiniteOptions): _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<ItemSearchInfiniteResponse, unknown>, Error>;
+
+export { type AugurApiClient, AugurHooksProvider, CATEGORY_CACHE_OPTIONS, type CartActionCallbacks, type CartInitCallbacks, type CartPriceData, type CartPricingResult, type CartSessionInfo, type GetItemCategoryApiOptions, INV_MAST_CACHE_OPTIONS, INV_MAST_DOC_CACHE_OPTIONS, PRICE_CACHE_OPTIONS, type PageData, type SearchSuggestion, type SearchSuggestionsResponse, getCartPricingQueryOptions, getCategoryItemsInfiniteKey, getInvMastDocKey, getInvMastDocOptions, getInvMastKey, getInvMastOptions, getInvMastStockKey, getInvMastStockOptions, getItemAttributesKey, getItemAttributesOptions, getItemCategoryKey, getItemCategoryOptions, getItemDetailsKey, getItemDetailsOptions, getItemPriceKey, getItemPriceOptions, getItemSearchInfiniteKey, getProductCategoryKey, getProductCategoryOptions, getProductSearchKey, getProductSearchOptions, getSearchSuggestionsKey, getSearchSuggestionsOptions, useAugurApi, useCartActions, useCartHdrUid, useCartInitialization, useCartItemCount, useCartLines, useCartPricing, useCartStore, useCategoryItemsInfinite, useDebounce, useFormatPrice, useInvMast, useInvMastDoc, useInvMastStock, useItemAttributes, useItemCategory, useItemDetails, useItemFiltersStore, useItemPrice, useItemSearchInfinite, usePaginationPrefetch, useProductCategory, useProductSearch, useSearchSuggestions, useSetCartHdrUid, useSetCartLines };