@tagadapay/plugin-sdk 2.6.4 → 2.6.6

package/dist/v2/react/components/GooglePayButton.js

@@ -0,0 +1,355 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Google Pay Button Component for v2 Architecture
+ * Uses v2 useExpressPaymentMethods hook and follows clean architecture principles
+ */
+import GooglePayButtonReact from '@google-pay/button-react';
+import { useCallback, useEffect, useState } from 'react';
+import { useExpressPaymentMethods } from '../hooks/useExpressPaymentMethods';
+const basistheoryPublicKey = process.env.NEXT_PUBLIC_BASIS_THEORY_PUBLIC_API_KEY || '';
+const basistheoryTenantId = process.env.NEXT_PUBLIC_BASIS_THEORY_TENANT_ID || '0b283fa3-44a1-4535-adff-e99ad0a58a47';
+export const GooglePayButton = ({ className = '', disabled = false, onSuccess, onError, onCancel, checkout, size = 'lg', buttonColor = 'black', buttonType = 'plain', }) => {
+    const { googlePayPaymentMethod, shippingMethods, lineItems, handleAddExpressId, updateCheckoutSessionValues, updateCustomerEmail, reComputeOrderSummary, setError: setContextError, } = useExpressPaymentMethods();
+    const [processingPayment, setProcessingPayment] = useState(false);
+    const [pendingPaymentData, setPendingPaymentData] = useState(null);
+    const [googlePayError, setGooglePayError] = useState(null);
+    // Don't render if no Google Pay payment method is enabled
+    if (!googlePayPaymentMethod) {
+        return null;
+    }
+    // Register express payment method
+    useEffect(() => {
+        handleAddExpressId('google_pay');
+    }, [handleAddExpressId]);
+    // Convert Google Pay address to internal Address format
+    const googlePayAddressToAddress = useCallback((googlePayAddress) => {
+        return {
+            address1: googlePayAddress.address1 || '',
+            address2: googlePayAddress.address2 || '',
+            lastName: googlePayAddress.name?.split(' ').slice(-1)[0] || '',
+            firstName: googlePayAddress.name?.split(' ').slice(0, -1).join(' ') || '',
+            city: googlePayAddress.locality || '',
+            state: googlePayAddress.administrativeArea || '',
+            country: googlePayAddress.countryCode || '',
+            postal: googlePayAddress.postalCode || '',
+            phone: googlePayAddress.phoneNumber || '',
+            email: '',
+        };
+    }, []);
+    // Tokenize Google Pay data using Basis Theory
+    const tokenizeGooglePayTokenWithBasisTheory = useCallback(async (paymentData) => {
+        try {
+            const googlePayTokenString = paymentData.paymentMethodData.tokenizationData.token;
+            const googlePayToken = JSON.parse(googlePayTokenString);
+            const response = await fetch('https://api.basistheory.com/google-pay', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'BT-API-KEY': basistheoryPublicKey,
+                },
+                body: JSON.stringify({
+                    google_payment_data: googlePayToken,
+                }),
+            });
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                console.error('Basis Theory API error:', errorData);
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            const jsonResponse = await response.json();
+            return jsonResponse?.token_intent || jsonResponse?.google_pay;
+        }
+        catch (error) {
+            console.error('Error tokenizing Google Pay data:', error);
+            throw error;
+        }
+    }, []);
+    // Process Google Pay payment
+    const processGooglePayPayment = useCallback(async (token) => {
+        if (!checkout.checkoutSession.id) {
+            throw new Error('Checkout session ID is not available');
+        }
+        setProcessingPayment(true);
+        try {
+            // Process payment with backend API
+            const response = await fetch('/api/v1/google-pay/process-payment', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    checkoutSessionId: checkout.checkoutSession.id,
+                    paymentToken: token,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error('Failed to process Google Pay payment');
+            }
+            const paymentResult = await response.json();
+            if (onSuccess) {
+                onSuccess(paymentResult);
+            }
+        }
+        catch (error) {
+            console.error('Error processing Google Pay payment:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Google Pay payment failed';
+            setGooglePayError(errorMessage);
+            setContextError(errorMessage);
+            if (onError) {
+                onError(errorMessage);
+            }
+            throw error;
+        }
+        finally {
+            setProcessingPayment(false);
+        }
+    }, [checkout.checkoutSession.id, onSuccess, onError, setContextError]);
+    // Process payment data
+    const onGooglePaymentData = useCallback(async (paymentData) => {
+        setProcessingPayment(true);
+        try {
+            // Extract billing address if available
+            let billingAddress;
+            if (paymentData.paymentMethodData.info?.billingAddress) {
+                billingAddress = googlePayAddressToAddress(paymentData.paymentMethodData.info.billingAddress);
+            }
+            // Extract shipping address if available
+            let shippingAddress;
+            if (paymentData.shippingAddress) {
+                shippingAddress = googlePayAddressToAddress(paymentData.shippingAddress);
+            }
+            // Update checkout session with addresses before processing payment
+            if (shippingAddress) {
+                await updateCheckoutSessionValues({
+                    data: {
+                        shippingAddress,
+                        billingAddress: billingAddress ?? null,
+                    },
+                });
+            }
+            // Update customer email if provided
+            if (paymentData.email) {
+                await updateCustomerEmail({
+                    data: {
+                        email: paymentData.email,
+                    },
+                });
+            }
+            const payToken = await tokenizeGooglePayTokenWithBasisTheory(paymentData);
+            await processGooglePayPayment(payToken);
+        }
+        catch (error) {
+            console.error('Error processing Google Pay payment:', error);
+            const errorMessage = error instanceof Error ? error.message : 'Payment Failed';
+            setProcessingPayment(false);
+            setGooglePayError(errorMessage);
+            setContextError(errorMessage);
+            if (onError) {
+                onError(errorMessage);
+            }
+        }
+    }, [
+        googlePayAddressToAddress,
+        updateCheckoutSessionValues,
+        updateCustomerEmail,
+        tokenizeGooglePayTokenWithBasisTheory,
+        processGooglePayPayment,
+        onError,
+        setContextError,
+    ]);
+    // Effect to process payment data in background
+    useEffect(() => {
+        if (pendingPaymentData && !processingPayment) {
+            const processPaymentInBackground = async () => {
+                try {
+                    await onGooglePaymentData(pendingPaymentData);
+                }
+                catch (error) {
+                    console.error('Background payment processing failed:', error);
+                }
+                finally {
+                    setPendingPaymentData(null);
+                }
+            };
+            void processPaymentInBackground();
+        }
+    }, [pendingPaymentData, processingPayment, onGooglePaymentData]);
+    // Handle payment data changes during the flow
+    const handleGooglePayDataChanged = useCallback((intermediatePaymentData) => {
+        return new Promise((resolve) => {
+            const processCallback = async () => {
+                try {
+                    const paymentDataRequestUpdate = {};
+                    if (intermediatePaymentData.callbackTrigger === 'SHIPPING_ADDRESS') {
+                        const address = intermediatePaymentData.shippingAddress;
+                        const shippingAddress = {
+                            address1: address?.addressLines?.[0] || '',
+                            address2: address?.addressLines?.[1] || '',
+                            lastName: address?.name?.split(' ').slice(-1)[0] || '',
+                            firstName: address?.name?.split(' ').slice(0, -1).join(' ') || '',
+                            city: address?.locality || '',
+                            state: address?.administrativeArea || '',
+                            country: address?.countryCode || '',
+                            postal: address?.postalCode || '',
+                            phone: address?.phoneNumber || '',
+                            email: '',
+                        };
+                        await updateCheckoutSessionValues({
+                            data: { shippingAddress },
+                        });
+                        const newOrderSummary = await reComputeOrderSummary();
+                        if (newOrderSummary) {
+                            paymentDataRequestUpdate.newShippingOptionParameters = {
+                                defaultSelectedOptionId: newOrderSummary.shippingMethods[0]?.identifier || '',
+                                shippingOptions: newOrderSummary.shippingMethods.map((method) => ({
+                                    id: method.identifier,
+                                    label: method.label,
+                                    description: method.amount + ': ' + method.detail || '',
+                                })),
+                            };
+                            paymentDataRequestUpdate.newTransactionInfo = {
+                                totalPriceStatus: 'FINAL',
+                                totalPrice: newOrderSummary.total.amount,
+                                currencyCode: checkout.summary?.currency || 'USD',
+                            };
+                        }
+                    }
+                    else if (intermediatePaymentData.callbackTrigger === 'SHIPPING_OPTION') {
+                        // Update shipping rate
+                        if (intermediatePaymentData.shippingOptionData?.id) {
+                            const response = await fetch('/api/v1/shipping-rates/select', {
+                                method: 'POST',
+                                headers: {
+                                    'Content-Type': 'application/json',
+                                },
+                                body: JSON.stringify({
+                                    checkoutSessionId: checkout.checkoutSession.id,
+                                    shippingRateId: intermediatePaymentData.shippingOptionData.id,
+                                }),
+                            });
+                            if (response.ok) {
+                                const newOrderSummary = await reComputeOrderSummary();
+                                if (newOrderSummary) {
+                                    paymentDataRequestUpdate.newTransactionInfo = {
+                                        totalPriceStatus: 'FINAL',
+                                        totalPrice: newOrderSummary.total.amount,
+                                        currencyCode: checkout.summary?.currency || 'USD',
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    else if (intermediatePaymentData.callbackTrigger === 'OFFER') {
+                        console.log('OFFER callback triggered, no action needed');
+                    }
+                    else if (intermediatePaymentData.callbackTrigger === 'INITIALIZE') {
+                        console.log('INITIALIZE callback triggered, no action needed');
+                    }
+                    resolve(paymentDataRequestUpdate);
+                }
+                catch (error) {
+                    console.error('Error in onPaymentDataChanged:', error);
+                    resolve({
+                        error: {
+                            reason: 'SHIPPING_ADDRESS_UNSERVICEABLE',
+                            message: 'Unable to calculate shipping for this address',
+                            intent: intermediatePaymentData.callbackTrigger,
+                        },
+                    });
+                }
+            };
+            void processCallback();
+        });
+    }, [updateCheckoutSessionValues, reComputeOrderSummary, checkout]);
+    // Handle payment authorization
+    const handleGooglePayAuthorized = useCallback((paymentData) => {
+        setPendingPaymentData(paymentData);
+        return Promise.resolve({ transactionState: 'SUCCESS' });
+    }, []);
+    // Don't render if no order summary
+    if (!checkout.summary) {
+        return null;
+    }
+    const minorUnitsToCurrencyString = (amountMinor, currency) => {
+        return (amountMinor / 100).toFixed(2);
+    };
+    const allowedCardNetworks = ['AMEX', 'DISCOVER', 'INTERAC', 'JCB', 'MASTERCARD', 'VISA'];
+    const allowedCardAuthMethods = ['PAN_ONLY', 'CRYPTOGRAM_3DS'];
+    const baseCardPaymentMethod = {
+        type: 'CARD',
+        parameters: {
+            allowedAuthMethods: allowedCardAuthMethods,
+            allowedCardNetworks: allowedCardNetworks,
+            billingAddressRequired: true,
+            billingAddressParameters: {
+                format: 'FULL',
+                phoneNumberRequired: true,
+            },
+        },
+    };
+    const tokenizationSpecification = {
+        type: 'PAYMENT_GATEWAY',
+        parameters: {
+            gateway: 'basistheory',
+            gatewayMerchantId: basistheoryTenantId,
+        },
+    };
+    const paymentRequest = {
+        apiVersion: 2,
+        apiVersionMinor: 0,
+        allowedPaymentMethods: [
+            {
+                ...baseCardPaymentMethod,
+                tokenizationSpecification,
+            },
+        ],
+        transactionInfo: {
+            totalPriceStatus: 'FINAL',
+            totalPrice: minorUnitsToCurrencyString(checkout.summary.totalAdjustedAmount, checkout.summary.currency),
+            currencyCode: checkout.summary.currency,
+        },
+        merchantInfo: {
+            merchantName: googlePayPaymentMethod?.metadata?.merchantName ||
+                checkout.checkoutSession?.store?.name ||
+                'Store',
+            merchantId: googlePayPaymentMethod?.metadata?.sandboxed
+                ? '12345678901234567890'
+                : googlePayPaymentMethod?.metadata?.merchantId || '12345678901234567890',
+        },
+        shippingAddressRequired: true,
+        shippingOptionRequired: true,
+        emailRequired: true,
+        callbackIntents: ['SHIPPING_OPTION', 'SHIPPING_ADDRESS', 'PAYMENT_AUTHORIZATION'],
+        shippingOptionParameters: {
+            defaultSelectedOptionId: shippingMethods.length > 0 ? shippingMethods[0].identifier : '',
+            shippingOptions: shippingMethods.map((method) => ({
+                id: method.identifier,
+                label: method.label,
+                description: method.amount + ': ' + method.detail || '',
+            })),
+        },
+    };
+    const environment = googlePayPaymentMethod?.metadata?.sandboxed ? 'TEST' : 'PRODUCTION';
+    // Button size classes
+    const sizeClasses = {
+        sm: 'h-8',
+        md: 'h-10',
+        lg: 'h-12',
+    };
+    const Button = ({ children }) => (_jsx("button", { type: "button", disabled: true, className: `w-full rounded-md bg-black text-base text-white shadow-sm hover:bg-black/80 disabled:cursor-not-allowed disabled:opacity-50 ${sizeClasses[size]} `, children: _jsxs("div", { className: "flex items-center justify-center gap-3", children: [_jsx("div", { className: "h-5 w-5 animate-spin rounded-full border-2 border-white border-t-transparent" }), children] }) }));
+    return (_jsxs("div", { className: "w-full", children: [!processingPayment ? (_jsx(GooglePayButtonReact, { environment: environment, paymentRequest: paymentRequest, onPaymentAuthorized: handleGooglePayAuthorized, onPaymentDataChanged: handleGooglePayDataChanged, onError: (error) => {
+                    console.error('Google Pay error:', error);
+                    const errorMessage = 'Google Pay error: ' + error.statusMessage;
+                    setGooglePayError(errorMessage);
+                    setContextError(errorMessage);
+                    if (onError) {
+                        onError(errorMessage);
+                    }
+                }, onCancel: () => {
+                    console.log('Google Pay payment cancelled');
+                    if (onCancel) {
+                        onCancel();
+                    }
+                }, existingPaymentMethodRequired: false, buttonColor: buttonColor, buttonType: buttonType, buttonSizeMode: "fill", buttonLocale: "en", className: `m-0 w-full rounded-sm p-0 text-base text-white ${sizeClasses[size]} ${className}` })) : (_jsx(Button, { children: _jsx("span", { className: "font-medium", children: "Processing..." }) })), googlePayError && (_jsx("div", { className: "mt-2 rounded border border-red-200 bg-red-50 p-2 text-sm text-red-600", children: googlePayError }))] }));
+};
+export default GooglePayButton;

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

@@ -2,7 +2,7 @@
  * API Query Hook using TanStack Query + Axios
  * Facade pattern for React SDK
  */
-import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
+import { UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
 import { ApiClient } from '../../core/resources/apiClient';
 export declare function setGlobalApiClient(client: ApiClient): void;
 export declare function getGlobalApiClient(): ApiClient;
@@ -10,7 +10,10 @@ export declare function getGlobalApiClientOrNull(): ApiClient | null;
 export declare const queryKeys: {
     readonly checkout: (token: string, currency?: string) => (string | undefined)[];
     readonly promotions: (sessionId: string) => string[];
+    readonly discounts: (sessionId: string) => string[];
     readonly orderBumps: (sessionId: string) => string[];
+    readonly shippingRates: (sessionId: string) => string[];
+    readonly vipPreview: (sessionId: string, offerIds: string[]) => (string | string[])[];
     readonly products: (productIds: string[], options?: Record<string, any>) => (string | string[] | Record<string, any> | undefined)[];
     readonly store: (storeId: string) => string[];
     readonly order: (orderId: string) => string[];

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

@@ -2,7 +2,7 @@
  * API Query Hook using TanStack Query + Axios
  * Facade pattern for React SDK
  */
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 // Global API client instance
 let globalApiClient = null;
 export function setGlobalApiClient(client) {
@@ -21,7 +21,10 @@ export function getGlobalApiClientOrNull() {
 export const queryKeys = {
     checkout: (token, currency) => ['checkout', token, currency].filter(Boolean),
     promotions: (sessionId) => ['promotions', sessionId],
+    discounts: (sessionId) => ['discounts', sessionId],
     orderBumps: (sessionId) => ['order-bumps', sessionId],
+    shippingRates: (sessionId) => ['shipping-rates', sessionId],
+    vipPreview: (sessionId, offerIds) => ['vip-preview', sessionId, offerIds],
     products: (productIds, options) => ['products', productIds, options],
     store: (storeId) => ['store', storeId],
     order: (orderId) => ['order', orderId],

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

@@ -0,0 +1,30 @@
+/**
+ * Discounts Hook using TanStack Query
+ * Simplified discount code management with automatic cache invalidation
+ */
+import { Discount } from '../../core/resources/discounts';
+export interface UseDiscountsQueryOptions {
+    sessionId?: string;
+    enabled?: boolean;
+    onApplySuccess?: (discount?: Discount) => void;
+    onRemoveSuccess?: () => void;
+}
+export interface UseDiscountsQueryResult {
+    appliedDiscounts: Discount[] | undefined;
+    isLoading: boolean;
+    isApplying: boolean;
+    isRemoving: boolean;
+    error: Error | null;
+    applyDiscountCode: (code: string) => Promise<{
+        success: boolean;
+        error?: string;
+        discount?: Discount;
+    }>;
+    removeDiscount: (discountId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    refresh: () => Promise<void>;
+    clearError: () => void;
+}
+export declare function useDiscountsQuery(options?: UseDiscountsQueryOptions): UseDiscountsQueryResult;

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

@@ -0,0 +1,175 @@
+/**
+ * Discounts Hook using TanStack Query
+ * Simplified discount code management with automatic cache invalidation
+ */
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { DiscountsResource } from '../../core/resources/discounts';
+import { getGlobalApiClient } from './useApiQuery';
+export function useDiscountsQuery(options = {}) {
+    const { sessionId, enabled = true, onApplySuccess, onRemoveSuccess } = options;
+    const queryClient = useQueryClient();
+    // Create discounts resource client
+    const discountsResource = useMemo(() => {
+        try {
+            return new DiscountsResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize discounts resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Main discounts query
+    const { data: appliedDiscounts, isLoading: isFetching, error: fetchError, refetch: refetchDiscounts, } = useQuery({
+        queryKey: ['discounts', sessionId],
+        queryFn: () => discountsResource.getAppliedDiscounts(sessionId),
+        enabled: enabled && !!sessionId,
+        staleTime: 30000, // 30 seconds
+        refetchOnWindowFocus: false,
+    });
+    // Apply discount code mutation
+    const applyMutation = useMutation({
+        mutationFn: ({ code }) => {
+            if (!sessionId) {
+                throw new Error('No checkout session available');
+            }
+            if (!code || code.trim() === '') {
+                throw new Error('Discount code is required');
+            }
+            return discountsResource.applyDiscountCode(sessionId, code);
+        },
+        onSuccess: async (response) => {
+            if (response.success) {
+                // Invalidate both discounts and checkout queries
+                if (sessionId) {
+                    await Promise.all([
+                        queryClient.invalidateQueries({ queryKey: ['discounts', sessionId] }),
+                        queryClient.invalidateQueries({ queryKey: ['checkout'] }),
+                    ]);
+                }
+                // Call onSuccess callback if provided
+                if (onApplySuccess) {
+                    onApplySuccess(response.promotion);
+                }
+            }
+        },
+    });
+    // Remove discount mutation
+    const removeMutation = useMutation({
+        mutationFn: ({ discountId }) => {
+            if (!sessionId) {
+                throw new Error('No checkout session available');
+            }
+            if (!discountId) {
+                throw new Error('Discount ID is required');
+            }
+            return discountsResource.removeDiscount(sessionId, discountId);
+        },
+        onSuccess: async (response) => {
+            if (response.success) {
+                // Invalidate both discounts and checkout queries
+                if (sessionId) {
+                    await Promise.all([
+                        queryClient.invalidateQueries({ queryKey: ['discounts', sessionId] }),
+                        queryClient.invalidateQueries({ queryKey: ['checkout'] }),
+                    ]);
+                }
+                // Call onSuccess callback if provided
+                if (onRemoveSuccess) {
+                    onRemoveSuccess();
+                }
+            }
+        },
+    });
+    // Apply discount code function
+    const applyDiscountCode = useCallback(async (code) => {
+        try {
+            const response = await applyMutation.mutateAsync({ code });
+            if (response.success) {
+                return { success: true, discount: response.promotion };
+            }
+            else {
+                return {
+                    success: false,
+                    error: response.error?.message || 'Failed to apply discount code',
+                };
+            }
+        }
+        catch (err) {
+            // Extract error message from API response
+            let errorMessage = 'Failed to apply discount code';
+            if (err && typeof err === 'object') {
+                const error = err;
+                if (error.response?.data?.error?.message) {
+                    errorMessage = error.response.data.error.message;
+                }
+                else if (error.response?.data?.message) {
+                    errorMessage = error.response.data.message;
+                }
+                else if (error.message) {
+                    errorMessage = error.message;
+                }
+            }
+            return { success: false, error: errorMessage };
+        }
+    }, [applyMutation]);
+    // Remove discount function
+    const removeDiscount = useCallback(async (discountId) => {
+        try {
+            const response = await removeMutation.mutateAsync({ discountId });
+            if (response.success) {
+                return { success: true };
+            }
+            else {
+                return {
+                    success: false,
+                    error: response.error?.message || 'Failed to remove discount',
+                };
+            }
+        }
+        catch (err) {
+            // Extract error message from API response
+            let errorMessage = 'Failed to remove discount';
+            if (err && typeof err === 'object') {
+                const error = err;
+                if (error.response?.data?.error?.message) {
+                    errorMessage = error.response.data.error.message;
+                }
+                else if (error.response?.data?.message) {
+                    errorMessage = error.response.data.message;
+                }
+                else if (error.message) {
+                    errorMessage = error.message;
+                }
+            }
+            return { success: false, error: errorMessage };
+        }
+    }, [removeMutation]);
+    // Refetch function
+    const refresh = useCallback(async () => {
+        await refetchDiscounts();
+    }, [refetchDiscounts]);
+    // Clear error function
+    const clearError = useCallback(() => {
+        // TanStack Query doesn't provide a direct way to clear errors
+        // We can trigger a refetch which will clear the error
+        void refresh();
+    }, [refresh]);
+    // Combine loading states
+    const isLoading = isFetching;
+    const isApplying = applyMutation.isPending;
+    const isRemoving = removeMutation.isPending;
+    // Combine errors
+    const error = (fetchError || applyMutation.error || removeMutation.error);
+    return {
+        appliedDiscounts,
+        isLoading,
+        isApplying,
+        isRemoving,
+        error,
+        applyDiscountCode,
+        removeDiscount,
+        refresh,
+        clearError,
+    };
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Express Payment Methods Hook for v2 Architecture
+ * Uses the ExpressPaymentMethodsProvider context
+ */
+import { ExpressPaymentMethodsContextType } from '../providers/ExpressPaymentMethodsProvider';
+/**
+ * Hook to access Express Payment Methods context
+ * Must be used within an ExpressPaymentMethodsProvider
+ */
+export declare const useExpressPaymentMethods: () => ExpressPaymentMethodsContextType;
+export type { ExpressPaymentMethodsContextType, ExpressPaymentMethodsProviderProps } from '../providers/ExpressPaymentMethodsProvider';
+export type { Address, PaymentMethod } from '../../core/resources/expressPaymentMethods';

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

@@ -0,0 +1,17 @@
+/**
+ * Express Payment Methods Hook for v2 Architecture
+ * Uses the ExpressPaymentMethodsProvider context
+ */
+import { useContext } from 'react';
+import { ExpressPaymentMethodsContext } from '../providers/ExpressPaymentMethodsProvider';
+/**
+ * Hook to access Express Payment Methods context
+ * Must be used within an ExpressPaymentMethodsProvider
+ */
+export const useExpressPaymentMethods = () => {
+    const context = useContext(ExpressPaymentMethodsContext);
+    if (context === undefined) {
+        throw new Error('useExpressPaymentMethods must be used within an ExpressPaymentMethodsProvider');
+    }
+    return context;
+};

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

@@ -48,6 +48,8 @@ export interface ExtractedAddress {
     locality: string;
     administrativeAreaLevel1: string;
     administrativeAreaLevel1Long: string;
+    administrativeAreaLevel2: string;
+    administrativeAreaLevel2Long: string;
     country: string;
     postalCode: string;
 }