@tagadapay/plugin-sdk 2.4.39 → 2.5.2

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

@@ -0,0 +1,150 @@
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import { getBasisTheoryApiKey } from '../../../react/config/payment';
+import { ThreedsResource } from '../../core/resources/threeds';
+import { useThreedsModal } from './useThreedsModal';
+import { getGlobalApiClient } from './useApiQuery';
+export function useThreeds(options = {}) {
+    const { defaultProvider = 'basis_theory' } = options;
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const { createThreedsModal, closeThreedsModal } = useThreedsModal();
+    const [basisTheory3ds, setBasisTheory3ds] = useState(null);
+    const [_currentChallenge, _setCurrentChallenge] = useState(null);
+    // Create threeds resource client
+    const threedsResource = useMemo(() => {
+        try {
+            return new ThreedsResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize threeds resource: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Dynamically import BasisTheory3ds on the client side only
+    useEffect(() => {
+        let isMounted = true;
+        const loadBasisTheory = async () => {
+            try {
+                // Dynamically import the library only on the client side
+                const { BasisTheory3ds } = await import('@basis-theory/web-threeds');
+                if (isMounted) {
+                    setBasisTheory3ds(() => BasisTheory3ds);
+                }
+            }
+            catch (err) {
+                if (isMounted) {
+                    setError(err instanceof Error ? err : new Error('Failed to load 3DS library'));
+                }
+            }
+        };
+        void loadBasisTheory();
+        return () => {
+            isMounted = false;
+        };
+    }, []);
+    // Create a 3DS session with BasisTheory
+    const createBasisTheorySession = useCallback(async (paymentInstrument) => {
+        if (!basisTheory3ds) {
+            throw new Error('BasisTheory3ds not loaded yet');
+        }
+        // Use the same API key approach as the working CMS version
+        const apiKey = getBasisTheoryApiKey('production'); // Use production config for now
+        const bt3ds = basisTheory3ds(apiKey);
+        const session = await bt3ds.createSession({
+            tokenId: paymentInstrument.token,
+        });
+        // Create session through our API
+        const threedsSession = await threedsResource.createSession({
+            provider: 'basis_theory',
+            sessionData: session,
+            paymentInstrumentId: paymentInstrument.id,
+        });
+        return threedsSession;
+    }, [threedsResource, basisTheory3ds]);
+    // Generic createSession method that supports multiple providers
+    const createSession = useCallback(async (paymentInstrument, options) => {
+        const provider = options?.provider || defaultProvider;
+        setIsLoading(true);
+        setError(null);
+        try {
+            let session;
+            if (provider === 'basis_theory') {
+                session = await createBasisTheorySession(paymentInstrument);
+            }
+            else {
+                throw new Error(`Unsupported 3DS provider: ${String(provider)}`);
+            }
+            return session;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to create 3DS session');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [defaultProvider, createBasisTheorySession]);
+    // Start a 3DS challenge with BasisTheory
+    const startBasisTheoryChallenge = useCallback(async (sessionId, acsChallengeUrl, acsTransactionId, threeDSVersion) => {
+        try {
+            if (!basisTheory3ds) {
+                throw new Error('BasisTheory3ds not loaded yet');
+            }
+            // Use the same API key approach as the working CMS version
+            const apiKey = getBasisTheoryApiKey('production'); // Use production config for now
+            if (!apiKey) {
+                throw new Error('BasisTheory API key is not set');
+            }
+            const modal = createThreedsModal({
+                onClose: () => {
+                    // Throw error when user closes the modal
+                    throw new Error('Authentication was cancelled by the user');
+                },
+            });
+            const bt3ds = basisTheory3ds(apiKey);
+            const challengeCompletion = await bt3ds.startChallenge({
+                sessionId,
+                acsChallengeUrl,
+                acsTransactionId,
+                threeDSVersion: threeDSVersion,
+                containerId: modal.containerId + '-content',
+                mode: 'iframe',
+                timeout: 60000 * 3,
+            });
+            closeThreedsModal();
+            return challengeCompletion;
+        }
+        catch (error) {
+            closeThreedsModal();
+            throw error;
+        }
+    }, [basisTheory3ds, createThreedsModal, closeThreedsModal]);
+    // Generic startChallenge method that supports multiple providers
+    const startChallenge = useCallback(async (challengeData, options) => {
+        const provider = options?.provider || defaultProvider;
+        setIsLoading(true);
+        setError(null);
+        try {
+            if (provider === 'basis_theory') {
+                return await startBasisTheoryChallenge(challengeData.sessionId, challengeData.acsChallengeUrl, challengeData.acsTransactionId, challengeData.threeDSVersion);
+            }
+            else {
+                throw new Error(`Unsupported 3DS provider: ${String(provider)}`);
+            }
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to start 3DS challenge');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [defaultProvider, startBasisTheoryChallenge]);
+    return {
+        createSession,
+        startChallenge,
+        isLoading,
+        error,
+    };
+}

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

@@ -0,0 +1,13 @@
+export declare function useThreedsModal(): {
+    createThreedsModal: (options?: {
+        containerId?: string;
+        mode?: "fixed" | "auto-fit";
+        onClose?: () => void;
+    }) => {
+        containerId: string;
+        getContentElement: () => HTMLElement | null;
+        updateModalSize: () => void;
+        cleanup: () => void;
+    };
+    closeThreedsModal: (containerId?: string) => void;
+};

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

@@ -0,0 +1,343 @@
+'use client';
+import { useCallback } from 'react';
+export function useThreedsModal() {
+    // Close the 3DS modal
+    const closeThreedsModal = useCallback((containerId = 'threedscontainer') => {
+        const container = document.getElementById(containerId);
+        const backdrop = document.getElementById(`${containerId}-backdrop`);
+        if (container && backdrop) {
+            // Animate out
+            container.style.transform = 'scale(0.95)';
+            container.style.opacity = '0';
+            backdrop.style.opacity = '0';
+            setTimeout(() => {
+                if (backdrop && document.body.contains(backdrop)) {
+                    document.body.removeChild(backdrop);
+                }
+                // Remove escape key listener
+                document.removeEventListener('keydown', (e) => {
+                    if (e.key === 'Escape')
+                        closeThreedsModal(containerId);
+                });
+            }, 300);
+        }
+    }, []);
+    // Create and open a modal for 3DS authentication
+    const createThreedsModal = useCallback((options = {}) => {
+        const { containerId = 'threedscontainer', mode = 'auto-fit', onClose } = options;
+        // Remove any existing modal first
+        const existingContainer = document.getElementById(containerId);
+        const existingBackdrop = document.getElementById(`${containerId}-backdrop`);
+        if (existingContainer)
+            document.body.removeChild(existingContainer);
+        if (existingBackdrop)
+            document.body.removeChild(existingBackdrop);
+        // Create backdrop
+        const backdrop = document.createElement('div');
+        backdrop.id = `${containerId}-backdrop`;
+        Object.assign(backdrop.style, {
+            position: 'fixed',
+            top: '0',
+            left: '0',
+            width: '100%',
+            height: '100%',
+            backgroundColor: 'rgba(0, 0, 0, 0.6)',
+            zIndex: '9998',
+            display: 'flex',
+            justifyContent: 'center',
+            alignItems: 'center', // Default to center alignment
+            transition: 'opacity 0.3s ease',
+            opacity: '0', // Start transparent
+        });
+        // Create modal container
+        const container = document.createElement('div');
+        container.id = containerId;
+        // Check if mobile initially
+        let isMobile = window.innerWidth < 768;
+        // Base styles for both modes
+        const baseStyles = {
+            position: 'relative',
+            backgroundColor: 'white',
+            borderRadius: '12px', // Default border radius
+            boxShadow: '0 10px 25px rgba(0, 0, 0, 0.2)',
+            maxWidth: '100%',
+            overflow: 'hidden',
+            zIndex: '9999',
+            transition: 'transform 0.3s ease, opacity 0.3s ease, width 0.3s ease, height 0.3s ease',
+            transform: 'scale(0.95)',
+            opacity: '0',
+        };
+        // Function to apply styles based on screen size and mode
+        const applyResponsiveStyles = () => {
+            isMobile = window.innerWidth < 768;
+            // Always ensure backdrop is properly centered
+            backdrop.style.alignItems = 'center';
+            backdrop.style.justifyContent = 'center';
+            if (mode === 'fixed') {
+                if (isMobile) {
+                    // Full screen modal for mobile
+                    Object.assign(container.style, {
+                        ...baseStyles,
+                        position: 'fixed',
+                        top: '0',
+                        left: '0',
+                        right: '0',
+                        bottom: '0',
+                        width: '100%',
+                        height: '100%',
+                        borderRadius: '0', // No border radius for full screen
+                        margin: '0',
+                        backgroundColor: 'white',
+                        transform: 'scale(0.95)',
+                        opacity: '0',
+                        maxHeight: '100%',
+                    });
+                }
+                else {
+                    // Desktop styles
+                    Object.assign(container.style, {
+                        ...baseStyles,
+                        width: '550px',
+                        height: '600px',
+                        maxHeight: '85vh',
+                        position: 'relative',
+                        borderRadius: '12px',
+                        margin: 'auto',
+                        backgroundColor: 'white',
+                        transform: 'scale(0.95)',
+                        opacity: '0',
+                    });
+                }
+            }
+            else {
+                // auto-fit mode
+                if (isMobile) {
+                    // Full screen modal for mobile
+                    Object.assign(container.style, {
+                        ...baseStyles,
+                        position: 'fixed',
+                        top: '0',
+                        left: '0',
+                        right: '0',
+                        bottom: '0',
+                        width: '100%',
+                        height: '100%',
+                        borderRadius: '0', // No border radius for full screen
+                        margin: '0',
+                        backgroundColor: 'white',
+                        transform: 'scale(0.95)',
+                        opacity: '0',
+                        maxHeight: '100%',
+                    });
+                }
+                else {
+                    // Desktop styles
+                    Object.assign(container.style, {
+                        ...baseStyles,
+                        width: '550px',
+                        maxHeight: '85vh',
+                        height: 'auto',
+                        minHeight: '250px',
+                        position: 'relative',
+                        borderRadius: '12px',
+                        margin: 'auto',
+                        backgroundColor: 'white',
+                        transform: 'scale(0.95)',
+                        opacity: '0',
+                    });
+                }
+            }
+        };
+        // Apply initial styles
+        applyResponsiveStyles();
+        // Create header
+        const header = document.createElement('div');
+        Object.assign(header.style, {
+            padding: '16px 20px',
+            borderBottom: '1px solid #eaeaea',
+            display: 'flex',
+            justifyContent: 'space-between',
+            alignItems: 'center',
+            backgroundColor: 'white',
+        });
+        // Add title
+        const title = document.createElement('h3');
+        title.textContent = 'Secure Authentication';
+        Object.assign(title.style, {
+            margin: '0',
+            fontSize: '18px',
+            fontWeight: '600',
+            color: '#333',
+        });
+        // Add close button
+        const closeButton = document.createElement('button');
+        closeButton.innerHTML = '&times;';
+        Object.assign(closeButton.style, {
+            background: 'none',
+            border: 'none',
+            fontSize: '24px',
+            cursor: 'pointer',
+            color: '#666',
+            padding: '0 5px',
+            lineHeight: '1',
+        });
+        // Create content area
+        const content = document.createElement('div');
+        content.id = `${containerId}-content`;
+        // Function to update content styles based on mode and screen size
+        const updateContentStyles = () => {
+            if (mode === 'fixed') {
+                Object.assign(content.style, {
+                    height: isMobile ? 'calc(100% - 60px)' : 'calc(100% - 60px)',
+                    width: '100%',
+                    overflow: 'hidden',
+                    backgroundColor: 'white',
+                });
+            }
+            else {
+                // auto-fit mode
+                if (isMobile) {
+                    Object.assign(content.style, {
+                        width: '100%',
+                        height: 'calc(100% - 60px)',
+                        overflow: 'auto',
+                        padding: '16px',
+                        backgroundColor: 'white',
+                    });
+                }
+                else {
+                    Object.assign(content.style, {
+                        width: '100%',
+                        overflow: 'auto',
+                        padding: '20px',
+                        maxHeight: 'calc(85vh - 60px)',
+                        backgroundColor: 'white',
+                    });
+                }
+            }
+        };
+        // Apply initial content styles
+        updateContentStyles();
+        // Update close handlers to call onClose callback
+        const handleClose = () => {
+            onClose?.();
+            closeThreedsModal(containerId);
+        };
+        // Update event listeners
+        closeButton.onclick = handleClose;
+        backdrop.onclick = (e) => {
+            if (e.target === backdrop) {
+                handleClose();
+            }
+        };
+        // Update escape key listener
+        const escKeyHandler = (e) => {
+            if (e.key === 'Escape') {
+                handleClose();
+            }
+        };
+        document.addEventListener('keydown', escKeyHandler);
+        // Assemble the modal
+        header.appendChild(title);
+        header.appendChild(closeButton);
+        container.appendChild(header);
+        container.appendChild(content);
+        backdrop.appendChild(container);
+        document.body.appendChild(backdrop);
+        // Animate in with a slight delay to ensure proper rendering
+        setTimeout(() => {
+            backdrop.style.opacity = '1';
+            container.style.transform = 'scale(1)';
+            container.style.opacity = '1';
+        }, 50);
+        // Function to adjust height in auto-fit mode
+        const adjustAutoFitHeight = () => {
+            if (!content)
+                return;
+            if (isMobile) {
+                // On mobile, we're using full screen so just ensure content scrolls
+                content.style.height = 'calc(100% - 60px)';
+                content.style.overflowY = 'auto';
+            }
+            else {
+                const viewportHeight = window.innerHeight;
+                const contentHeight = content.scrollHeight;
+                const headerHeight = header.offsetHeight;
+                const maxModalHeight = viewportHeight * 0.85;
+                if (contentHeight + headerHeight < maxModalHeight) {
+                    // Content fits, let it determine the height
+                    container.style.height = 'auto';
+                    content.style.overflowY = 'visible';
+                }
+                else {
+                    // Content is too large, cap the height
+                    container.style.height = `${maxModalHeight}px`;
+                    content.style.height = `${maxModalHeight - headerHeight}px`;
+                    content.style.overflowY = 'auto';
+                }
+            }
+        };
+        // Handle window resize
+        const handleResize = () => {
+            // Store current opacity values before applying new styles
+            const currentOpacity = container.style.opacity;
+            const currentTransform = container.style.transform;
+            applyResponsiveStyles();
+            updateContentStyles();
+            // Restore opacity and transform to maintain visibility
+            container.style.opacity = currentOpacity;
+            container.style.transform = currentTransform;
+            // For auto-fit mode, also adjust the height
+            if (mode === 'auto-fit') {
+                adjustAutoFitHeight();
+            }
+        };
+        // Set up mutation observer to detect content changes
+        const contentObserver = new MutationObserver((mutations) => {
+            // When content changes, adjust the height
+            if (mode === 'auto-fit') {
+                // Small delay to ensure content has rendered
+                setTimeout(adjustAutoFitHeight, 50);
+            }
+        });
+        // Configure and start the mutation observer
+        contentObserver.observe(content, {
+            childList: true, // Watch for changes to child elements
+            subtree: true, // Watch the entire subtree
+            characterData: true, // Watch for changes to text content
+            attributes: true, // Watch for changes to attributes
+        });
+        // For auto-fit mode, set up resize observer for content element
+        let resizeObserver = null;
+        if (mode === 'auto-fit') {
+            resizeObserver = new ResizeObserver(() => {
+                adjustAutoFitHeight();
+            });
+            resizeObserver.observe(content);
+        }
+        // Add window resize listener
+        window.addEventListener('resize', handleResize);
+        // Create a function to manually trigger height adjustment
+        const updateModalSize = () => {
+            if (mode === 'auto-fit') {
+                adjustAutoFitHeight();
+            }
+        };
+        return {
+            containerId,
+            getContentElement: () => document.getElementById(`${containerId}-content`),
+            updateModalSize, // Expose function to manually update size
+            cleanup: () => {
+                window.removeEventListener('resize', handleResize);
+                if (resizeObserver) {
+                    resizeObserver.disconnect();
+                }
+                contentObserver.disconnect();
+            },
+        };
+    }, [closeThreedsModal]);
+    return {
+        createThreedsModal,
+        closeThreedsModal,
+    };
+}

package/dist/v2/react/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * React hooks and components for TagadaPay Plugin SDK v2
+ * Uses core functions for business logic
+ */
+export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
+export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { usePluginConfig } from './hooks/usePluginConfig';
+export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
+export { useGeoLocation } from './hooks/useGeoLocation';
+export { useISOData, getAvailableLanguages, useLanguageImport, useCountryOptions, useRegionOptions } from './hooks/useISOData';
+export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
+export { useOrderBumpQuery as useOrderBump } from './hooks/useOrderBumpQuery';
+export { usePromotionsQuery as usePromotions } from './hooks/usePromotionsQuery';
+export { useProductsQuery as useProducts } from './hooks/useProductsQuery';
+export { useOrderQuery as useOrder } from './hooks/useOrderQuery';
+export { usePostPurchasesQuery as usePostPurchases } from './hooks/usePostPurchasesQuery';
+export { useOffersQuery as useOffers } from './hooks/useOffersQuery';
+export { usePaymentQuery as usePayment } from './hooks/usePaymentQuery';
+export { useThreeds } from './hooks/useThreeds';
+export { useThreedsModal } from './hooks/useThreedsModal';
+export { useCurrency } from './hooks/useCurrency';
+export { useApiQuery, useApiMutation, useInvalidateQuery, usePreloadQuery, queryKeys } from './hooks/useApiQuery';
+export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
+export type { UsePluginConfigOptions, UsePluginConfigResult } from './hooks/usePluginConfig';
+export type { UseGoogleAutocompleteOptions, UseGoogleAutocompleteResult, GooglePrediction, GooglePlaceDetails, ExtractedAddress } from './hooks/useGoogleAutocomplete';
+export type { UseGeoLocationOptions, UseGeoLocationReturn, GeoLocationData } from './hooks/useGeoLocation';
+export type { UseISODataResult, ISOCountry, ISORegion } from './hooks/useISOData';
+export type { UseCheckoutQueryOptions as UseCheckoutOptions, UseCheckoutQueryResult as UseCheckoutResult } from './hooks/useCheckoutQuery';
+export type { UseOrderBumpQueryOptions as UseOrderBumpOptions, UseOrderBumpQueryResult as UseOrderBumpResult } from './hooks/useOrderBumpQuery';
+export type { UsePromotionsQueryOptions as UsePromotionsOptions, UsePromotionsQueryResult as UsePromotionsResult } from './hooks/usePromotionsQuery';
+export type { UseProductsQueryOptions as UseProductsOptions, UseProductsQueryResult as UseProductsResult } from './hooks/useProductsQuery';
+export type { UseOrderQueryOptions as UseOrderOptions, UseOrderQueryResult as UseOrderResult } from './hooks/useOrderQuery';
+export type { UsePostPurchasesQueryOptions as UsePostPurchasesOptions, UsePostPurchasesQueryResult as UsePostPurchasesResult } from './hooks/usePostPurchasesQuery';
+export type { UseOffersQueryOptions as UseOffersOptions, UseOffersQueryResult as UseOffersResult } from './hooks/useOffersQuery';
+export type { PaymentHook as UsePaymentResult } from './hooks/usePaymentQuery';
+export type { ThreedsProvider, PaymentInstrument, ThreedsSession, ThreedsChallenge, ThreedsOptions, ThreedsHook } from './hooks/useThreeds';
+export { formatMoney } from '../../react/utils/money';
+export type OrderItem = import('../core/utils/order').OrderLineItem;

package/dist/v2/react/index.js

@@ -0,0 +1,27 @@
+/**
+ * React hooks and components for TagadaPay Plugin SDK v2
+ * Uses core functions for business logic
+ */
+// Provider
+export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
+// Hooks
+export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { usePluginConfig } from './hooks/usePluginConfig';
+export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
+export { useGeoLocation } from './hooks/useGeoLocation';
+export { useISOData, getAvailableLanguages, useLanguageImport, useCountryOptions, useRegionOptions } from './hooks/useISOData';
+// TanStack Query hooks (recommended)
+export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
+export { useOrderBumpQuery as useOrderBump } from './hooks/useOrderBumpQuery';
+export { usePromotionsQuery as usePromotions } from './hooks/usePromotionsQuery';
+export { useProductsQuery as useProducts } from './hooks/useProductsQuery';
+export { useOrderQuery as useOrder } from './hooks/useOrderQuery';
+export { usePostPurchasesQuery as usePostPurchases } from './hooks/usePostPurchasesQuery';
+export { useOffersQuery as useOffers } from './hooks/useOffersQuery';
+export { usePaymentQuery as usePayment } from './hooks/usePaymentQuery';
+export { useThreeds } from './hooks/useThreeds';
+export { useThreedsModal } from './hooks/useThreedsModal';
+export { useCurrency } from './hooks/useCurrency';
+export { useApiQuery, useApiMutation, useInvalidateQuery, usePreloadQuery, queryKeys } from './hooks/useApiQuery';
+// Re-export utilities from main react
+export { formatMoney } from '../../react/utils/money';

package/dist/v2/react/providers/TagadaProvider.d.ts

@@ -0,0 +1,63 @@
+/**
+ * TagadaProvider - Main provider component for the Tagada Pay React SDK
+ */
+import { ReactNode } from 'react';
+import { PluginConfig, RawPluginConfig } from '../../../react/hooks/usePluginConfig';
+import { ApiService } from '../../../react/services/apiService';
+import { AuthState, Currency, Customer, Environment, EnvironmentConfig, Locale, Session, Store } from '../../../react/types';
+import { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits } from '../../../react/utils/money';
+interface TagadaContextValue {
+    auth: AuthState;
+    session: Session | null;
+    customer: Customer | null;
+    locale: Locale;
+    currency: Currency;
+    store: Store | null;
+    environment: EnvironmentConfig;
+    apiService: ApiService;
+    isLoading: boolean;
+    isInitialized: boolean;
+    isSessionInitialized: boolean;
+    debugMode: boolean;
+    pluginConfig: PluginConfig;
+    pluginConfigLoading: boolean;
+    debugCheckout: {
+        isActive: boolean;
+        data: any;
+        error: Error | null;
+        isLoading: boolean;
+        lastUpdated: Date | null;
+    };
+    updateCheckoutDebugData: (data: any, error?: Error | null, isLoading?: boolean) => void;
+    refreshCoordinator: {
+        registerCheckoutRefresh: (refreshFn: () => Promise<void>, name?: string) => void;
+        registerOrderBumpRefresh: (refreshFn: () => Promise<void>) => void;
+        notifyCheckoutChanged: () => Promise<void>;
+        notifyOrderBumpChanged: () => Promise<void>;
+        unregisterCheckoutRefresh: (refreshFn?: () => Promise<void>) => void;
+        unregisterOrderBumpRefresh: () => void;
+    };
+    money: {
+        formatMoney: typeof formatMoney;
+        getCurrencyInfo: typeof getCurrencyInfo;
+        moneyStringOrNumberToMinorUnits: typeof moneyStringOrNumberToMinorUnits;
+        minorUnitsToMajorUnits: typeof minorUnitsToMajorUnits;
+        formatMoneyWithoutSymbol: typeof formatMoneyWithoutSymbol;
+        convertCurrency: typeof convertCurrency;
+        formatSimpleMoney: typeof formatSimpleMoney;
+    };
+}
+interface TagadaProviderProps {
+    children: ReactNode;
+    environment?: Environment;
+    customApiConfig?: Partial<EnvironmentConfig>;
+    debugMode?: boolean;
+    localConfig?: string;
+    blockUntilSessionReady?: boolean;
+    rawPluginConfig?: RawPluginConfig;
+}
+export declare function TagadaProvider({ children, environment, customApiConfig, debugMode, // Remove default, will be set based on environment
+localConfig, blockUntilSessionReady, // Default to new non-blocking behavior
+rawPluginConfig, }: TagadaProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useTagadaContext(): TagadaContextValue;
+export {};