@tagadapay/plugin-sdk 3.1.2 → 3.1.8

package/dist/v2/react/hooks/usePaymentPolling.d.ts

@@ -2,14 +2,14 @@ export interface Payment {
     id: string;
     status: string;
     subStatus: string;
-    requireAction: 'none' | 'redirect' | 'error';
+    requireAction: 'none' | 'redirect' | 'error' | 'radar';
     requireActionData?: {
-        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error';
+        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar';
         url?: string;
         processed: boolean;
         processorId?: string;
         metadata?: {
-            type: 'redirect';
+            type: 'redirect' | 'stripe_radar' | 'finix_radar';
             redirect?: {
                 redirectUrl: string;
                 returnUrl: string;
@@ -20,6 +20,12 @@ export interface Payment {
                 acsTransID: string;
                 messageVersion: string;
             };
+            radar?: {
+                merchantId?: string;
+                environment?: 'sandbox' | 'live';
+                orderId?: string;
+                publishableKey?: string;
+            };
         };
         redirectUrl?: string;
         resumeToken?: string;

package/dist/v2/react/hooks/usePaymentPolling.js

@@ -54,6 +54,11 @@ export function usePaymentPolling() {
         isPollingRef.current = true;
         currentPaymentIdRef.current = paymentId;
         const { onRequireAction, onSuccess, onFailure, maxAttempts = 20, pollInterval = 1500 } = options;
+        console.log('🔄 [usePaymentPolling] Starting polling...', {
+            paymentId,
+            maxAttempts,
+            pollInterval: `${pollInterval}ms`,
+        });
         const checkPaymentStatus = async () => {
             // Stop if component was unmounted or polling was stopped
             if (!isMountedRef.current || !isPollingRef.current) {
@@ -61,7 +66,14 @@ export function usePaymentPolling() {
             }
             try {
                 attemptsRef.current++;
+                console.log(`🔄 [usePaymentPolling] Polling attempt ${attemptsRef.current}/${maxAttempts} for payment ${paymentId}...`);
                 const payment = await paymentsResource.getPaymentStatus(paymentId);
+                console.log(`📊 [usePaymentPolling] Payment status:`, {
+                    id: payment.id,
+                    status: payment.status,
+                    subStatus: payment.subStatus,
+                    requireAction: payment.requireAction,
+                });
                 // Check again after async operation
                 if (!isMountedRef.current || !isPollingRef.current) {
                     return;
@@ -70,25 +82,31 @@ export function usePaymentPolling() {
                 if (!payment?.id) {
                     return;
                 }
-                // Check if payment requires action
-                if (payment.requireAction !== 'none' && payment.requireActionData) {
-                    stopPolling();
-                    if (isMountedRef.current && onRequireAction) {
-                        onRequireAction(payment, stopPolling);
-                    }
-                    return;
-                }
-                // Check for successful payment
+                // 🔒 CRITICAL: Check for successful payment FIRST
+                // Even if requireAction is set, if payment succeeded, we should call onSuccess
+                // This handles the case where payment succeeds after redirect (3DS, etc.)
                 if (payment.status === 'succeeded' ||
                     (payment.status === 'pending' && payment.subStatus === 'authorized')) {
+                    console.log('✅ [usePaymentPolling] Payment succeeded! Stopping polling.');
                     stopPolling();
                     if (isMountedRef.current && onSuccess) {
                         onSuccess(payment);
                     }
                     return;
                 }
+                // Check if payment requires action (and hasn't been processed yet)
+                // Only if payment is NOT yet succeeded
+                if (payment.requireAction !== 'none' && payment.requireActionData && !payment.requireActionData.processed) {
+                    console.log('⚠️ [usePaymentPolling] Payment requires NEW action (not yet processed) - stopping polling');
+                    stopPolling();
+                    if (isMountedRef.current && onRequireAction) {
+                        onRequireAction(payment, stopPolling);
+                    }
+                    return;
+                }
                 // Check for failed payment (non-succeeded and not pending)
                 if (payment.status !== 'succeeded' && payment.status !== 'pending') {
+                    console.error('❌ [usePaymentPolling] Payment failed - stopping polling');
                     stopPolling();
                     if (isMountedRef.current && onFailure) {
                         onFailure(payment.status || 'Payment failed');
@@ -97,11 +115,15 @@ export function usePaymentPolling() {
                 }
                 // Stop after max attempts
                 if (attemptsRef.current >= maxAttempts) {
+                    console.warn('⏱️ [usePaymentPolling] Max attempts reached - stopping polling');
                     stopPolling();
                     if (isMountedRef.current && onFailure) {
                         onFailure('Payment verification timeout');
                     }
                 }
+                else {
+                    console.log(`⏳ [usePaymentPolling] Payment still pending - will retry in ${pollInterval}ms...`);
+                }
             }
             catch (_error) {
                 // Stop polling on repeated errors to prevent infinite loops

package/dist/v2/react/hooks/usePaymentQuery.d.ts

@@ -2,8 +2,38 @@
  * Payment Hook using TanStack Query (V2)
  * Matches the old usePayment.ts implementation exactly for easy migration
  */
-import type { PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse } from '../../core/resources/payments';
+import type { Payment, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse } from '../../core/resources/payments';
 export type { Payment as PaymentType, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse, PaymentInstrumentCustomer } from '../../core/resources/payments';
+/**
+ * Metadata provided with payment callbacks
+ */
+export interface PaymentCompletionMetadata {
+    /** True if payment completed after external redirect (3DS, PayPal, etc.) */
+    isRedirectReturn: boolean;
+    /** Order associated with the payment (if available) */
+    order?: any;
+    /** Checkout session ID (if available) */
+    checkoutSessionId?: string;
+}
+/**
+ * Hook-level options for universal payment handling
+ */
+export interface UsePaymentOptions {
+    /**
+     * Called when payment completes successfully
+     * Works for BOTH immediate success AND post-redirect success (3DS, PayPal, etc.)
+     * @param payment - The completed payment
+     * @param metadata - Additional context about how payment completed
+     */
+    onPaymentCompleted?: (payment: Payment, metadata: PaymentCompletionMetadata) => void | Promise<void>;
+    /**
+     * Called when payment fails
+     * Works for BOTH immediate failure AND post-redirect failure
+     * @param error - Error message
+     * @param metadata - Additional context about the failure
+     */
+    onPaymentFailed?: (error: string, metadata: PaymentCompletionMetadata) => void | Promise<void>;
+}
 export interface PaymentHook {
     processCardPayment: (checkoutSessionId: string, cardData: CardPaymentMethod, options?: PaymentOptions) => Promise<PaymentResponse>;
     processApplePayPayment: (checkoutSessionId: string, applePayToken: ApplePayToken, options?: PaymentOptions) => Promise<PaymentResponse>;
@@ -16,4 +46,4 @@ export interface PaymentHook {
     clearError: () => void;
     currentPaymentId: string | null;
 }
-export declare function usePaymentQuery(): PaymentHook;
+export declare function usePaymentQuery(hookOptions?: UsePaymentOptions): PaymentHook;

package/dist/v2/react/hooks/usePaymentQuery.js

@@ -10,8 +10,12 @@ import { PaymentsResource } from '../../core/resources/payments';
 import { usePaymentPolling } from './usePaymentPolling';
 import { useThreeds } from './useThreeds';
 import { getGlobalApiClient } from './useApiQuery';
-export function usePaymentQuery() {
+import { useStoreConfigQuery } from './useStoreConfigQuery';
+import { getAssignedPaymentFlowId } from '../../core/funnelClient';
+export function usePaymentQuery(hookOptions) {
     const { environment } = useTagadaContext();
+    // Get store config to auto-detect 3DS setting from payment flow
+    const { storeConfig } = useStoreConfigQuery();
     // Create payments resource client
     const paymentsResource = useMemo(() => {
         try {
@@ -24,6 +28,11 @@ export function usePaymentQuery() {
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     const [currentPaymentId, setCurrentPaymentId] = useState(null);
+    // Store hook-level callbacks in ref to avoid re-renders
+    const hookOptionsRef = useRef(hookOptions);
+    useEffect(() => {
+        hookOptionsRef.current = hookOptions;
+    }, [hookOptions]);
     const { startPolling, stopPolling } = usePaymentPolling();
     const { createSession, startChallenge } = useThreeds();
     // Track challenge in progress to prevent multiple challenges
@@ -83,7 +92,7 @@ export function usePaymentQuery() {
                                 onRequireAction: (updatedPayment) => {
                                     void handlePaymentAction(updatedPayment, options);
                                 },
-                                onSuccess: (successPayment) => {
+                                onSuccess: async (successPayment) => {
                                     setIsLoading(false);
                                     const response = {
                                         paymentId: successPayment.id,
@@ -91,14 +100,27 @@ export function usePaymentQuery() {
                                         // Extract order from payment if available (for funnel path resolution)
                                         order: successPayment.order,
                                     };
+                                    // Hook-level callback (universal handler)
+                                    if (hookOptionsRef.current?.onPaymentCompleted) {
+                                        await hookOptionsRef.current.onPaymentCompleted(successPayment, {
+                                            isRedirectReturn: false,
+                                            order: response.order,
+                                        });
+                                    }
                                     // Legacy callback (backwards compatibility)
                                     options.onSuccess?.(response);
                                     // Funnel-aligned callback (recommended)
                                     options.onPaymentSuccess?.(response);
                                 },
-                                onFailure: (errorMsg) => {
+                                onFailure: async (errorMsg) => {
                                     setError(errorMsg);
                                     setIsLoading(false);
+                                    // Hook-level callback (universal handler)
+                                    if (hookOptionsRef.current?.onPaymentFailed) {
+                                        await hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                                            isRedirectReturn: false,
+                                        });
+                                    }
                                     // Legacy callback (backwards compatibility)
                                     options.onFailure?.(errorMsg);
                                     // Funnel-aligned callback (recommended)
@@ -150,6 +172,13 @@ export function usePaymentQuery() {
                         // Extract order from payment if available (for funnel path resolution)
                         order: payment.order,
                     };
+                    // Hook-level callback (universal handler)
+                    if (hookOptionsRef.current?.onPaymentCompleted) {
+                        await hookOptionsRef.current.onPaymentCompleted(payment, {
+                            isRedirectReturn: false,
+                            order: response.order,
+                        });
+                    }
                     // Legacy callback (backwards compatibility)
                     options.onSuccess?.(response);
                     // Funnel-aligned callback (recommended)
@@ -172,9 +201,251 @@ export function usePaymentQuery() {
                 });
                 break;
             }
+            case 'finix_radar': {
+                // Handle Finix fraud detection - collect device fingerprint
+                const radarConfig = actionData.metadata?.radar;
+                if (!radarConfig) {
+                    console.error('Finix radar config missing from payment action');
+                    break;
+                }
+                try {
+                    // Dynamically load Finix SDK if not already loaded
+                    if (typeof window !== 'undefined' && typeof window.Finix?.Auth !== 'function') {
+                        const existingScript = document.querySelector('script[src="https://js.finix.com/v/1/finix.js"]');
+                        if (!existingScript) {
+                            const script = document.createElement('script');
+                            script.src = 'https://js.finix.com/v/1/finix.js';
+                            script.async = true;
+                            document.head.appendChild(script);
+                            await new Promise((resolve, reject) => {
+                                script.onload = () => {
+                                    console.log('Finix SDK loaded successfully');
+                                    resolve();
+                                };
+                                script.onerror = () => reject(new Error('Failed to load Finix SDK'));
+                            });
+                        }
+                        else {
+                            // Wait for existing script to load
+                            await new Promise((resolve, reject) => {
+                                const checkFinix = () => {
+                                    if (typeof window.Finix?.Auth === 'function') {
+                                        resolve();
+                                    }
+                                    else {
+                                        setTimeout(checkFinix, 100);
+                                    }
+                                };
+                                checkFinix();
+                                setTimeout(() => reject(new Error('Timeout waiting for Finix SDK')), 10000);
+                            });
+                        }
+                    }
+                    // Get session key from Finix using callback to ensure initialization is complete
+                    const sessionKey = await new Promise((resolve, reject) => {
+                        const timeoutId = setTimeout(() => {
+                            reject(new Error('Timeout waiting for Finix Auth initialization'));
+                        }, 10000);
+                        // Initialize Finix Auth with callback
+                        const FinixAuth = window.Finix.Auth(radarConfig.environment, radarConfig.merchantId, () => {
+                            // Callback fired when Finix Auth is ready
+                            clearTimeout(timeoutId);
+                            const key = FinixAuth.getSessionKey();
+                            console.log('Finix Auth initialized, session key:', key);
+                            if (key) {
+                                resolve(key);
+                            }
+                            else {
+                                reject(new Error('No session key returned from Finix after initialization'));
+                            }
+                        });
+                        // Also try getting session key immediately in case it's already ready
+                        const immediateKey = FinixAuth.getSessionKey();
+                        if (immediateKey) {
+                            clearTimeout(timeoutId);
+                            console.log('Finix session key obtained immediately:', immediateKey);
+                            resolve(immediateKey);
+                        }
+                    });
+                    console.log('Finix fraud session key obtained:', sessionKey);
+                    // Save radar session to database
+                    await paymentsResource.saveRadarSession({
+                        orderId: radarConfig.orderId,
+                        finixRadarSessionId: sessionKey,
+                        finixRadarSessionData: {
+                            sessionKey,
+                            merchantId: radarConfig.merchantId,
+                            environment: radarConfig.environment,
+                            createdAt: new Date().toISOString(),
+                        },
+                    });
+                    console.log('Finix radar session saved to database');
+                    // Resume payment by calling completePaymentAfterAction
+                    const resumedPayment = await paymentsResource.completePaymentAfterAction(payment.id);
+                    console.log('Payment resumed after Finix radar:', resumedPayment);
+                    // Handle the resumed payment response
+                    if (resumedPayment.requireAction !== 'none' && resumedPayment.requireActionData) {
+                        // Payment requires another action (e.g., 3DS)
+                        await handlePaymentAction(resumedPayment, options);
+                    }
+                    else if (resumedPayment.status === 'succeeded') {
+                        // Payment succeeded
+                        setIsLoading(false);
+                        const response = {
+                            paymentId: resumedPayment.id,
+                            payment: resumedPayment,
+                            order: resumedPayment.order,
+                        };
+                        options.onSuccess?.(response);
+                        options.onPaymentSuccess?.(response);
+                    }
+                    else {
+                        // Start polling for final status
+                        startPolling(resumedPayment.id, {
+                            onRequireAction: (updatedPayment) => {
+                                void handlePaymentAction(updatedPayment, options);
+                            },
+                            onSuccess: (successPayment) => {
+                                setIsLoading(false);
+                                const response = {
+                                    paymentId: successPayment.id,
+                                    payment: successPayment,
+                                    order: successPayment.order,
+                                };
+                                options.onSuccess?.(response);
+                                options.onPaymentSuccess?.(response);
+                            },
+                            onFailure: (errorMsg) => {
+                                setError(errorMsg);
+                                setIsLoading(false);
+                                options.onFailure?.(errorMsg);
+                                options.onPaymentFailed?.({
+                                    code: 'PAYMENT_FAILED',
+                                    message: errorMsg,
+                                    payment,
+                                });
+                            },
+                        });
+                    }
+                }
+                catch (radarError) {
+                    const errorMsg = radarError instanceof Error ? radarError.message : 'Finix fraud detection failed';
+                    console.error('Finix radar error:', radarError);
+                    setError(errorMsg);
+                    setIsLoading(false);
+                    options.onFailure?.(errorMsg);
+                    options.onPaymentFailed?.({
+                        code: 'FINIX_RADAR_FAILED',
+                        message: errorMsg,
+                        payment,
+                    });
+                }
+                break;
+            }
         }
         options.onRequireAction?.(payment);
     }, [paymentsResource, startPolling, startChallenge]);
+    // Auto-detect payment action from URL parameters (after redirect from Stripe, PayPal, etc.)
+    useEffect(() => {
+        if (typeof window === 'undefined')
+            return;
+        const urlParams = new URLSearchParams(window.location.search);
+        const paymentAction = urlParams.get('paymentAction');
+        const paymentActionStatus = urlParams.get('paymentActionStatus');
+        const paymentIdFromUrl = urlParams.get('paymentId');
+        const paymentMode = urlParams.get('mode');
+        console.log('🔍 [usePayment] Checking for payment redirect return...', {
+            paymentAction,
+            paymentActionStatus,
+            paymentId: paymentIdFromUrl,
+            mode: paymentMode,
+            url: window.location.href,
+        });
+        // Skip if in retrieve mode (handled by separate hook)
+        if (paymentMode === 'retrieve') {
+            console.log('⏭️ [usePayment] Skipping - retrieve mode detected');
+            return;
+        }
+        // Check if returning from a payment redirect
+        if (paymentAction === 'requireAction' && paymentActionStatus === 'completed' && paymentIdFromUrl) {
+            console.log('✅ [usePayment] Payment redirect return detected! Starting auto-polling...', {
+                paymentId: paymentIdFromUrl,
+            });
+            setIsLoading(true);
+            setCurrentPaymentId(paymentIdFromUrl);
+            // Start polling for the payment status
+            startPolling(paymentIdFromUrl, {
+                onRequireAction: (payment) => {
+                    console.log('⚠️ [usePayment] Payment requires new action', payment);
+                    void handlePaymentAction(payment, {});
+                },
+                onSuccess: async (payment) => {
+                    console.log('✅ [usePayment] Payment succeeded after redirect!', {
+                        paymentId: payment.id,
+                        status: payment.status,
+                        hasOrder: !!payment.order,
+                    });
+                    setIsLoading(false);
+                    // Clean up ONLY payment-related query parameters (preserve funnel/checkout params)
+                    const urlParams = new URLSearchParams(window.location.search);
+                    const paymentParams = ['paymentAction', 'paymentActionStatus', 'paymentId', 'payment_intent', 'payment_intent_client_secret', 'source_type', 'redirect_status'];
+                    paymentParams.forEach(param => urlParams.delete(param));
+                    const newUrl = urlParams.toString()
+                        ? `${window.location.pathname}?${urlParams.toString()}`
+                        : window.location.pathname;
+                    window.history.replaceState({}, document.title, newUrl);
+                    console.log('🧹 [usePayment] Payment URL parameters cleaned up (preserved funnel/checkout params)');
+                    // Call hook-level onPaymentCompleted callback (if provided)
+                    if (hookOptionsRef.current?.onPaymentCompleted) {
+                        console.log('📞 [usePayment] Calling onPaymentCompleted callback...', {
+                            isRedirectReturn: true,
+                        });
+                        try {
+                            await hookOptionsRef.current.onPaymentCompleted(payment, {
+                                isRedirectReturn: true,
+                                order: payment.order,
+                            });
+                            console.log('✅ [usePayment] onPaymentCompleted callback completed successfully');
+                        }
+                        catch (error) {
+                            console.error('❌ [usePayment] Error in onPaymentCompleted callback:', error);
+                        }
+                    }
+                    else {
+                        console.warn('⚠️ [usePayment] No onPaymentCompleted callback provided');
+                    }
+                },
+                onFailure: async (errorMsg) => {
+                    console.error('❌ [usePayment] Payment failed after redirect:', errorMsg);
+                    setError(errorMsg);
+                    setIsLoading(false);
+                    // Clean up ONLY payment-related query parameters (preserve funnel/checkout params)
+                    const urlParams = new URLSearchParams(window.location.search);
+                    const paymentParams = ['paymentAction', 'paymentActionStatus', 'paymentId', 'payment_intent', 'payment_intent_client_secret', 'source_type', 'redirect_status'];
+                    paymentParams.forEach(param => urlParams.delete(param));
+                    const newUrl = urlParams.toString()
+                        ? `${window.location.pathname}?${urlParams.toString()}`
+                        : window.location.pathname;
+                    window.history.replaceState({}, document.title, newUrl);
+                    // Call hook-level onPaymentFailed callback (if provided)
+                    if (hookOptionsRef.current?.onPaymentFailed) {
+                        console.log('📞 [usePayment] Calling onPaymentFailed callback...');
+                        try {
+                            await hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                                isRedirectReturn: true,
+                            });
+                        }
+                        catch (error) {
+                            console.error('❌ [usePayment] Error in onPaymentFailed callback:', error);
+                        }
+                    }
+                },
+            });
+        }
+        else {
+            console.log('⏭️ [usePayment] No payment redirect detected - normal page load');
+        }
+    }, [startPolling, handlePaymentAction, setIsLoading, setError, setCurrentPaymentId]);
     // Create card payment instrument - matches old implementation
     const createCardPaymentInstrument = useCallback((cardData) => {
         return paymentsResource.createCardPaymentInstrument(basisTheory, cardData);
@@ -186,9 +457,12 @@ export function usePaymentQuery() {
     // Process payment directly with checkout session - matches old implementation
     const processPaymentDirect = useCallback(async (checkoutSessionId, paymentInstrumentId, threedsSessionId, options = {}) => {
         try {
+            // Get paymentFlowId: priority is options > stepConfig > undefined (uses store default)
+            const paymentFlowId = options.paymentFlowId || getAssignedPaymentFlowId();
             const response = await paymentsResource.processPaymentDirect(checkoutSessionId, paymentInstrumentId, threedsSessionId, {
                 initiatedBy: options.initiatedBy,
                 source: options.source,
+                paymentFlowId,
             });
             setCurrentPaymentId(response.payment?.id);
             if (response.payment.requireAction !== 'none') {
@@ -201,6 +475,14 @@ export function usePaymentQuery() {
                     ...response,
                     order: response.order || response.payment.order,
                 };
+                // Hook-level callback (universal handler)
+                if (hookOptionsRef.current?.onPaymentCompleted) {
+                    await hookOptionsRef.current.onPaymentCompleted(response.payment, {
+                        isRedirectReturn: false,
+                        order: successResponse.order,
+                        checkoutSessionId,
+                    });
+                }
                 // Legacy callback (backwards compatibility)
                 options.onSuccess?.(successResponse);
                 // Funnel-aligned callback (recommended)
@@ -212,7 +494,7 @@ export function usePaymentQuery() {
                     onRequireAction: (payment) => {
                         void handlePaymentAction(payment, options);
                     },
-                    onSuccess: (payment) => {
+                    onSuccess: async (payment) => {
                         setIsLoading(false);
                         const successResponse = {
                             paymentId: payment.id,
@@ -220,14 +502,28 @@ export function usePaymentQuery() {
                             // Extract order from payment if available (for funnel path resolution)
                             order: payment.order,
                         };
+                        // Hook-level callback (universal handler)
+                        if (hookOptionsRef.current?.onPaymentCompleted) {
+                            await hookOptionsRef.current.onPaymentCompleted(payment, {
+                                isRedirectReturn: false,
+                                order: successResponse.order,
+                                checkoutSessionId,
+                            });
+                        }
                         // Legacy callback (backwards compatibility)
                         options.onSuccess?.(successResponse);
                         // Funnel-aligned callback (recommended)
                         options.onPaymentSuccess?.(successResponse);
                     },
-                    onFailure: (errorMsg) => {
+                    onFailure: async (errorMsg) => {
                         setError(errorMsg);
                         setIsLoading(false);
+                        // Hook-level callback (universal handler)
+                        if (hookOptionsRef.current?.onPaymentFailed) {
+                            await hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                                isRedirectReturn: false,
+                            });
+                        }
                         // Legacy callback (backwards compatibility)
                         options.onFailure?.(errorMsg);
                         // Funnel-aligned callback (recommended)
@@ -262,9 +558,10 @@ export function usePaymentQuery() {
         try {
             // 1. Create payment instrument
             const paymentInstrument = await createCardPaymentInstrument(cardData);
-            // 2. Create 3DS session if enabled
+            // 2. Create 3DS session if enabled (use payment flow setting if not explicitly provided)
+            const shouldCreateThreedsSession = storeConfig?.computed?.threedsEnabled;
             let threedsSessionId;
-            if (options.enableThreeds !== false) {
+            if (shouldCreateThreedsSession) {
                 try {
                     const threedsSession = await createSession(paymentInstrument, {
                         provider: options.threedsProvider || 'basis_theory',

package/dist/v2/react/hooks/usePaymentRetrieve.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Payment Retrieve Hook using TanStack Query (V2)
+ * Handles payment status retrieval after external redirects
+ * This is useful for processors that require server-side status checks (e.g., some 3DS flows)
+ */
+export interface RetrieveResult {
+    retrieveResult?: {
+        status?: string;
+        message?: string;
+        success?: boolean;
+    };
+    paymentId: string;
+    transactionCreated?: boolean;
+    status?: string;
+    transactionId?: string;
+    message?: string;
+    success?: boolean;
+    error?: any;
+}
+export interface PaymentRetrieveHook {
+    startRetrievePolling: (paymentId: string) => Promise<void>;
+    isLoading: boolean;
+    error: string | null;
+    isPolling: boolean;
+}
+export declare function usePaymentRetrieve(): PaymentRetrieveHook;