@tagadapay/plugin-sdk 3.1.11 → 3.1.22

package/dist/v2/react/hooks/payment-actions/usePaymentActionHandler.js

@@ -0,0 +1,142 @@
+/**
+ * Main payment action handler that routes to specific action handlers
+ */
+import { useCallback, useRef } from 'react';
+import { useThreedsAuthAction } from './useThreedsAuthAction';
+import { useProcessorAuthAction } from './useProcessorAuthAction';
+import { useRedirectAction } from './useRedirectAction';
+import { useErrorAction } from './useErrorAction';
+import { useFinixRadarAction } from './useFinixRadarAction';
+import { useAirwallexRadarAction } from './useAirwallexRadarAction';
+import { useStripeRadarAction } from './useStripeRadarAction';
+import { useKessPayAction } from './useKessPayAction';
+import { useTrustFlowAction } from './useTrustFlowAction';
+import { useMasterCardAction } from './useMasterCardAction';
+export function usePaymentActionHandler({ paymentsResource, startChallenge, startPolling, setIsLoading, setError, hookOptionsRef, }) {
+    // Track challenge in progress to prevent multiple challenges
+    const challengeInProgressRef = useRef(false);
+    // Initialize all action handlers
+    const { handleThreedsAuth } = useThreedsAuthAction({
+        startChallenge,
+        startPolling,
+        setIsLoading,
+        setError,
+        hookOptionsRef,
+        challengeInProgressRef,
+    });
+    const { handleProcessorAuth } = useProcessorAuthAction();
+    const { handleRedirect } = useRedirectAction({
+        setIsLoading,
+        hookOptionsRef,
+    });
+    const { handleError } = useErrorAction({
+        setError,
+        setIsLoading,
+    });
+    const { handleFinixRadar } = useFinixRadarAction({
+        paymentsResource,
+        startPolling,
+        setError,
+        setIsLoading,
+        hookOptionsRef,
+    });
+    const { handleAirwallexRadar } = useAirwallexRadarAction({
+        paymentsResource,
+        startPolling,
+        setError,
+        setIsLoading,
+        hookOptionsRef,
+    });
+    const { handleStripeRadar } = useStripeRadarAction({
+        paymentsResource,
+        startPolling,
+        setError,
+        setIsLoading,
+        hookOptionsRef,
+    });
+    const { handleKessPayAuth } = useKessPayAction({
+        setError,
+        setIsLoading,
+        hookOptionsRef,
+    });
+    const { handleTrustFlowAuth } = useTrustFlowAction({
+        setError,
+        setIsLoading,
+        hookOptionsRef,
+    });
+    const { handleMasterCardAuth } = useMasterCardAction({
+        paymentsResource,
+        startPolling,
+        setError,
+        setIsLoading,
+        hookOptionsRef,
+    });
+    // Main handler that routes to specific action handlers
+    const handlePaymentAction = useCallback(async (payment, options = {}) => {
+        if (payment.requireAction === 'none')
+            return;
+        if (payment?.requireActionData?.processed)
+            return;
+        const actionData = payment.requireActionData;
+        if (!actionData)
+            return;
+        // Mark action as processed
+        try {
+            await paymentsResource.markPaymentActionProcessed(payment.id);
+        }
+        catch (_error) {
+            // Error handling removed
+        }
+        // Route to appropriate action handler based on type
+        switch (actionData.type) {
+            case 'threeds_auth':
+                await handleThreedsAuth(payment, actionData, options);
+                break;
+            case 'processor_auth':
+            case 'redirect_to_payment':
+                await handleProcessorAuth(actionData);
+                break;
+            case 'redirect':
+                await handleRedirect(payment, actionData, options);
+                break;
+            case 'error':
+                await handleError(payment, actionData, options);
+                break;
+            case 'finix_radar':
+                await handleFinixRadar(payment, actionData, options, handlePaymentAction);
+                break;
+            case 'stripe_radar':
+                await handleStripeRadar(payment, actionData, options, handlePaymentAction);
+                break;
+            case 'kesspay_auth':
+                await handleKessPayAuth(payment, actionData, options);
+                break;
+            case 'trustflow_auth':
+                await handleTrustFlowAuth(payment, actionData, options);
+                break;
+            case 'mastercard_auth':
+                await handleMasterCardAuth(payment, actionData, options, handlePaymentAction);
+                break;
+            case 'radar':
+                // Check provider for specific implementation
+                if (actionData.metadata?.provider === 'airwallex') {
+                    await handleAirwallexRadar(payment, actionData, options, handlePaymentAction);
+                }
+                break;
+        }
+        options.onRequireAction?.(payment);
+    }, [
+        paymentsResource,
+        handleThreedsAuth,
+        handleProcessorAuth,
+        handleRedirect,
+        handleError,
+        handleFinixRadar,
+        handleAirwallexRadar,
+        handleStripeRadar,
+        handleKessPayAuth,
+        handleTrustFlowAuth,
+        handleMasterCardAuth,
+    ]);
+    return { handlePaymentAction };
+}

