@tagadapay/plugin-sdk 3.0.3 → 3.0.9

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

@@ -0,0 +1,290 @@
+/**
+ * usePreviewOffer - Lightweight offer preview without checkout sessions
+ *
+ * This hook provides a fast, client-side offer preview by:
+ * 1. Fetching offer data with pre-computed summaries
+ * 2. Allowing variant/quantity selection
+ * 3. Recalculating totals on-the-fly without backend calls
+ * 4. NO checkout session creation - perfect for browsing/previewing
+ */
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { OffersResource } from '../../core/resources/offers';
+import { getGlobalApiClient } from './useApiQuery';
+export function usePreviewOffer(options) {
+    const { offerId, currency: requestedCurrency = 'USD', initialSelections = {} } = options;
+    const offersResource = useMemo(() => new OffersResource(getGlobalApiClient()), []);
+    // Track user selections (variant + quantity per product)
+    const [selections, setSelections] = useState(initialSelections);
+    const [isPaying, setIsPaying] = useState(false);
+    // Build lineItems array for API call
+    const lineItemsForPreview = useMemo(() => {
+        if (Object.keys(selections).length === 0)
+            return undefined;
+        return Object.values(selections).map((selection) => {
+            const item = {
+                variantId: selection.variantId,
+                quantity: selection.quantity,
+            };
+            // Include lineItemId for precise matching
+            if (selection.lineItemId) {
+                item.lineItemId = selection.lineItemId;
+            }
+            return item;
+        });
+    }, [selections]);
+    // 🎯 ONE API CALL - Fetch offer + preview in one request
+    const { data, isLoading, isFetching, error } = useQuery({
+        queryKey: ['offer-preview', offerId, requestedCurrency, lineItemsForPreview],
+        queryFn: async () => {
+            console.log('🔍 [usePreviewOffer] Fetching preview:', {
+                offerId,
+                currency: requestedCurrency,
+                lineItems: lineItemsForPreview,
+            });
+            const result = await offersResource.previewOffer(offerId, requestedCurrency, lineItemsForPreview);
+            console.log('✅ [usePreviewOffer] Preview result:', result);
+            // Extract offer and preview from unified response
+            const offer = result.offer || null;
+            const preview = result.preview || result; // Backwards compatibility
+            // Transform preview to expected format
+            const summary = {
+                items: (preview.items || []).map((item) => ({
+                    id: item.id,
+                    productId: item.productId,
+                    variantId: item.variantId,
+                    priceId: item.priceId,
+                    productName: item.product?.name || item.orderLineItemProduct?.name || '',
+                    variantName: item.variant?.name || item.orderLineItemVariant?.name || '',
+                    imageUrl: item.variant?.imageUrl || item.orderLineItemVariant?.imageUrl || null,
+                    quantity: item.quantity,
+                    unitAmount: item.unitAmount,
+                    amount: item.amount,
+                    adjustedAmount: item.adjustedAmount,
+                    currency: item.currency,
+                })),
+                totalAmount: preview.totalAmount || 0,
+                totalAdjustedAmount: preview.totalAdjustedAmount || 0,
+                totalPromotionAmount: preview.totalPromotionAmount || 0,
+                currency: preview.currency || requestedCurrency,
+                options: preview.options || {},
+            };
+            return { offer, summary };
+        },
+        enabled: !!offerId,
+        staleTime: 0, // Always refetch, no cache
+        gcTime: 5000, // Keep in cache for 5s during transitions
+        placeholderData: (previousData) => previousData, // Keep previous data during refetch
+        refetchOnMount: 'always', // Always refetch on mount
+        retry: false, // Don't retry on error
+        retryOnMount: false,
+    });
+    const offer = data?.offer || null;
+    const summary = data?.summary || null;
+    // Initialize selections from preview response on first load
+    useEffect(() => {
+        if (summary && Object.keys(selections).length === 0) {
+            const initialSelections = {};
+            summary.items.forEach((item) => {
+                // Use lineItemId as key to support same product with different variants
+                initialSelections[item.id] = {
+                    lineItemId: item.id,
+                    variantId: item.variantId,
+                    quantity: item.quantity,
+                    priceId: item.priceId,
+                };
+            });
+            console.log('🎬 [usePreviewOffer] Initialized selections:', initialSelections);
+            setSelections(initialSelections);
+        }
+    }, [summary, selections]);
+    console.log('🎁 [usePreviewOffer] State:', {
+        offerId,
+        isLoading,
+        isFetching,
+        hasData: !!data,
+        hasOffer: !!offer,
+        hasSummary: !!summary,
+        selectionsCount: Object.keys(selections).length,
+        error: error?.message,
+    });
+    // ===== Precise methods (by lineItemId) =====
+    // Select a variant for a specific line item
+    const selectVariant = useCallback((lineItemId, variantId) => {
+        const item = summary?.items.find((i) => i.id === lineItemId);
+        if (!item)
+            return;
+        const variants = summary?.options?.[item.productId];
+        if (!variants)
+            return;
+        const selectedVariant = variants.find((v) => (v.id || v.variantId) === variantId);
+        if (!selectedVariant)
+            return;
+        const priceId = selectedVariant.prices?.[0]?.id;
+        setSelections(prev => ({
+            ...prev,
+            [lineItemId]: {
+                lineItemId,
+                variantId,
+                quantity: prev[lineItemId]?.quantity || item.quantity,
+                priceId,
+            },
+        }));
+    }, [summary]);
+    // Update quantity for a specific line item
+    const updateQuantity = useCallback((lineItemId, quantity) => {
+        if (quantity < 1)
+            return;
+        const item = summary?.items.find((i) => i.id === lineItemId);
+        if (!item)
+            return;
+        setSelections(prev => ({
+            ...prev,
+            [lineItemId]: {
+                lineItemId,
+                variantId: prev[lineItemId]?.variantId || item.variantId,
+                quantity,
+                priceId: prev[lineItemId]?.priceId || item.priceId,
+            },
+        }));
+    }, [summary]);
+    // ===== Simple methods (by productId - affects all items with this product) =====
+    // Select a variant for all line items with this product
+    const selectVariantByProduct = useCallback((productId, variantId) => {
+        if (!summary?.options?.[productId])
+            return;
+        const variants = summary.options[productId];
+        const selectedVariant = variants.find((v) => (v.id || v.variantId) === variantId);
+        if (!selectedVariant)
+            return;
+        const priceId = selectedVariant.prices?.[0]?.id;
+        setSelections(prev => {
+            const updated = { ...prev };
+            // Update all line items with this productId
+            summary.items.forEach((item) => {
+                if (item.productId === productId) {
+                    updated[item.id] = {
+                        lineItemId: item.id,
+                        variantId,
+                        quantity: prev[item.id]?.quantity || item.quantity,
+                        priceId,
+                    };
+                }
+            });
+            return updated;
+        });
+    }, [summary]);
+    // Update quantity for all line items with this product
+    const updateQuantityByProduct = useCallback((productId, quantity) => {
+        if (quantity < 1)
+            return;
+        setSelections(prev => {
+            const updated = { ...prev };
+            // Update all line items with this productId
+            summary?.items.forEach((item) => {
+                if (item.productId === productId) {
+                    updated[item.id] = {
+                        lineItemId: item.id,
+                        variantId: prev[item.id]?.variantId || item.variantId,
+                        quantity,
+                        priceId: prev[item.id]?.priceId || item.priceId,
+                    };
+                }
+            });
+            return updated;
+        });
+    }, [summary]);
+    // Get available variants for a product
+    const getAvailableVariants = useCallback((productId) => {
+        if (!summary?.options?.[productId])
+            return [];
+        const currentItem = summary.items.find((i) => i.productId === productId);
+        const activePriceId = currentItem?.priceId;
+        const currency = summary.currency || requestedCurrency;
+        return summary.options[productId].map((variant) => {
+            // Find matching price or use first
+            let unitAmount = 0;
+            if (activePriceId && variant.prices) {
+                const matchingPrice = variant.prices.find((p) => p.id === activePriceId);
+                if (matchingPrice?.currencyOptions?.[currency]) {
+                    unitAmount = matchingPrice.currencyOptions[currency].amount;
+                }
+            }
+            // Fallback to first price
+            if (unitAmount === 0 && variant.prices?.[0]?.currencyOptions?.[currency]) {
+                unitAmount = variant.prices[0].currencyOptions[currency].amount;
+            }
+            return {
+                variantId: variant.id || variant.variantId,
+                variantName: variant.name || variant.variantName,
+                imageUrl: variant.imageUrl,
+                unitAmount,
+                currency,
+            };
+        });
+    }, [summary, requestedCurrency]);
+    // Pay for the offer with current selections
+    const pay = useCallback(async (mainOrderId) => {
+        if (isPaying) {
+            throw new Error('Payment already in progress');
+        }
+        setIsPaying(true);
+        try {
+            const result = await offersResource.payPreviewedOffer(offerId, requestedCurrency, lineItemsForPreview, typeof window !== 'undefined' ? window.location.href : undefined, mainOrderId);
+            console.log('[usePreviewOffer] Payment initiated:', result);
+            return {
+                checkoutUrl: result.checkout.checkoutUrl,
+            };
+        }
+        catch (error) {
+            console.error('[usePreviewOffer] Payment failed:', error);
+            throw error;
+        }
+        finally {
+            setIsPaying(false);
+        }
+    }, [offerId, requestedCurrency, lineItemsForPreview, offersResource, isPaying]);
+    // Create checkout session without paying (for landing pages)
+    const toCheckout = useCallback(async (mainOrderId) => {
+        if (isPaying) {
+            throw new Error('Operation already in progress');
+        }
+        setIsPaying(true);
+        try {
+            const result = await offersResource.toCheckout(offerId, requestedCurrency, lineItemsForPreview, typeof window !== 'undefined' ? window.location.href : undefined, mainOrderId);
+            console.log('[usePreviewOffer] Checkout session created:', result);
+            return {
+                checkoutSessionId: result.checkoutSessionId,
+                checkoutToken: result.checkoutToken,
+                checkoutUrl: result.checkoutUrl,
+            };
+        }
+        catch (error) {
+            console.error('[usePreviewOffer] Checkout creation failed:', error);
+            throw error;
+        }
+        finally {
+            setIsPaying(false);
+        }
+    }, [offerId, requestedCurrency, lineItemsForPreview, offersResource, isPaying]);
+    return {
+        offer,
+        isLoading,
+        isFetching,
+        isPaying,
+        error: error,
+        summary,
+        selections,
+        // Precise methods
+        selectVariant,
+        updateQuantity,
+        // Simple methods
+        selectVariantByProduct,
+        updateQuantityByProduct,
+        // Helpers
+        getAvailableVariants,
+        // Payment
+        pay,
+        toCheckout,
+    };
+}

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

