@tagadapay/plugin-sdk 2.4.38 → 2.5.0

package/dist/index.d.ts

@@ -14,3 +14,4 @@ export type { Currency, Customer, Environment, EnvironmentConfig, Locale, Order,
 export { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits, } from './react/utils/money';
 export * from './data/iso3166';
 export * from './data/languages';
+export * from './v2';

package/dist/index.js

@@ -15,3 +15,5 @@ export { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMon
 // Export data utilities
 export * from './data/iso3166';
 export * from './data/languages';
+// V2 exports - new clean architecture
+export * from './v2';

package/dist/react/hooks/useCheckout.js

@@ -1,40 +1,11 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useCurrency } from '../hooks/useCurrency';
-import { useTagadaContextSafe } from '../providers/TagadaProvider';
+import { useTagadaContext } from '../providers/TagadaProvider';
 import { collectTrackingData } from '../utils/trackingUtils';
 import { usePluginConfig } from './usePluginConfig';
 export function useCheckout(options = {}) {
-    const context = useTagadaContextSafe();
+    const { apiService, updateCheckoutDebugData, refreshCoordinator, currency, isSessionInitialized } = useTagadaContext();
     const { storeId } = usePluginConfig();
-    // If context is not ready yet, return loading state
-    if (!context) {
-        return {
-            checkout: null,
-            error: null,
-            isLoading: true,
-            isInitialized: false,
-            initialized: false,
-            init: async () => ({ checkoutUrl: '', checkoutSession: {}, checkoutToken: '' }),
-            getCheckout: async () => ({}),
-            refresh: async () => { },
-            updateAddress: async () => ({ success: false, shippingCountryChanged: false, billingCountryChanged: false }),
-            setCheckoutInfo: async () => ({ success: false }),
-            applyPromotionCode: async () => ({ success: false }),
-            removePromotion: async () => ({ success: false }),
-            getAppliedPromotions: async () => [],
-            updateLineItems: async () => ({ success: false }),
-            addLineItems: async () => ({ success: false }),
-            removeLineItems: async () => ({ success: false }),
-            setItemQuantity: async () => ({ success: false }),
-            toggleOrderBump: async () => ({ success: false }),
-            updateCustomer: async () => ({ success: false }),
-            updateCustomerAndSessionInfo: async () => ({ success: false }),
-            previewOrderSummary: async () => ({ savings: 0, savingsPct: 0, currency: 'USD' }),
-            previewCheckoutSession: async () => ({ success: false, preview: {} }),
-            clear: () => { },
-        };
-    }
-    const { apiService, updateCheckoutDebugData, refreshCoordinator, currency, isSessionInitialized } = context;
     const { code: currentCurrency } = useCurrency();
     const [checkout, setCheckout] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
@@ -502,11 +473,25 @@ export function useCheckout(options = {}) {
     }, []);
     // Auto-load existing checkout session from provided token
     useEffect(() => {
+        console.log('🔧 useCheckout: Auto-load effect triggered', {
+            autoLoadFromToken,
+            hasAutoLoaded: hasAutoLoadedRef.current,
+            isInitialized,
+            providedToken: providedToken ? providedToken.substring(0, 8) + '...' : null,
+            isLoading,
+            isSessionInitialized
+        });
         if (!autoLoadFromToken || hasAutoLoadedRef.current || isInitialized || !providedToken) {
+            console.log('🔧 useCheckout: Auto-load skipped', {
+                reason: !autoLoadFromToken ? 'autoLoadFromToken false' :
+                    hasAutoLoadedRef.current ? 'already loaded' :
+                        isInitialized ? 'already initialized' :
+                            !providedToken ? 'no token' : 'unknown'
+            });
             return;
         }
         if (!isLoading) {
-            console.debug('[Checkout] Auto-loading from provided token:', {
+            console.log('🔧 useCheckout: Auto-loading from provided token:', {
                 tokenPreview: providedToken.substring(0, 8) + '...',
             });
             hasAutoLoadedRef.current = true;
@@ -516,7 +501,10 @@ export function useCheckout(options = {}) {
                 hasAutoLoadedRef.current = false; // Reset to allow retry
             });
         }
-    }, [autoLoadFromToken, providedToken, isInitialized, isLoading, getCheckout]);
+        else {
+            console.log('🔧 useCheckout: Auto-load skipped - still loading');
+        }
+    }, [autoLoadFromToken, providedToken, isInitialized, isLoading, getCheckout, isSessionInitialized]);
     return {
         checkout,
         isLoading,

package/dist/react/hooks/useCheckoutSession.d.ts

@@ -0,0 +1,19 @@
+import { CheckoutData } from './useCheckout';
+export interface UseCheckoutSessionOptions {
+    checkoutToken: string | null;
+    autoRefresh?: boolean;
+    refreshInterval?: number;
+}
+export interface UseCheckoutSessionResult {
+    checkout: CheckoutData | null;
+    isLoading: boolean;
+    error: Error | null;
+    isInitialized: boolean;
+    refresh: () => Promise<void>;
+    getCheckout: (token: string) => Promise<CheckoutData>;
+}
+/**
+ * Fetches and manages checkout session data for a specific token
+ * This hook is composable and can be used multiple times with different tokens
+ */
+export declare function useCheckoutSession(options: UseCheckoutSessionOptions): UseCheckoutSessionResult;

package/dist/react/hooks/useCheckoutSession.js

@@ -0,0 +1,108 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+/**
+ * Fetches and manages checkout session data for a specific token
+ * This hook is composable and can be used multiple times with different tokens
+ */
+export function useCheckoutSession(options) {
+    const { apiService, isSessionInitialized } = useTagadaContext();
+    const { checkoutToken, autoRefresh = false, refreshInterval = 30000 } = options;
+    const [checkout, setCheckout] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const refreshIntervalRef = useRef(null);
+    const isSessionInitializedRef = useRef(isSessionInitialized);
+    // Keep ref in sync with state
+    useEffect(() => {
+        isSessionInitializedRef.current = isSessionInitialized;
+    }, [isSessionInitialized]);
+    const getCheckout = useCallback(async (token) => {
+        console.log('🔧 useCheckoutSession: Fetching checkout data', {
+            tokenPreview: token.substring(0, 8) + '...'
+        });
+        // Wait for session initialization if needed
+        if (!isSessionInitializedRef.current) {
+            console.log('🔧 useCheckoutSession: Waiting for session initialization...');
+            await new Promise((resolve) => {
+                const checkSession = () => {
+                    if (isSessionInitializedRef.current) {
+                        resolve();
+                    }
+                    else {
+                        setTimeout(checkSession, 100);
+                    }
+                };
+                checkSession();
+            });
+        }
+        const response = await apiService.fetch(`/api/v1/checkout-sessions/${token}`, {
+            method: 'GET',
+        });
+        console.log('🔧 useCheckoutSession: Checkout data fetched', {
+            sessionId: response.checkoutSession?.id,
+            itemsCount: response.summary?.items?.length || 0,
+            totalAmount: response.summary?.totalAmount
+        });
+        return response;
+    }, [apiService]);
+    const refresh = useCallback(async () => {
+        if (!checkoutToken) {
+            console.log('🔧 useCheckoutSession: No token available for refresh');
+            return;
+        }
+        try {
+            setIsLoading(true);
+            setError(null);
+            const data = await getCheckout(checkoutToken);
+            setCheckout(data);
+            setIsInitialized(true);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to refresh checkout');
+            setError(error);
+            console.error('🔧 useCheckoutSession: Refresh failed:', error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [checkoutToken, getCheckout]);
+    // Auto-load when token becomes available
+    useEffect(() => {
+        if (!checkoutToken || isInitialized) {
+            return;
+        }
+        console.log('🔧 useCheckoutSession: Token available, loading checkout data', {
+            tokenPreview: checkoutToken.substring(0, 8) + '...'
+        });
+        refresh();
+    }, [checkoutToken, refresh, isInitialized]);
+    // Auto-refresh setup
+    useEffect(() => {
+        if (!autoRefresh || !checkout?.checkoutSession?.id) {
+            return;
+        }
+        console.log('🔧 useCheckoutSession: Setting up auto-refresh', {
+            interval: refreshInterval,
+            sessionId: checkout.checkoutSession.id
+        });
+        refreshIntervalRef.current = setInterval(() => {
+            console.log('🔧 useCheckoutSession: Auto-refreshing checkout data');
+            refresh();
+        }, refreshInterval);
+        return () => {
+            if (refreshIntervalRef.current) {
+                clearInterval(refreshIntervalRef.current);
+                refreshIntervalRef.current = null;
+            }
+        };
+    }, [autoRefresh, refreshInterval, checkout?.checkoutSession?.id, refresh]);
+    return {
+        checkout,
+        isLoading,
+        error,
+        isInitialized,
+        refresh,
+        getCheckout,
+    };
+}

package/dist/react/hooks/useCheckoutToken.d.ts

@@ -0,0 +1,17 @@
+export interface UseCheckoutTokenOptions {
+    checkoutToken?: string;
+    autoLoadFromToken?: boolean;
+}
+export interface UseCheckoutTokenResult {
+    checkoutToken: string | null;
+    isLoading: boolean;
+    error: Error | null;
+    isInitialized: boolean;
+    setToken: (token: string | null) => void;
+    clearToken: () => void;
+}
+/**
+ * Manages checkout token state and auto-loading behavior
+ * This hook handles token management without fetching checkout data
+ */
+export declare function useCheckoutToken(options?: UseCheckoutTokenOptions): UseCheckoutTokenResult;

package/dist/react/hooks/useCheckoutToken.js

@@ -0,0 +1,80 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+/**
+ * Manages checkout token state and auto-loading behavior
+ * This hook handles token management without fetching checkout data
+ */
+export function useCheckoutToken(options = {}) {
+    const { isSessionInitialized } = useTagadaContext();
+    const { checkoutToken: providedToken, autoLoadFromToken = true } = options;
+    const [checkoutToken, setCheckoutToken] = useState(providedToken || null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const hasAutoLoadedRef = useRef(false);
+    const isSessionInitializedRef = useRef(isSessionInitialized);
+    // Keep ref in sync with state
+    useEffect(() => {
+        isSessionInitializedRef.current = isSessionInitialized;
+    }, [isSessionInitialized]);
+    // Update token when provided token changes
+    useEffect(() => {
+        if (providedToken && providedToken !== checkoutToken) {
+            console.log('🔧 useCheckoutToken: Token updated from props', {
+                oldToken: checkoutToken ? checkoutToken.substring(0, 8) + '...' : null,
+                newToken: providedToken.substring(0, 8) + '...'
+            });
+            setCheckoutToken(providedToken);
+            setIsInitialized(false);
+            hasAutoLoadedRef.current = false;
+        }
+    }, [providedToken, checkoutToken]);
+    // Auto-load token from URL if no token provided
+    useEffect(() => {
+        if (!providedToken && autoLoadFromToken && !checkoutToken && !hasAutoLoadedRef.current) {
+            const urlParams = new URLSearchParams(window.location.search);
+            const urlToken = urlParams.get('checkoutToken') || urlParams.get('token');
+            if (urlToken) {
+                console.log('🔧 useCheckoutToken: Auto-loading token from URL', {
+                    tokenPreview: urlToken.substring(0, 8) + '...'
+                });
+                setCheckoutToken(urlToken);
+                hasAutoLoadedRef.current = true;
+            }
+        }
+    }, [providedToken, autoLoadFromToken, checkoutToken]);
+    // Wait for session initialization
+    useEffect(() => {
+        if (!isSessionInitialized || !checkoutToken || isInitialized) {
+            return;
+        }
+        console.log('🔧 useCheckoutToken: Session initialized, token ready', {
+            tokenPreview: checkoutToken.substring(0, 8) + '...',
+            isSessionInitialized
+        });
+        setIsInitialized(true);
+    }, [isSessionInitialized, checkoutToken, isInitialized]);
+    const setToken = useCallback((token) => {
+        console.log('🔧 useCheckoutToken: Setting token', {
+            tokenPreview: token ? token.substring(0, 8) + '...' : null
+        });
+        setCheckoutToken(token);
+        setIsInitialized(!!token);
+        setError(null);
+    }, []);
+    const clearToken = useCallback(() => {
+        console.log('🔧 useCheckoutToken: Clearing token');
+        setCheckoutToken(null);
+        setIsInitialized(false);
+        setError(null);
+        hasAutoLoadedRef.current = false;
+    }, []);
+    return {
+        checkoutToken,
+        isLoading,
+        error,
+        isInitialized,
+        setToken,
+        clearToken,
+    };
+}

package/dist/react/hooks/useOrderBump.js

@@ -1,44 +1,102 @@
 import { useState, useCallback, useEffect } from 'react';
-import { useTagadaContextSafe } from '../providers/TagadaProvider';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { useCheckout } from './useCheckout';
 export function useOrderBump(options) {
-    const context = useTagadaContextSafe();
-    // If context is not ready yet, return loading state
-    if (!context) {
-        return {
-            isSelected: false,
-            preview: null,
-            savings: null,
-            isLoading: false,
-            isToggling: false,
-            error: null,
-            toggle: async () => ({ success: false }),
-            refreshPreview: async () => { },
-        };
-    }
-    const { apiService, refreshCoordinator } = context;
-    const { checkoutSessionId, offerId, orderBumpType = 'vip', autoPreview = true } = options;
-    const [isSelected, setIsSelected] = useState(false);
+    const { apiService, refreshCoordinator } = useTagadaContext();
+    const { checkout } = useCheckout();
+    const { checkoutSessionId, offerId, orderBumpType = 'primary', autoPreview = true } = options;
+    // Debug logging for hook initialization
+    console.log('🔧 useOrderBump initialized:', {
+        offerId,
+        orderBumpType,
+        checkoutSessionId,
+        hasCheckout: !!checkout,
+        hasSession: !!checkout?.checkoutSession,
+        sessionLineItems: checkout?.checkoutSession?.sessionLineItems?.length || 0
+    });
+    // Initialize isSelected based on current checkout session if available
+    const getInitialSelection = () => {
+        if (!checkout?.checkoutSession?.sessionLineItems) {
+            console.log('🔧 getInitialSelection: No session line items available');
+            return false;
+        }
+        if (orderBumpType === 'vip') {
+            console.log('🔧 getInitialSelection: VIP order bump (placeholder)');
+            return false; // Placeholder for VIP logic
+        }
+        const isSelected = checkout.checkoutSession.sessionLineItems.some((item) => {
+            const matches = item.isOrderBump === true &&
+                (item.orderBumpOfferId === offerId || item.productId === offerId);
+            console.log('🔧 Checking line item:', {
+                itemId: item.id,
+                productId: item.productId,
+                isOrderBump: item.isOrderBump,
+                offerId,
+                matches
+            });
+            if (matches) {
+                console.log('🔧 getInitialSelection: Found matching order bump item:', item);
+            }
+            return matches;
+        });
+        console.log('🔧 getInitialSelection result:', isSelected);
+        return isSelected;
+    };
+    const [isSelected, setIsSelected] = useState(getInitialSelection);
     const [preview, setPreview] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     const [isToggling, setIsToggling] = useState(false);
     const [error, setError] = useState(null);
+    // Check if order bump is selected from checkout session line items
+    const checkOrderBumpSelection = useCallback(() => {
+        if (!checkout?.checkoutSession?.sessionLineItems)
+            return false;
+        // For VIP order bumps, we need to check if any VIP offers are selected
+        if (orderBumpType === 'vip') {
+            // VIP logic would go here - checking for VIP offers in line items
+            return false; // Placeholder for now
+        }
+        // For primary/secondary order bumps, check if the offer's product is in line items
+        // The offerId should match the order bump offer ID, not the product ID
+        return checkout.checkoutSession.sessionLineItems.some((item) => {
+            // Check if this is an order bump item and matches our offer
+            return item.isOrderBump === true &&
+                (item.orderBumpOfferId === offerId || item.productId === offerId);
+        });
+    }, [checkout?.checkoutSession?.sessionLineItems, offerId, orderBumpType]);
     const refreshPreview = useCallback(async () => {
         if (!checkoutSessionId)
             return;
         setIsLoading(true);
         setError(null);
         try {
-            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/vip-preview`, {
-                method: 'POST',
-                body: {
-                    orderBumpOfferIds: [offerId],
+            // Only use VIP preview for VIP order bumps
+            if (orderBumpType === 'vip') {
+                const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/vip-preview`, {
+                    method: 'POST',
+                    body: {
+                        orderBumpOfferIds: [offerId],
+                        orderBumpType,
+                    },
+                });
+                setPreview(response);
+                // Update isSelected based on preview data for VIP
+                const offerSelected = response.selectedOffers?.some((offer) => offer.isSelected);
+                setIsSelected(offerSelected ?? false);
+            }
+            else {
+                // For primary/secondary order bumps, check checkout session directly
+                const isSelectedFromSession = checkOrderBumpSelection();
+                setIsSelected(isSelectedFromSession);
+                setPreview(null); // No preview for non-VIP order bumps
+                // Debug logging to help troubleshoot
+                console.log('Order bump selection check:', {
+                    offerId,
                     orderBumpType,
-                },
-            });
-            setPreview(response);
-            // Update isSelected based on preview data
-            const offerSelected = response.selectedOffers?.some((offer) => offer.isSelected);
-            setIsSelected(offerSelected ?? false);
+                    sessionLineItems: checkout?.checkoutSession?.sessionLineItems,
+                    isSelectedFromSession
+                });
+            }
         }
         catch (err) {
             const error = err instanceof Error ? err : new Error('Failed to fetch preview');
@@ -48,7 +106,7 @@ export function useOrderBump(options) {
         finally {
             setIsLoading(false);
         }
-    }, [checkoutSessionId, offerId, orderBumpType, apiService]);
+    }, [checkoutSessionId, offerId, orderBumpType, apiService, checkOrderBumpSelection]);
     const toggle = useCallback(async (selected) => {
         if (!checkoutSessionId) {
             throw new Error('No checkout session available');
@@ -90,6 +148,13 @@ export function useOrderBump(options) {
             setIsToggling(false);
         }
     }, [checkoutSessionId, offerId, isSelected, apiService, refreshPreview, refreshCoordinator]);
+    // Initialize isSelected when checkout session first loads
+    useEffect(() => {
+        if (checkout?.checkoutSession?.sessionLineItems) {
+            const isSelectedFromSession = checkOrderBumpSelection();
+            setIsSelected(isSelectedFromSession);
+        }
+    }, [checkOrderBumpSelection, checkout?.checkoutSession?.sessionLineItems]);
     // Auto-fetch preview on mount and when dependencies change
     useEffect(() => {
         if (autoPreview && checkoutSessionId) {

package/dist/react/hooks/useOrderBumpV2.d.ts

@@ -0,0 +1,17 @@
+export interface UseOrderBumpV2Options {
+    offerId: string;
+    productId?: string;
+    orderBumpType?: 'primary' | 'secondary';
+}
+export interface UseOrderBumpV2Result {
+    isSelected: boolean;
+    isLoading: boolean;
+    isToggling: boolean;
+    error: Error | null;
+    isReady: boolean;
+    toggle: (selected?: boolean) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+}
+export declare function useOrderBumpV2(options: UseOrderBumpV2Options): UseOrderBumpV2Result;

package/dist/react/hooks/useOrderBumpV2.js

@@ -0,0 +1,95 @@
+import { useState, useCallback, useEffect } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { useCheckout } from './useCheckout';
+export function useOrderBumpV2(options) {
+    const { apiService, refreshCoordinator } = useTagadaContext();
+    const { checkout } = useCheckout();
+    const { offerId, productId, orderBumpType = 'primary' } = options;
+    // Check if order bump is selected from checkout session line items
+    const checkOrderBumpSelection = useCallback(() => {
+        console.log('🔧 useOrderBumpV2: Full checkout object:', checkout);
+        console.log('🔧 useOrderBumpV2: Checkout session:', checkout?.checkoutSession);
+        console.log('🔧 useOrderBumpV2: Session line items:', checkout?.checkoutSession?.sessionLineItems);
+        console.log('🔧 useOrderBumpV2: Checkout is null?', checkout === null);
+        console.log('🔧 useOrderBumpV2: Checkout session is null?', checkout?.checkoutSession === null);
+        console.log('🔧 useOrderBumpV2: Session line items is null?', checkout?.checkoutSession?.sessionLineItems === null);
+        if (!checkout?.checkoutSession?.sessionLineItems) {
+            console.log('🔧 useOrderBumpV2: No session line items available');
+            return false;
+        }
+        const targetProductId = productId || offerId; // Fallback to offerId if productId not provided
+        console.log('🔧 useOrderBumpV2: Looking for product ID:', targetProductId);
+        const isSelected = checkout.checkoutSession.sessionLineItems.some((item) => {
+            const matches = item.isOrderBump === true && item.productId === targetProductId;
+            console.log('🔧 useOrderBumpV2: Checking item:', {
+                itemId: item.id,
+                productId: item.productId,
+                isOrderBump: item.isOrderBump,
+                targetProductId,
+                offerId,
+                matches
+            });
+            return matches;
+        });
+        console.log('🔧 useOrderBumpV2: Selection result:', isSelected);
+        return isSelected;
+    }, [checkout?.checkoutSession?.sessionLineItems, offerId, productId]);
+    // Initialize state based on current checkout session
+    const [isSelected, setIsSelected] = useState(() => checkOrderBumpSelection());
+    const [isLoading, setIsLoading] = useState(false);
+    const [isToggling, setIsToggling] = useState(false);
+    const [error, setError] = useState(null);
+    // Update isSelected when checkout session changes
+    useEffect(() => {
+        const isSelectedFromSession = checkOrderBumpSelection();
+        setIsSelected(isSelectedFromSession);
+    }, [checkOrderBumpSelection]);
+    const toggle = useCallback(async (selected) => {
+        if (!checkout?.checkoutSession?.id) {
+            console.warn('useOrderBumpV2: No checkout session available yet');
+            return { success: false, error: 'Checkout session not ready' };
+        }
+        const targetState = selected ?? !isSelected;
+        // Optimistic update
+        setIsSelected(targetState);
+        setIsToggling(true);
+        setError(null);
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/toggle-order-bump`, {
+                method: 'POST',
+                body: {
+                    orderBumpOfferId: offerId,
+                    selected: targetState,
+                },
+            });
+            if (response.success) {
+                // Notify checkout hook that order bump data changed
+                await refreshCoordinator.notifyOrderBumpChanged();
+                return { success: true };
+            }
+            else {
+                // Revert optimistic update
+                setIsSelected(!targetState);
+                return { success: false, error: response.error };
+            }
+        }
+        catch (err) {
+            // Revert optimistic update
+            setIsSelected(!targetState);
+            const error = err instanceof Error ? err : new Error('Failed to toggle order bump');
+            setError(error);
+            return { success: false, error: error.message };
+        }
+        finally {
+            setIsToggling(false);
+        }
+    }, [checkout?.checkoutSession?.id, offerId, isSelected, apiService, refreshCoordinator]);
+    return {
+        isSelected,
+        isLoading,
+        isToggling,
+        error,
+        toggle,
+        isReady: !!checkout?.checkoutSession?.id,
+    };
+}

package/dist/react/hooks/useOrderBumpV3.d.ts

@@ -0,0 +1,23 @@
+export interface UseOrderBumpV3Options {
+    checkoutToken: string | null;
+    offerId: string;
+    productId?: string;
+    orderBumpType?: 'primary' | 'secondary';
+}
+export interface UseOrderBumpV3Result {
+    isSelected: boolean;
+    isLoading: boolean;
+    isToggling: boolean;
+    error: Error | null;
+    isReady: boolean;
+    toggle: (selected?: boolean) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    checkout: any;
+}
+/**
+ * Composable order bump hook that works with a specific checkout token
+ * This allows multiple order bumps to work with different checkout sessions
+ */
+export declare function useOrderBumpV3(options: UseOrderBumpV3Options): UseOrderBumpV3Result;