package/dist/v2/react/hooks/payment-actions/useProcessorAuthAction.d.ts

@@ -0,0 +1,3 @@
+export declare function useProcessorAuthAction(): {
+    handleProcessorAuth: (actionData: any) => Promise<void>;
+};

package/dist/v2/react/hooks/payment-actions/useProcessorAuthAction.js

@@ -0,0 +1,13 @@
+/**
+ * Hook for handling processor-specific authentication redirects
+ */
+import { useCallback } from 'react';
+export function useProcessorAuthAction() {
+    const handleProcessorAuth = useCallback(async (actionData) => {
+        // Always auto-redirect for processor auth (e.g., 3DS, external payment flows)
+        if (actionData.metadata?.redirect?.redirectUrl) {
+            window.location.href = actionData.metadata.redirect.redirectUrl;
+        }
+    }, []);
+    return { handleProcessorAuth };
+}

package/dist/v2/react/hooks/payment-actions/useRedirectAction.d.ts

@@ -0,0 +1,10 @@
+import type { Payment, PaymentOptions } from '../../../core/resources/payments';
+import type { UsePaymentOptions } from '../usePaymentQuery';
+interface UseRedirectActionParams {
+    setIsLoading: (loading: boolean) => void;
+    hookOptionsRef: React.MutableRefObject<UsePaymentOptions | undefined>;
+}
+export declare function useRedirectAction({ setIsLoading, hookOptionsRef }: UseRedirectActionParams): {
+    handleRedirect: (payment: Payment, actionData: any, options?: PaymentOptions) => Promise<void>;
+};
+export {};

package/dist/v2/react/hooks/payment-actions/useRedirectAction.js

@@ -0,0 +1,35 @@
+/**
+ * Hook for handling generic redirect actions
+ */
+import { useCallback } from 'react';
+export function useRedirectAction({ setIsLoading, hookOptionsRef }) {
+    const handleRedirect = useCallback(async (payment, actionData, options = {}) => {
+        // For redirect type, let funnel orchestrator handle navigation via callbacks
+        // Only auto-redirect if explicitly enabled (disableAutoRedirect: false)
+        const shouldAutoRedirect = options.disableAutoRedirect === false;
+        if (shouldAutoRedirect && actionData.metadata?.redirect?.redirectUrl) {
+            window.location.href = actionData.metadata.redirect.redirectUrl;
+        }
+        else if (payment.status === 'succeeded') {
+            // Payment succeeded - call success callbacks for funnel navigation
+            setIsLoading(false);
+            const response = {
+                paymentId: payment.id,
+                payment,
+                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)
+            options.onPaymentSuccess?.(response);
+        }
+    }, [setIsLoading, hookOptionsRef]);
+    return { handleRedirect };
+}

package/dist/v2/react/hooks/payment-actions/useStripeRadarAction.d.ts

@@ -0,0 +1,14 @@
+import type { Payment, PaymentOptions } from '../../../core/resources/payments';
+import type { PaymentsResource } from '../../../core/resources/payments';
+import type { UsePaymentOptions } from '../usePaymentQuery';
+interface UseStripeRadarActionParams {
+    paymentsResource: PaymentsResource;
+    startPolling: any;
+    setError: (error: string | null) => void;
+    setIsLoading: (loading: boolean) => void;
+    hookOptionsRef: React.MutableRefObject<UsePaymentOptions | undefined>;
+}
+export declare function useStripeRadarAction({ paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef, }: UseStripeRadarActionParams): {
+    handleStripeRadar: (payment: Payment, actionData: any, options: PaymentOptions | undefined, handlePaymentAction: any) => Promise<void>;
+};
+export {};