@@ -47,7 +47,7 @@ export function useThreeds(options = {}) {
             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 apiKey = getBasisTheoryApiKey(); // Auto-detects environment
         const bt3ds = basisTheory3ds(apiKey);
         const session = await bt3ds.createSession({
             tokenId: paymentInstrument.token,
@@ -91,7 +91,7 @@ export function useThreeds(options = {}) {
                 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 apiKey = getBasisTheoryApiKey(); // Auto-detects environment
             if (!apiKey) {
                 throw new Error('BasisTheory API key is not set');
             }

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

@@ -27,6 +27,7 @@ export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
 export { useCurrency } from './hooks/useCurrency';
 export { useDiscountsQuery as useDiscounts } from './hooks/useDiscountsQuery';
 export { useOfferQuery as useOffer } from './hooks/useOfferQuery';
+export { usePreviewOffer } from './hooks/usePreviewOffer';
 export { useOrderBumpQuery as useOrderBump } from './hooks/useOrderBumpQuery';
 export { useOrderQuery as useOrder } from './hooks/useOrderQuery';
 export { usePaymentQuery as usePayment } from './hooks/usePaymentQuery';
@@ -64,6 +65,7 @@ export type { FunnelAction, FunnelNavigationAction, FunnelNavigationResult, Simp
 export type { FunnelContextValue } from './hooks/useFunnel';
 export type { UseFunnelOptions as UseFunnelLegacyOptions, UseFunnelResult as UseFunnelLegacyResult } from './hooks/useFunnelLegacy';
 export type { AvailableVariant, LineItemSelection, OfferLineItem, OfferPreviewSummary, UseOfferQueryOptions as UseOfferOptions, UseOfferQueryResult as UseOfferResult } from './hooks/useOfferQuery';
+export type { PreviewOfferSummary, UsePreviewOfferOptions, UsePreviewOfferResult } from './hooks/usePreviewOffer';
 export type { UseOrderBumpQueryOptions as UseOrderBumpOptions, UseOrderBumpQueryResult as UseOrderBumpResult } from './hooks/useOrderBumpQuery';
 export type { UseOrderQueryOptions as UseOrderOptions, UseOrderQueryResult as UseOrderResult } from './hooks/useOrderQuery';
 export type { PaymentHook as UsePaymentResult } from './hooks/usePaymentQuery';

package/dist/v2/react/index.js

@@ -30,6 +30,7 @@ export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
 export { useCurrency } from './hooks/useCurrency';
 export { useDiscountsQuery as useDiscounts } from './hooks/useDiscountsQuery';
 export { useOfferQuery as useOffer } from './hooks/useOfferQuery';
+export { usePreviewOffer } from './hooks/usePreviewOffer';
 export { useOrderBumpQuery as useOrderBump } from './hooks/useOrderBumpQuery';
 export { useOrderQuery as useOrder } from './hooks/useOrderQuery';
 export { usePaymentQuery as usePayment } from './hooks/usePaymentQuery';

package/dist/v2/react/providers/TagadaProvider.js

@@ -4,7 +4,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  * TagadaProvider - Main provider component for the Tagada Pay React SDK
  */
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
+import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from 'react';
 import { ApiService } from '../../../react/services/apiService';
 import { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits, } from '../../../react/utils/money';
 import { TagadaClient } from '../../core/client';
@@ -51,6 +51,9 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
             (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development');
     // Initialize client
     const client = useMemo(() => {
+        // Merge features with defaults, ensuring autoRedirect is always false in provider
+        const mergedFeatures = features ?? { funnel: true };
+        const funnelFeature = mergedFeatures.funnel;
         const config = {
             environment,
             customApiConfig,
@@ -58,9 +61,21 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
             localConfig,
             rawPluginConfig,
             blockUntilSessionReady,
-            // For now we always enable funnel by default; callers can disable via features if needed
-            features: features ?? {
-                funnel: true,
+            features: {
+                ...mergedFeatures,
+                funnel: typeof funnelFeature === 'object'
+                    ? {
+                        ...funnelFeature,
+                        // Always disable auto-redirect in core because we handle it in the provider
+                        // to set pendingRedirect state and prevent UI flashes
+                        autoRedirect: false,
+                    }
+                    : funnelFeature === false
+                        ? false
+                        : {
+                            // Default: enable funnel with auto-redirect disabled
+                            autoRedirect: false,
+                        },
             },
         };
         return new TagadaClient(config);
@@ -70,6 +85,17 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
     useEffect(() => {
         return client.subscribe(setState);
     }, [client]);
+    // Listen for config hot-reload updates
+    useEffect(() => {
+        const cleanup = client.bus.on('CONFIG_UPDATED', () => {
+            // Force re-render when config is updated
+            setState(client.getState());
+            if (state.debugMode) {
+                console.log('[TagadaProvider] Config updated, re-rendering...');
+            }
+        });
+        return cleanup;
+    }, [client, state.debugMode]);
     // Cleanup client on unmount
     useEffect(() => {
         return () => {
@@ -151,39 +177,29 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
             lastUpdated: new Date(),
         });
     }, []);
-    // Refresh Coordinator
-    const checkoutRefreshRefs = useRef(new Set());
-    const orderBumpRefreshRefs = useRef(new Set());
+    // Refresh Coordinator (backed by EventBus in core)
     const refreshCoordinator = useMemo(() => ({
         registerCheckoutRefresh: (refreshFn, name) => {
-            checkoutRefreshRefs.current.add(refreshFn);
+            client.bus.on('CHECKOUT_REFRESH', refreshFn);
         },
         registerOrderBumpRefresh: (refreshFn) => {
-            orderBumpRefreshRefs.current.add(refreshFn);
+            client.bus.on('ORDER_BUMP_REFRESH', refreshFn);
         },
         notifyCheckoutChanged: async () => {
-            if (orderBumpRefreshRefs.current.size > 0) {
-                await Promise.all(Array.from(orderBumpRefreshRefs.current).map((fn) => fn().catch(console.warn)));
-            }
+            await client.bus.emit('ORDER_BUMP_REFRESH'); // Notify bumps that checkout changed? Wait logic
         },
         notifyOrderBumpChanged: async () => {
-            if (checkoutRefreshRefs.current.size > 0) {
-                await Promise.all(Array.from(checkoutRefreshRefs.current).map((fn) => fn().catch(console.warn)));
-            }
+            await client.bus.emit('CHECKOUT_REFRESH'); // Notify checkout that bumps changed
         },
         unregisterCheckoutRefresh: (refreshFn) => {
             if (refreshFn)
-                checkoutRefreshRefs.current.delete(refreshFn);
-            else
-                checkoutRefreshRefs.current.clear();
+                client.bus.off('CHECKOUT_REFRESH', refreshFn);
         },
         unregisterOrderBumpRefresh: (refreshFn) => {
             if (refreshFn)
-                orderBumpRefreshRefs.current.delete(refreshFn);
-            else
-                orderBumpRefreshRefs.current.clear();
+                client.bus.off('ORDER_BUMP_REFRESH', refreshFn);
         },
-    }), []);
+    }), [client]);
     // Money Utils
     const moneyUtils = useMemo(() => ({
         formatMoney,
@@ -212,8 +228,8 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
                 refetch: noopAsync,
             };
         }
-        const next = async (event) => {
-            const result = await client.funnel.navigate(event);
+        // Helper to handle navigation result with optional auto-redirect
+        const handleNavigationResult = (result) => {
             // Call custom onNavigate handler if provided
             let shouldAutoRedirect = true;
             if (onNavigate) {
@@ -230,22 +246,23 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
                 setPendingRedirect(true);
                 window.location.href = result.url;
             }
+        };
+        const next = async (event) => {
+            const result = await client.funnel.navigate(event);
+            handleNavigationResult(result);
             return result;
         };
         const goToStep = async (stepId) => {
-            return await next({
-                type: 'DIRECT_NAVIGATION',
-                data: { targetStepId: stepId },
-            });
+            const result = await client.funnel.goToStep(stepId);
+            handleNavigationResult(result);
+            return result;
         };
-        // Helper to resolve accountId with fallbacks
-        const getAccountId = () => state.store?.accountId || state.pluginConfig?.accountId || state.session?.accountId || '';
         return {
             next,
             goToStep,
             updateContext: (updates) => client.funnel.updateContext(updates),
             initializeSession: async (entryStepId) => {
-                const accountId = getAccountId();
+                const accountId = client.getAccountId();
                 if (!accountId || !state.auth.session || !state.store) {
                     throw new Error('Cannot initialize funnel: missing required data (accountId, session, or store)');
                 }
@@ -253,7 +270,7 @@ export function TagadaProvider({ children, environment, customApiConfig, debugMo
             },
             endSession: () => client.funnel.endSession(),
             retryInitialization: () => {
-                const accountId = getAccountId();
+                const accountId = client.getAccountId();
                 if (!accountId || !state.auth.session || !state.store) {
                     return Promise.reject(new Error('Cannot retry initialization: missing required data'));
                 }

package/dist/v2/standalone/external-tracker.d.ts

@@ -0,0 +1,119 @@
+/**
+ * TagadaPay External Page Tracker
+ *
+ * A lightweight standalone script for tracking users on external pages
+ * that are part of a Tagadapay funnel but not hosted on the Tagadapay platform.
+ *
+ * ARCHITECTURE:
+ * - Reuses core SDK infrastructure (TagadaClient) for authentication and API handling
+ * - All tracking handled automatically by funnelOrchestrator via autoInitialize() and navigate()
+ * - No separate tracking endpoints needed - unified tracking through orchestrator
+ *
+ * Usage (via CDN):
+ * <script src="https://cdn.jsdelivr.net/npm/@tagadapay/plugin-sdk/dist/external-tracker.min.js"></script>
+ * <script>
+ *   TagadaTracker.init({
+ *     storeId: 'store_xxx',
+ *     accountId: 'acc_xxx',
+ *     funnelId: 'funnel_xxx',  // Optional: detected from URL
+ *     stepId: 'step_xxx',
+ *     stepName: 'External Offer Page',
+ *     stepType: 'external'
+ *   });
+ *
+ *   // Navigate to next step (tracking automatic)
+ *   TagadaTracker.navigate({
+ *     eventType: 'form.submitted',
+ *     eventData: { email: 'user@example.com' }
+ *   });
+ * </script>
+ */
+import type { TagadaClient } from '../core/client';
+export interface TagadaTrackerConfig {
+    /** Store ID (required) */
+    storeId: string;
+    /** Account ID (required for session init) */
+    accountId?: string;
+    /** Funnel ID (optional - can be extracted from URL param) */
+    funnelId?: string;
+    /**
+     * Step ID (REQUIRED for external pages)
+     *
+     * External URLs cannot be mapped to steps via URL matching (only works for Tagadapay-hosted pages).
+     * You must explicitly specify which step this external page represents.
+     */
+    stepId: string;
+    /** Step name (optional - for analytics/debugging) */
+    stepName?: string;
+    /** Step type (optional - e.g., 'landing', 'offer', 'external') */
+    stepType?: string;
+    /** API base URL (defaults to production) */
+    apiBaseUrl?: string;
+    /** Enable debug logging */
+    debug?: boolean;
+    /** Callback when session is ready */
+    onReady?: (session: ExternalTrackerSession) => void;
+    /** Callback on error */
+    onError?: (error: Error) => void;
+}
+export interface ExternalTrackerSession {
+    sessionId: string;
+    customerId: string;
+    storeId: string;
+    funnelId?: string;
+    currentStepId?: string;
+    cmsToken?: string;
+}
+export interface NavigateOptions {
+    /** Event type for navigation (e.g., 'offer.accepted', 'form.submitted') */
+    eventType: string;
+    /** Event data */
+    eventData?: Record<string, unknown>;
+    /** Override return URL */
+    returnUrl?: string;
+}
+declare class TagadaExternalTracker {
+    private config;
+    private client;
+    private initialized;
+    private initializing;
+    /**
+     * Initialize the tracker using SDK infrastructure
+     */
+    init(config: TagadaTrackerConfig): Promise<ExternalTrackerSession | null>;
+    /**
+     * Get current session from SDK state
+     */
+    getSession(): ExternalTrackerSession | null;
+    /**
+     * Check if tracker is ready
+     */
+    isReady(): boolean;
+    /**
+     * Navigate to next step in funnel using SDK's funnel client
+     */
+    navigate(options: NavigateOptions): Promise<{
+        url: string;
+    } | null>;
+    /**
+     * Get customer ID (for identifying the user)
+     */
+    getCustomerId(): string | null;
+    /**
+     * Get funnel session ID
+     */
+    getFunnelSessionId(): string | null;
+    /**
+     * Build a URL with funnel context parameters
+     * Useful for linking to other external pages while preserving session
+     */
+    buildUrl(baseUrl: string, additionalParams?: Record<string, string>): string;
+    /**
+     * Get the underlying SDK client (for advanced usage)
+     */
+    getClient(): TagadaClient | null;
+    private waitForClientReady;
+    private initializeFunnel;
+}
+declare const TagadaTracker: TagadaExternalTracker;
+export { TagadaTracker, TagadaExternalTracker };