@tagadapay/plugin-sdk 3.1.12 → 3.1.24

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

@@ -3,9 +3,19 @@
  * Replaces the coordinator pattern with automatic cache invalidation
  */
 import { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSessionPreview } from '../../core/resources/checkout';
+export interface CheckoutMessages {
+    /** Error shown when CMS session takes too long to initialize. Default: 'Session initialization timeout. Please refresh the page and try again.' */
+    sessionTimeout?: string;
+    /** Error shown when checkout resource fails to initialize. Default: 'Failed to initialize checkout resource' */
+    initFailed?: string;
+    /** Error shown when an operation is attempted without an active checkout session. Default: 'No checkout session available' */
+    noCheckoutSession?: string;
+}
 export interface UseCheckoutQueryOptions {
     checkoutToken?: string;
     enabled?: boolean;
+    /** Override default error messages (e.g. for i18n). Use with useTranslation's t() to pass translated strings. */
+    messages?: CheckoutMessages;
 }
 export interface UseCheckoutQueryResult {
     checkout: CheckoutData | undefined;
@@ -17,8 +27,14 @@ export interface UseCheckoutQueryResult {
         checkoutToken: string;
     }>;
     refresh: () => Promise<void>;
+    replaceSessionLineItems: (lineItems: CheckoutLineItem[]) => Promise<any>;
     updateLineItems: (lineItems: CheckoutLineItem[]) => Promise<any>;
     updateLineItemsOptimistic: (lineItems: CheckoutLineItem[]) => void;
+    addLineItems: (lineItems: CheckoutLineItem[]) => Promise<any>;
+    removeLineItems: (lineItems: {
+        variantId: string;
+        quantity?: number;
+    }[]) => Promise<any>;
     setItemQuantity: (variantId: string, quantity: number, priceId?: string) => Promise<any>;
     updateCustomer: (data: {
         email: string;

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

@@ -5,12 +5,19 @@
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { CheckoutResource } from '../../core/resources/checkout';
+import { getAssignedOrderBumpOfferIds } from '../../core/funnelClient';
 import { useTagadaContext } from '../providers/TagadaProvider';
 import { getGlobalApiClient } from './useApiQuery';
 import { useCurrency } from './useCurrency';
 import { usePluginConfig } from './usePluginConfig';
+const DEFAULT_MESSAGES = {
+    sessionTimeout: 'Session initialization timeout. Please refresh the page and try again.',
+    initFailed: 'Failed to initialize checkout resource',
+    noCheckoutSession: 'No checkout session available',
+};
 export function useCheckoutQuery(options = {}) {
-    const { checkoutToken: providedToken, enabled = true } = options;
+    const { checkoutToken: providedToken, enabled = true, messages: userMessages } = options;
+    const messages = { ...DEFAULT_MESSAGES, ...userMessages };
     const { storeId } = usePluginConfig();
     const currency = useCurrency();
     const queryClient = useQueryClient();
@@ -48,7 +55,7 @@ export function useCheckoutQuery(options = {}) {
                     if (sessionResolvers.current.size === 0) {
                         pendingSessionPromise.current = null;
                     }
-                    reject(new Error('Session initialization timeout. Please refresh the page and try again.'));
+                    reject(new Error(messages.sessionTimeout));
                 }
             }, 10000);
         });
@@ -60,7 +67,7 @@ export function useCheckoutQuery(options = {}) {
             return new CheckoutResource(getGlobalApiClient());
         }
         catch (error) {
-            throw new Error('Failed to initialize checkout resource: ' + (error instanceof Error ? error.message : 'Unknown error'));
+            throw new Error(messages.initFailed + ': ' + (error instanceof Error ? error.message : 'Unknown error'));
         }
     }, []);
     // Internal token state that can be updated after init