package/dist/v2/react/hooks/payment-actions/useStripeRadarAction.js

@@ -0,0 +1,192 @@
+/**
+ * Hook for handling Stripe Radar fraud detection
+ */
+import { useCallback, useRef } from 'react';
+export function useStripeRadarAction({ paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef, }) {
+    const scriptLoadingRef = useRef(false);
+    const handleStripeRadar = useCallback(async (payment, actionData, options = {}, handlePaymentAction) => {
+        const radarConfig = actionData.metadata?.radar;
+        if (!radarConfig?.publishableKey) {
+            console.error('Stripe radar config missing from payment action');
+            setError('Missing Stripe Radar configuration');
+            setIsLoading(false);
+            options.onFailure?.('Missing Stripe Radar configuration');
+            options.onPaymentFailed?.({
+                code: 'STRIPE_RADAR_MISSING_CONFIG',
+                message: 'Missing Stripe Radar configuration',
+                payment,
+            });
+            return;
+        }
+        try {
+            // Load Stripe if not already loaded
+            if (typeof window !== 'undefined' && typeof window.Stripe !== 'function' && !scriptLoadingRef.current) {
+                console.log('Loading Stripe script...');
+                scriptLoadingRef.current = true;
+                // Check if script already exists
+                const existingScript = document.querySelector('script[src="https://js.stripe.com/v3/"]');
+                if (existingScript) {
+                    console.log('Stripe script already exists, waiting for load...');
+                    if (typeof window.Stripe === 'function') {
+                        console.log('Stripe already loaded');
+                    }
+                    else {
+                        // Wait for existing script to load
+                        await new Promise((resolve, reject) => {
+                            const checkStripe = () => {
+                                if (typeof window.Stripe === 'function') {
+                                    resolve();
+                                }
+                                else {
+                                    setTimeout(checkStripe, 100);
+                                }
+                            };
+                            checkStripe();
+                            setTimeout(() => reject(new Error('Timeout waiting for Stripe')), 10000);
+                        });
+                    }
+                }
+                else {
+                    const script = document.createElement('script');
+                    script.src = 'https://js.stripe.com/v3/';
+                    script.async = true;
+                    document.head.appendChild(script);
+                    await new Promise((resolve, reject) => {
+                        script.onload = () => {
+                            console.log('Stripe script loaded successfully');
+                            scriptLoadingRef.current = false;
+                            resolve();
+                        };
+                        script.onerror = () => {
+                            scriptLoadingRef.current = false;
+                            reject(new Error('Failed to load Stripe'));
+                        };
+                    });
+                }
+            }
+            console.log('Initializing Stripe with public key:', radarConfig.publishableKey);
+            const stripe = window.Stripe(radarConfig.publishableKey);
+            const result = await stripe.createRadarSession();
+            console.log('Stripe Radar result:', result);
+            if (result.error) {
+                const errorMessage = result.error.message || 'Failed to create Radar session';
+                console.error('Stripe Radar error:', errorMessage);
+                throw new Error(errorMessage);
+            }
+            if (!result.radarSession) {
+                const errorMessage = 'No radar session returned from Stripe';
+                console.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+            console.log('Stripe Radar session created:', result.radarSession);
+            // Save radar session to database
+            await paymentsResource.saveRadarSession({
+                orderId: radarConfig.orderId,
+                stripeRadarSessionId: result.radarSession.id,
+                stripeRadarSessionData: result.radarSession,
+            });
+            console.log('Radar session saved to database');
+            // Resume payment by calling completePaymentAfterAction
+            const resumedPayment = await paymentsResource.completePaymentAfterAction(payment.id);
+            console.log('Payment resumed after Stripe radar:', resumedPayment);
+            // Handle the resumed payment response
+            if (resumedPayment.status === 'declined' || resumedPayment.status === 'failed') {
+                // Payment declined or failed - extract error message from response
+                const errorMsg = resumedPayment.error?.message
+                    || resumedPayment.error?.processorMessage
+                    || 'Payment declined';
+                console.error('❌ [usePayment] Payment declined after Stripe radar:', errorMsg);
+                setError(errorMsg);
+                setIsLoading(false);
+                options.onFailure?.(errorMsg);
+                options.onPaymentFailed?.({
+                    code: resumedPayment.error?.code || 'PAYMENT_DECLINED',
+                    message: errorMsg,
+                    payment: resumedPayment,
+                });
+                // Hook-level callback (universal handler)
+                if (hookOptionsRef.current?.onPaymentFailed) {
+                    hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                        isRedirectReturn: false,
+                    });
+                }
+            }
+            else if (resumedPayment.status === 'succeeded') {
+                // Payment succeeded
+                setIsLoading(false);
+                const response = {
+                    paymentId: resumedPayment.id,
+                    payment: resumedPayment,
+                    order: resumedPayment.order,
+                };
+                // Hook-level callback (universal handler)
+                if (hookOptionsRef.current?.onPaymentCompleted) {
+                    await hookOptionsRef.current.onPaymentCompleted(resumedPayment, {
+                        isRedirectReturn: false,
+                        order: response.order,
+                    });
+                }
+                options.onSuccess?.(response);
+                options.onPaymentSuccess?.(response);
+            }
+            else if (resumedPayment.requireAction !== 'none' && resumedPayment.requireActionData) {
+                // Payment requires another action (e.g., 3DS)
+                await handlePaymentAction(resumedPayment, options);
+            }
+            else {
+                // Start polling for final status
+                startPolling(resumedPayment.id, {
+                    onRequireAction: (updatedPayment) => {
+                        void handlePaymentAction(updatedPayment, options);
+                    },
+                    onSuccess: async (successPayment) => {
+                        setIsLoading(false);
+                        const response = {
+                            paymentId: successPayment.id,
+                            payment: successPayment,
+                            order: successPayment.order,
+                        };
+                        // Hook-level callback (universal handler)
+                        if (hookOptionsRef.current?.onPaymentCompleted) {
+                            await hookOptionsRef.current.onPaymentCompleted(successPayment, {
+                                isRedirectReturn: false,
+                                order: response.order,
+                            });
+                        }
+                        options.onSuccess?.(response);
+                        options.onPaymentSuccess?.(response);
+                    },
+                    onFailure: async (errorMsg) => {
+                        setError(errorMsg);
+                        setIsLoading(false);
+                        // Hook-level callback (universal handler)
+                        if (hookOptionsRef.current?.onPaymentFailed) {
+                            await hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                                isRedirectReturn: false,
+                            });
+                        }
+                        options.onFailure?.(errorMsg);
+                        options.onPaymentFailed?.({
+                            code: 'PAYMENT_FAILED',
+                            message: errorMsg,
+                            payment,
+                        });
+                    },
+                });
+            }
+        }
+        catch (radarError) {
+            const errorMsg = radarError instanceof Error ? radarError.message : 'Stripe Radar failed';
+            console.error('Stripe radar error:', radarError);
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({
+                code: 'STRIPE_RADAR_FAILED',
+                message: errorMsg,
+                payment,
+            });
+        }
+    }, [paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef]);
+    return { handleStripeRadar };
+}

package/dist/v2/react/hooks/payment-actions/useThreedsAuthAction.d.ts

@@ -0,0 +1,14 @@
+import type { Payment, PaymentOptions } from '../../../core/resources/payments';
+import type { UsePaymentOptions } from '../usePaymentQuery';
+interface UseThreedsAuthActionParams {
+    startChallenge: any;
+    startPolling: any;
+    setIsLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    hookOptionsRef: React.MutableRefObject<UsePaymentOptions | undefined>;
+    challengeInProgressRef: React.MutableRefObject<boolean>;
+}
+export declare function useThreedsAuthAction({ startChallenge, startPolling, setIsLoading, setError, hookOptionsRef, challengeInProgressRef, }: UseThreedsAuthActionParams): {
+    handleThreedsAuth: (payment: Payment, actionData: any, options?: PaymentOptions) => Promise<void>;
+};
+export {};

package/dist/v2/react/hooks/payment-actions/useThreedsAuthAction.js

@@ -0,0 +1,81 @@
+/**
+ * Hook for handling 3DS authentication actions
+ */
+import { useCallback } from 'react';
+export function useThreedsAuthAction({ startChallenge, startPolling, setIsLoading, setError, hookOptionsRef, challengeInProgressRef, }) {
+    const handleThreedsAuth = useCallback(async (payment, actionData, options = {}) => {
+        if (actionData.metadata?.threedsSession && !challengeInProgressRef.current) {
+            try {
+                challengeInProgressRef.current = true;
+                await startChallenge({
+                    sessionId: actionData.metadata.threedsSession.externalSessionId,
+                    acsChallengeUrl: actionData.metadata.threedsSession.acsChallengeUrl,
+                    acsTransactionId: actionData.metadata.threedsSession.acsTransID,
+                    threeDSVersion: actionData.metadata.threedsSession.messageVersion,
+                }, { provider: options.threedsProvider || 'basis_theory' });
+                challengeInProgressRef.current = false;
+                // Start polling after challenge completion
+                if (payment.id) {
+                    startPolling(payment.id, {
+                        onRequireAction: (updatedPayment) => {
+                            // Will be handled by parent
+                            options.onRequireAction?.(updatedPayment);
+                        },
+                        onSuccess: async (successPayment) => {
+                            setIsLoading(false);
+                            const response = {
+                                paymentId: successPayment.id,
+                                payment: successPayment,
+                                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: 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)
+                            options.onPaymentFailed?.({
+                                code: 'PAYMENT_FAILED',
+                                message: errorMsg,
+                                payment,
+                            });
+                        },
+                    });
+                }
+            }
+            catch (_error) {
+                challengeInProgressRef.current = false;
+                const errorMsg = _error instanceof Error ? _error.message : 'Failed to start 3DS challenge';
+                setError(errorMsg);
+                setIsLoading(false);
+                // Legacy callback (backwards compatibility)
+                options.onFailure?.(errorMsg);
+                // Funnel-aligned callback (recommended)
+                options.onPaymentFailed?.({
+                    code: '3DS_CHALLENGE_FAILED',
+                    message: errorMsg,
+                    payment,
+                });
+            }
+        }
+    }, [startChallenge, startPolling, setIsLoading, setError, hookOptionsRef, challengeInProgressRef]);
+    return { handleThreedsAuth };
+}