@@ -90,16 +97,17 @@ export function useCheckoutQuery(options = {}) {
     // Initialize checkout mutation (async mode for fast response)
     const initMutation = useMutation({
         mutationFn: async (params) => {
+            const enabledOrderBumpOfferIds = params.enabledOrderBumpOfferIds ?? getAssignedOrderBumpOfferIds();
             const requestBody = {
                 ...params,
                 storeId: params.storeId || storeId,
                 returnUrl: params.returnUrl || window.location.origin,
-                // Include customerId from session to prevent duplicate customer creation
                 customerId: params.customerId || session?.customerId,
                 customer: {
                     ...params.customer,
                     currency: params.customer?.currency ?? currency.code,
                 },
+                ...(enabledOrderBumpOfferIds && { enabledOrderBumpOfferIds }),
             };
             // Use async mode for fast response (~50ms vs 2-5s)
             const asyncResponse = await checkoutResource.initCheckoutAsync(requestBody);
@@ -121,11 +129,25 @@ export function useCheckoutQuery(options = {}) {
         },
     });
     // Order bump functionality removed - use useOrderBumpQuery instead
+    // Replace session line items mutation (full rewrite)
+    const replaceSessionLineItemsMutation = useMutation({
+        mutationFn: ({ lineItems }) => {
+            if (!checkout?.checkoutSession?.id) {
+                throw new Error(messages.noCheckoutSession);
+            }
+            return checkoutResource.replaceSessionLineItems(checkout.checkoutSession.id, lineItems);
+        },
+        onSuccess: () => {
+            if (checkoutToken) {
+                void queryClient.invalidateQueries({ queryKey: ['checkout', checkoutToken] });
+            }
+        },
+    });
     // Line items mutation with optimistic updates
     const lineItemsMutation = useMutation({
         mutationFn: ({ lineItems }) => {
             if (!checkout?.checkoutSession?.id) {
-                throw new Error('No checkout session available');
+                throw new Error(messages.noCheckoutSession);
             }
             return checkoutResource.updateLineItems(checkout.checkoutSession.id, lineItems);
         },
@@ -166,11 +188,39 @@ export function useCheckoutQuery(options = {}) {
             }
         },
     });
+    // Add line items mutation
+    const addLineItemsMutation = useMutation({
+        mutationFn: ({ lineItems }) => {
+            if (!checkout?.checkoutSession?.id) {
+                throw new Error(messages.noCheckoutSession);
+            }
+            return checkoutResource.addLineItems(checkout.checkoutSession.id, lineItems);
+        },
+        onSuccess: () => {
+            if (checkoutToken) {
+                void queryClient.invalidateQueries({ queryKey: ['checkout', checkoutToken] });
+            }
+        },
+    });
+    // Remove line items mutation
+    const removeLineItemsMutation = useMutation({
+        mutationFn: ({ lineItems }) => {
+            if (!checkout?.checkoutSession?.id) {
+                throw new Error(messages.noCheckoutSession);
+            }
+            return checkoutResource.removeLineItems(checkout.checkoutSession.id, lineItems);
+        },
+        onSuccess: () => {
+            if (checkoutToken) {
+                void queryClient.invalidateQueries({ queryKey: ['checkout', checkoutToken] });
+            }
+        },
+    });
     // Item quantity mutation
     const quantityMutation = useMutation({
         mutationFn: ({ variantId, quantity, priceId }) => {
             if (!checkout?.checkoutSession?.id) {
-                throw new Error('No checkout session available');
+                throw new Error(messages.noCheckoutSession);
             }
             return checkoutResource.setItemQuantity(checkout.checkoutSession.id, variantId, quantity, priceId);
         },
@@ -184,7 +234,7 @@ export function useCheckoutQuery(options = {}) {
     const customerMutation = useMutation({
         mutationFn: (data) => {
             if (!checkout?.checkoutSession?.id) {
-                throw new Error('No checkout session available');
+                throw new Error(messages.noCheckoutSession);
             }
             return checkoutResource.updateCustomer(checkout.checkoutSession.id, data);
         },
@@ -198,7 +248,7 @@ export function useCheckoutQuery(options = {}) {
     const customerAndSessionMutation = useMutation({
         mutationFn: (data) => {
             if (!checkout?.checkoutSession?.id) {
-                throw new Error('No checkout session available');
+                throw new Error(messages.noCheckoutSession);
             }
             return checkoutResource.updateCustomerAndSessionInfo(checkout.checkoutSession.id, data);
         },
@@ -212,7 +262,7 @@ export function useCheckoutQuery(options = {}) {
     const promotionMutation = useMutation({
         mutationFn: ({ code }) => {
             if (!checkout?.checkoutSession?.id) {
-                throw new Error('No checkout session available');
+                throw new Error(messages.noCheckoutSession);
             }
             return checkoutResource.applyPromotionCode(checkout.checkoutSession.id, code);
         },
@@ -229,7 +279,7 @@ export function useCheckoutQuery(options = {}) {
     const removePromotionMutation = useMutation({
         mutationFn: ({ promotionId }) => {
             if (!checkout?.checkoutSession?.id) {
-                throw new Error('No checkout session available');
+                throw new Error(messages.noCheckoutSession);
             }
             return checkoutResource.removePromotion(checkout.checkoutSession.id, promotionId);
         },
@@ -274,8 +324,11 @@ export function useCheckoutQuery(options = {}) {
         },
         refresh,
         // Checkout operations
+        replaceSessionLineItems: (lineItems) => replaceSessionLineItemsMutation.mutateAsync({ lineItems }),
         updateLineItems: (lineItems) => lineItemsMutation.mutateAsync({ lineItems }),
         updateLineItemsOptimistic: (lineItems) => lineItemsMutation.mutate({ lineItems }),
+        addLineItems: (lineItems) => addLineItemsMutation.mutateAsync({ lineItems }),
+        removeLineItems: (lineItems) => removeLineItemsMutation.mutateAsync({ lineItems }),
         setItemQuantity: (variantId, quantity, priceId) => quantityMutation.mutateAsync({ variantId, quantity, priceId }),
         updateCustomer: (data) => customerMutation.mutateAsync(data),
         updateCustomerAndSessionInfo: (data) => customerAndSessionMutation.mutateAsync(data),

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

@@ -14,8 +14,8 @@
  * // In any child component:
  * const { context, next, isLoading, stepConfig } = useFunnel();
  *
- * // Access step-specific config (payment flows, static resources, etc.)
- * const offerId = stepConfig.staticResources?.offer;
+ * // Access step-specific config (payment flows, resources, etc.)
+ * const offerId = stepConfig.resources?.offer;
  * const paymentFlowId = stepConfig.paymentFlowId;
  * ```
  */
@@ -35,10 +35,11 @@ export interface StepConfigValue {
      */
     paymentFlowId: string | undefined;
     /**
-     * Static resources assigned to this step/variant
-     * For A/B tests, this contains the resources for the specific variant
+     * Resource bindings for this step/variant.
      * e.g., { offer: 'offer_xxx', product: 'product_xxx' }
      */
+    resources: Record<string, string> | undefined;
+    /** @deprecated Use `resources` instead */
     staticResources: Record<string, string> | undefined;
     /**
      * Get scripts for a specific injection position
@@ -54,6 +55,16 @@ export interface StepConfigValue {
         [TrackingProvider.SNAPCHAT]?: SnapchatTrackingConfig[];
         [TrackingProvider.GTM]?: GTMTrackingConfig[];
     };
+    /**
+     * Enabled order bump offer IDs for this step.
+     * undefined = inherit all store bumps, string[] = only these IDs.
+     */
+    orderBumpOfferIds: string[] | undefined;
+    /**
+     * Enabled upsell offer IDs for this step.
+     * undefined = inherit all store upsells, string[] = only these IDs.
+     */
+    upsellOfferIds: string[] | undefined;
 }
 export interface FunnelContextValue extends FunnelState {
     currentStep: {

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

@@ -14,13 +14,13 @@
  * // In any child component:
  * const { context, next, isLoading, stepConfig } = useFunnel();
  *
- * // Access step-specific config (payment flows, static resources, etc.)
- * const offerId = stepConfig.staticResources?.offer;
+ * // Access step-specific config (payment flows, resources, etc.)
+ * const offerId = stepConfig.resources?.offer;
  * const paymentFlowId = stepConfig.paymentFlowId;
  * ```
  */
 import { useMemo } from 'react';
-import { TrackingProvider, getAssignedPaymentFlowId, getAssignedPixels, getAssignedScripts, getAssignedStaticResources, getAssignedStepConfig } from '../../core/funnelClient';
+import { TrackingProvider, getAssignedOrderBumpOfferIds, getAssignedPaymentFlowId, getAssignedPixels, getAssignedResources, getAssignedScripts, getAssignedStepConfig, getAssignedUpsellOfferIds, } from '../../core/funnelClient';
 import { useTagadaContext } from '../providers/TagadaProvider';
 /**
  * Hook to access funnel state and methods
@@ -35,12 +35,16 @@ export function useFunnel() {
     // Compute step config from HTML injection (memoized, computed once on mount)
     const stepConfig = useMemo(() => {
         const raw = getAssignedStepConfig();
+        const resources = getAssignedResources();
         return {
             raw,
             paymentFlowId: getAssignedPaymentFlowId(),
-            staticResources: getAssignedStaticResources(),
+            resources,
+            staticResources: resources,
             pixels: getAssignedPixels(),
             getScripts: (position) => getAssignedScripts(position),
+            orderBumpOfferIds: getAssignedOrderBumpOfferIds(),
+            upsellOfferIds: getAssignedUpsellOfferIds(),
         };
     }, []);
     return {

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

@@ -1,3 +1,4 @@
+import { TagadaError } from '../../core/errors';
 export interface GeoLocationData {
     ip_address?: string | null;
     city?: string | null;
@@ -82,7 +83,7 @@ export interface UseGeoLocationReturn {
     /**
      * Any error that occurred during the request
      */
-    error: string | null;
+    error: TagadaError | null;
     /**
      * Function to manually fetch geolocation data
      */

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

@@ -1,6 +1,7 @@
 'use client';
-import { useCallback, useEffect, useState } from 'react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
 import { useTagadaContext } from '../providers/TagadaProvider';
+import { TagadaError, TagadaErrorCode } from '../../core/errors';
 /**
  * Hook to fetch and manage geolocation data - V2 Implementation
  * Compatible with V1 interface while using V2 provider architecture
@@ -111,10 +112,11 @@ export function useGeoLocation(options = {}) {
             void fetchGeoData();
         }
     }, [refetchOnMount, apiService, fetchGeoData]);
+    const tagadaError = useMemo(() => error ? new TagadaError(error, { code: TagadaErrorCode.NETWORK_ERROR }) : null, [error]);
     return {
         data,
         isLoading,
-        error,
+        error: tagadaError,
         fetchGeoData,
         clearData,
         isLocalhost: isLocalhost(data?.ip_address),

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

@@ -68,6 +68,8 @@ export interface UseGoogleAutocompleteOptions {
     version?: string;
     language?: string;
     region?: string;
+    /** When true, defer loading the Google Maps script until searchPlaces() is first called. Default: false (eager load). */
+    defer?: boolean;
 }
 export interface UseGoogleAutocompleteResult {
     predictions: GooglePrediction[];

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

@@ -8,7 +8,7 @@ import { useCallback, useEffect, useRef, useState } from 'react';
  * Automatically loads the Google Maps JavaScript API with Places library
  */
 export function useGoogleAutocomplete(options) {
-    const { apiKey, libraries = ['places'], version = 'weekly', language, region } = options;
+    const { apiKey, libraries = ['places'], version = 'weekly', language, region, defer = false } = options;
     const [predictions, setPredictions] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
     const [isScriptLoaded, setIsScriptLoaded] = useState(false);
@@ -16,19 +16,16 @@ export function useGoogleAutocomplete(options) {
     const placesServiceRef = useRef(null);
     const scriptLoadedRef = useRef(false);
     const debounceTimeoutRef = useRef(null);
-    // Inject Google Maps script
-    useEffect(() => {
-        if (!apiKey) {
-            return;
-        }
+    const pendingSearchRef = useRef(null);
+    // Shared script injection logic (used by both eager useEffect and lazy trigger)
+    const injectScript = useCallback(() => {
         if (scriptLoadedRef.current || window.google?.maps) {
             setIsScriptLoaded(true);
+            scriptLoadedRef.current = true;
             return;
         }
-        // Check if script is already being loaded
         const existingScript = document.querySelector('script[src*="maps.googleapis.com"]');
         if (existingScript) {
-            // Wait for existing script to load
             const checkLoaded = () => {
                 if (window.google?.maps?.places?.AutocompleteService) {
                     setIsScriptLoaded(true);
@@ -41,7 +38,6 @@ export function useGoogleAutocomplete(options) {
             checkLoaded();
             return;
         }
-        // Create and inject the script
         const script = document.createElement('script');
         const params = new URLSearchParams({
             key: apiKey,
@@ -63,12 +59,23 @@ export function useGoogleAutocomplete(options) {
             // Failed to load Google Maps API
         };
         document.head.appendChild(script);
-        // Cleanup function
-        return () => {
-            // Note: We don't remove the script as it might be used by other components
-            // The script will remain in the DOM for the session
-        };
     }, [apiKey, libraries, version, language, region]);
+    // Inject Google Maps script eagerly (unless defer is true)
+    useEffect(() => {
+        if (!apiKey || defer) {
+            return;
+        }
+        injectScript();
+    }, [apiKey, defer, injectScript]);
+    // When script finishes loading in deferred mode, replay the pending search
+    const searchPlacesRef = useRef(null);
+    useEffect(() => {
+        if (isScriptLoaded && pendingSearchRef.current && searchPlacesRef.current) {
+            const { input, countryRestriction } = pendingSearchRef.current;
+            pendingSearchRef.current = null;
+            searchPlacesRef.current(input, countryRestriction);
+        }
+    }, [isScriptLoaded]);
     // Initialize Google Places services
     const initializeServices = useCallback(() => {
         if (typeof window === 'undefined')
@@ -89,6 +96,11 @@ export function useGoogleAutocomplete(options) {
     // Search for place predictions
     const searchPlaces = useCallback((input, countryRestriction) => {
         if (!isScriptLoaded) {
+            // When deferred, trigger lazy load and queue the search for replay
+            if (defer && !scriptLoadedRef.current) {
+                pendingSearchRef.current = { input, countryRestriction };
+                injectScript();
+            }
             return;
         }
         if (!initializeServices()) {
@@ -124,7 +136,9 @@ export function useGoogleAutocomplete(options) {
                 }
             });
         }, 300); // 300ms debounce
-    }, [initializeServices, isScriptLoaded]);
+    }, [initializeServices, isScriptLoaded, defer, injectScript]);
+    // Keep ref in sync so the deferred-replay useEffect can call searchPlaces
+    searchPlacesRef.current = searchPlaces;
     // Get detailed place information
     const getPlaceDetails = useCallback((placeId) => {
         return new Promise((resolve) => {

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

@@ -18,11 +18,8 @@ export interface UseISODataResult {
     registeredLanguages: SupportedLanguage[];
 }
 /**
- * React hook for accessing ISO3166 countries and regions data with dynamic language loading
- * @param language - Language code (supports: en, ru, de, fr, es, zh, hi, pt, ja, ar, it, he)
- * @param autoImport - Whether to automatically import the language if not registered (default: true)
- * @param disputeSetting - Territorial dispute perspective (currently only UN is supported)
- * @returns Object with countries data and helper functions
+ * React hook for accessing ISO3166 countries and regions data.
+ * Fetches slim JSON from CDN on first use, then caches in memory.
  */
 export declare function useISOData(language?: SupportedLanguage, autoImport?: boolean, disputeSetting?: string): UseISODataResult;
 /**

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

@@ -1,35 +1,40 @@
 import { useMemo, useEffect, useState, useCallback } from 'react';
-// Import the pre-built ISO data functions
-import { getCountries, getStatesForCountry, importLanguage, isLanguageRegistered, getRegisteredLanguages } from '../../../data/iso3166';
+import { getCountries, getStatesForCountry, ensureGeoDataLoaded, importLanguage, isLanguageRegistered, getRegisteredLanguages } from '../../../data/iso3166';
 /**
- * React hook for accessing ISO3166 countries and regions data with dynamic language loading
- * @param language - Language code (supports: en, ru, de, fr, es, zh, hi, pt, ja, ar, it, he)
- * @param autoImport - Whether to automatically import the language if not registered (default: true)
- * @param disputeSetting - Territorial dispute perspective (currently only UN is supported)
- * @returns Object with countries data and helper functions
+ * React hook for accessing ISO3166 countries and regions data.
+ * Fetches slim JSON from CDN on first use, then caches in memory.
  */
 export function useISOData(language = 'en', autoImport = true, disputeSetting = 'UN') {
     const [isLanguageLoaded, setIsLanguageLoaded] = useState(isLanguageRegistered(language));
     const [registeredLanguages, setRegisteredLanguages] = useState(getRegisteredLanguages);
-    // Auto-import language if not registered and autoImport is true
+    // Fetch geodata from CDN (countries + regions) for the requested language
     useEffect(() => {
-        if (!isLanguageRegistered(language) && autoImport && language !== 'en') {
-            importLanguage(language)
-                .then(() => {
+        let cancelled = false;
+        ensureGeoDataLoaded(language)
+            .then(() => {
+            if (!cancelled) {
                 setIsLanguageLoaded(true);
                 setRegisteredLanguages(getRegisteredLanguages());
-            })
-                .catch((error) => {
-            });
-        }
+            }
+        })
+            .catch((err) => {
+            console.error('[SDK] Failed to load geodata from CDN:', err);
+        });
+        return () => { cancelled = true; };
     }, [language, autoImport]);
     const data = useMemo(() => {
+        if (!isLanguageLoaded) {
+            return {
+                countries: {},
+                getRegions: () => [],
+                findRegion: () => null,
+                mapGoogleToISO: () => null,
+                isLanguageLoaded: false,
+                registeredLanguages,
+            };
+        }
         try {
-            console.log('[SDK] Loading ISO data for language:', language, 'autoImport:', autoImport);
-            // Get countries from pre-built data with language support
             const countriesArray = getCountries(language);
-            console.log('[SDK] Loaded countries count:', countriesArray.length);
-            // Transform to our expected format (Record<string, ISOCountry>)
             const countries = {};
             countriesArray.forEach((country) => {
                 countries[country.code] = {
@@ -39,7 +44,6 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
                     name: country.name,
                 };
             });
-            // Helper to load regions for a specific country
             const getRegions = (countryCode) => {
                 try {
                     const states = getStatesForCountry(countryCode, language);
@@ -49,31 +53,26 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
                     }));
                 }
                 catch {
-                    return []; // Return empty array if no regions
+                    return [];
                 }
             };
-            // Find a specific region by ISO code
             const findRegion = (countryCode, regionCode) => {
                 const regions = getRegions(countryCode);
                 return regions.find((region) => region.iso === regionCode) ?? null;
             };
-            // Map Google Places state to ISO region (proven 100% success rate)
             const mapGoogleToISO = (googleState, googleStateLong, countryCode) => {
                 const regions = getRegions(countryCode);
                 if (regions.length === 0)
                     return null;
-                // Strategy 1: Exact ISO code match (86% success rate)
                 let match = regions.find((r) => r.iso === googleState);
                 if (match)
                     return match;
-                // Strategy 2: Name matching (14% success rate)
                 match = regions.find((r) => r.name.toLowerCase() === googleState.toLowerCase());
                 if (match)
                     return match;
                 match = regions.find((r) => r.name.toLowerCase() === googleStateLong.toLowerCase());
                 if (match)
                     return match;
-                // Strategy 3: Partial name matching (fallback)
                 match = regions.find((r) => r.name.toLowerCase().includes(googleStateLong.toLowerCase()) ||
                     googleStateLong.toLowerCase().includes(r.name.toLowerCase()));
                 return match ?? null;
@@ -106,7 +105,7 @@ export function useISOData(language = 'en', autoImport = true, disputeSetting =
  */
 export function getAvailableLanguages() {
     // Return all available languages (not just registered ones)
-    return ['en', 'ru', 'de', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
+    return ['en', 'ru', 'de', 'da', 'fr', 'es', 'zh', 'hi', 'pt', 'ja', 'ar', 'it', 'he'];
 }
 /**
  * Hook to manually import and register a language

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' | 'radar';
+    requireAction: 'none' | 'redirect' | 'redirect_to_payment' | 'error' | 'radar' | 'stripe_express_checkout';
     requireActionData?: {
-        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar';
+        type: 'redirect' | 'redirect_to_payment' | 'threeds_auth' | 'processor_auth' | 'error' | 'stripe_radar' | 'finix_radar' | 'radar' | 'kesspay_auth' | 'trustflow_auth' | 'mastercard_auth' | 'stripe_express_checkout';
         url?: string;
         processed: boolean;
         processorId?: string;
         metadata?: {
-            type: 'redirect' | 'stripe_radar' | 'finix_radar';
+            type: 'redirect' | 'redirect_to_payment' | 'stripe_radar' | 'finix_radar';
             redirect?: {
                 redirectUrl: string;
                 returnUrl: string;

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

@@ -2,7 +2,8 @@
  * Payment Hook using TanStack Query (V2)
  * Matches the old usePayment.ts implementation exactly for easy migration
  */
-import type { Payment, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse } from '../../core/resources/payments';
+import type { Payment, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, GooglePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse } from '../../core/resources/payments';
+import { TagadaError } from '../../core/errors';
 export type { Payment as PaymentType, PaymentResponse, PaymentOptions, CardPaymentMethod, ApplePayToken, PaymentInstrumentResponse, PaymentInstrumentCustomerResponse, PaymentInstrumentCustomer } from '../../core/resources/payments';
 /**
  * Metadata provided with payment callbacks
@@ -11,7 +12,12 @@ export interface PaymentCompletionMetadata {
     /** True if payment completed after external redirect (3DS, PayPal, etc.) */
     isRedirectReturn: boolean;
     /** Order associated with the payment (if available) */
-    order?: any;
+    order?: {
+        id: string;
+        amount?: number;
+        currency?: string;
+        [key: string]: unknown;
+    };
     /** Checkout session ID (if available) */
     checkoutSessionId?: string;
 }
@@ -37,14 +43,21 @@ export interface UsePaymentOptions {
 export interface PaymentHook {
     processCardPayment: (checkoutSessionId: string, cardData: CardPaymentMethod, options?: PaymentOptions) => Promise<PaymentResponse>;
     processApplePayPayment: (checkoutSessionId: string, applePayToken: ApplePayToken, options?: PaymentOptions) => Promise<PaymentResponse>;
-    processGooglePayPayment: (checkoutSessionId: string, googlePayToken: any, options?: PaymentOptions) => Promise<PaymentResponse>;
+    processGooglePayPayment: (checkoutSessionId: string, googlePayToken: GooglePayToken, options?: PaymentOptions) => Promise<PaymentResponse>;
     processPaymentWithInstrument: (checkoutSessionId: string, paymentInstrumentId: string, options?: PaymentOptions) => Promise<PaymentResponse>;
+    processApmPayment: (checkoutSessionId: string, options: {
+        processorId: string;
+        paymentMethod: string;
+        initiatedBy?: 'customer' | 'merchant';
+        source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+        paymentFlowId?: string;
+    } & Pick<PaymentOptions, 'onFailure' | 'onPaymentFailed' | 'onSuccess' | 'onPaymentSuccess'>) => Promise<PaymentResponse>;
     createCardPaymentInstrument: (cardData: CardPaymentMethod) => Promise<PaymentInstrumentResponse>;
     createApplePayPaymentInstrument: (applePayToken: ApplePayToken) => Promise<PaymentInstrumentResponse>;
-    createGooglePayPaymentInstrument: (googlePayToken: any) => Promise<PaymentInstrumentResponse>;
+    createGooglePayPaymentInstrument: (googlePayToken: GooglePayToken) => Promise<PaymentInstrumentResponse>;
     getCardPaymentInstruments: () => Promise<PaymentInstrumentCustomerResponse>;
     isLoading: boolean;
-    error: string | null;
+    error: TagadaError | null;
     clearError: () => void;
     currentPaymentId: string | null;
 }