package/dist/v2/react/hooks/payment-actions/useTrustFlowAction.d.ts

@@ -0,0 +1,11 @@
+import type { Payment, PaymentOptions } from '../../../core/resources/payments';
+import type { UsePaymentOptions } from '../usePaymentQuery';
+interface UseTrustFlowActionParams {
+    setError: (error: string | null) => void;
+    setIsLoading: (loading: boolean) => void;
+    hookOptionsRef: React.MutableRefObject<UsePaymentOptions | undefined>;
+}
+export declare function useTrustFlowAction({ setError, setIsLoading, hookOptionsRef, }: UseTrustFlowActionParams): {
+    handleTrustFlowAuth: (payment: Payment, actionData: any, options?: PaymentOptions) => Promise<void>;
+};
+export {};

package/dist/v2/react/hooks/payment-actions/useTrustFlowAction.js

@@ -0,0 +1,84 @@
+/**
+ * Hook for handling Trust Flow 3DS authentication
+ */
+import { useCallback, useRef } from 'react';
+export function useTrustFlowAction({ setError, setIsLoading, hookOptionsRef, }) {
+    const challengeInProgressRef = useRef(false);
+    const handleTrustFlowAuth = useCallback(async (payment, actionData, options = {}) => {
+        if (challengeInProgressRef.current) {
+            console.log('Trust Flow 3DS challenge already in progress');
+            return;
+        }
+        const authData = actionData?.metadata?.trustflow;
+        if (!authData?.appId || !authData?.txnId || !authData?.hash) {
+            const errorMsg = 'Missing Trust Flow 3DS authentication data';
+            console.error(errorMsg);
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({
+                code: 'TRUSTFLOW_MISSING_DATA',
+                message: errorMsg,
+                payment,
+            });
+            return;
+        }
+        try {
+            challengeInProgressRef.current = true;
+            setIsLoading(false); // Stop loading before redirect
+            console.log('🔐 [Trust Flow] Starting 3DS authentication:', {
+                appId: authData.appId,
+                txnId: authData.txnId,
+                captureUrl: authData.captureUrl,
+                testMode: authData.testMode,
+            });
+            // Create form for Trust Flow 3DS capture request
+            const form = document.createElement('form');
+            form.method = 'POST';
+            form.action = authData.captureUrl;
+            form.style.display = 'none';
+            // Add required fields for Trust Flow capture
+            const appIdInput = document.createElement('input');
+            appIdInput.type = 'hidden';
+            appIdInput.name = 'APP_ID';
+            appIdInput.value = authData.appId;
+            form.appendChild(appIdInput);
+            const txnIdInput = document.createElement('input');
+            txnIdInput.type = 'hidden';
+            txnIdInput.name = 'TXN_ID';
+            txnIdInput.value = authData.txnId;
+            form.appendChild(txnIdInput);
+            const hashInput = document.createElement('input');
+            hashInput.type = 'hidden';
+            hashInput.name = 'HASH';
+            hashInput.value = authData.hash;
+            form.appendChild(hashInput);
+            // Add form to document and submit
+            document.body.appendChild(form);
+            form.submit();
+            console.log('🔐 [Trust Flow] Redirecting to 3DS challenge...');
+            // Note: Success callback will be triggered after redirect return
+            // Payment status will be updated via webhook
+        }
+        catch (error) {
+            challengeInProgressRef.current = false;
+            const errorMsg = error instanceof Error ? error.message : 'Failed to process Trust Flow 3DS authentication';
+            console.error('🔐 [Trust Flow] 3DS authentication error:', error);
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({
+                code: 'TRUSTFLOW_AUTH_FAILED',
+                message: errorMsg,
+                payment,
+            });
+            // Hook-level callback (universal handler)
+            if (hookOptionsRef.current?.onPaymentFailed) {
+                hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                    isRedirectReturn: false,
+                });
+            }
+        }
+    }, [setError, setIsLoading, hookOptionsRef]);
+    return { handleTrustFlowAuth };
+}

package/dist/v2/react/hooks/payment-processing/usePaymentInstruments.d.ts

@@ -0,0 +1,14 @@
+import type { CardPaymentMethod, ApplePayToken, GooglePayToken, BasisTheoryInstance, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse } from '../../../core/resources/payments';
+import type { PaymentsResource } from '../../../core/resources/payments';
+interface UsePaymentInstrumentsParams {
+    basisTheory: BasisTheoryInstance | undefined;
+    paymentsResource: PaymentsResource;
+    setError: (error: string | null) => void;
+}
+export declare function usePaymentInstruments({ basisTheory, paymentsResource, setError, }: UsePaymentInstrumentsParams): {
+    createCardPaymentInstrument: (cardData: CardPaymentMethod) => Promise<PaymentInstrumentResponse>;
+    createApplePayPaymentInstrument: (applePayToken: ApplePayToken) => Promise<PaymentInstrumentResponse>;
+    createGooglePayPaymentInstrument: (googlePayToken: GooglePayToken) => Promise<PaymentInstrumentResponse>;
+    getCardPaymentInstruments: () => Promise<PaymentInstrumentCustomerResponse>;
+};
+export {};

package/dist/v2/react/hooks/payment-processing/usePaymentInstruments.js

@@ -0,0 +1,36 @@
+/**
+ * Hook for managing payment instruments
+ */
+import { useCallback } from 'react';
+export function usePaymentInstruments({ basisTheory, paymentsResource, setError, }) {
+    // Create card payment instrument
+    const createCardPaymentInstrument = useCallback((cardData) => {
+        return paymentsResource.createCardPaymentInstrument(basisTheory, cardData);
+    }, [basisTheory, paymentsResource]);
+    // Create Apple Pay payment instrument
+    const createApplePayPaymentInstrument = useCallback((applePayToken) => {
+        return paymentsResource.createApplePayPaymentInstrument(basisTheory, applePayToken);
+    }, [basisTheory, paymentsResource]);
+    // Create Google Pay payment instrument
+    const createGooglePayPaymentInstrument = useCallback((googlePayToken) => {
+        return paymentsResource.createGooglePayPaymentInstrument(basisTheory, googlePayToken);
+    }, [basisTheory, paymentsResource]);
+    // Get card payment instruments
+    const getCardPaymentInstruments = useCallback(async () => {
+        try {
+            const response = await paymentsResource.getCardPaymentInstruments();
+            return response;
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : 'Failed to fetch payment instruments';
+            setError(errorMsg);
+            throw error;
+        }
+    }, [paymentsResource, setError]);
+    return {
+        createCardPaymentInstrument,
+        createApplePayPaymentInstrument,
+        createGooglePayPaymentInstrument,
+        getCardPaymentInstruments,
+    };
+}