@tagadapay/plugin-sdk 2.4.38 → 2.5.0

package/dist/react/hooks/useOrderBumpV3.js

@@ -0,0 +1,109 @@
+import { useState, useCallback, useEffect } from 'react';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { useCheckoutSession } from './useCheckoutSession';
+/**
+ * Composable order bump hook that works with a specific checkout token
+ * This allows multiple order bumps to work with different checkout sessions
+ */
+export function useOrderBumpV3(options) {
+    const { apiService, refreshCoordinator } = useTagadaContext();
+    const { checkoutToken, offerId, productId, orderBumpType = 'primary' } = options;
+    // Use the composable checkout session hook
+    const { checkout, isLoading: checkoutLoading, error: checkoutError, refresh: refreshCheckout } = useCheckoutSession({
+        checkoutToken,
+        autoRefresh: false, // We'll handle refreshes manually
+    });
+    // Check if order bump is selected from checkout session line items
+    const checkOrderBumpSelection = useCallback(() => {
+        console.log('🔧 useOrderBumpV3: Checking order bump selection', {
+            checkoutToken: checkoutToken ? checkoutToken.substring(0, 8) + '...' : null,
+            offerId,
+            productId,
+            hasCheckout: !!checkout,
+            hasSession: !!checkout?.checkoutSession,
+            hasLineItems: !!checkout?.checkoutSession?.sessionLineItems
+        });
+        if (!checkout?.checkoutSession?.sessionLineItems) {
+            console.log('🔧 useOrderBumpV3: No session line items available');
+            return false;
+        }
+        const targetProductId = productId || offerId; // Fallback to offerId if productId not provided
+        console.log('🔧 useOrderBumpV3: Looking for product ID:', targetProductId);
+        const isSelected = checkout.checkoutSession.sessionLineItems.some((item) => {
+            const matches = item.isOrderBump === true && item.productId === targetProductId;
+            console.log('🔧 useOrderBumpV3: Checking item:', {
+                itemId: item.id,
+                productId: item.productId,
+                isOrderBump: item.isOrderBump,
+                targetProductId,
+                offerId,
+                matches
+            });
+            return matches;
+        });
+        console.log('🔧 useOrderBumpV3: Selection result:', isSelected);
+        return isSelected;
+    }, [checkout?.checkoutSession?.sessionLineItems, offerId, productId]);
+    // Initialize state based on current checkout session
+    const [isSelected, setIsSelected] = useState(() => checkOrderBumpSelection());
+    const [isToggling, setIsToggling] = useState(false);
+    const [error, setError] = useState(null);
+    // Update isSelected when checkout session changes
+    useEffect(() => {
+        const isSelectedFromSession = checkOrderBumpSelection();
+        setIsSelected(isSelectedFromSession);
+    }, [checkOrderBumpSelection]);
+    const toggle = useCallback(async (selected) => {
+        if (!checkout?.checkoutSession?.id) {
+            console.warn('useOrderBumpV3: No checkout session available yet');
+            return { success: false, error: 'Checkout session not ready' };
+        }
+        const targetState = selected ?? !isSelected;
+        // Optimistic update
+        setIsSelected(targetState);
+        setIsToggling(true);
+        setError(null);
+        try {
+            const response = await apiService.fetch(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/toggle-order-bump`, {
+                method: 'POST',
+                body: {
+                    orderBumpOfferId: offerId,
+                    selected: targetState,
+                },
+            });
+            if (response.success) {
+                // Refresh the checkout session to get updated data
+                await refreshCheckout();
+                // Notify other hooks that order bump data changed
+                await refreshCoordinator.notifyOrderBumpChanged();
+                // Also notify checkout hooks that data changed
+                await refreshCoordinator.notifyCheckoutChanged();
+                return { success: true };
+            }
+            else {
+                // Revert optimistic update
+                setIsSelected(!targetState);
+                return { success: false, error: response.error };
+            }
+        }
+        catch (err) {
+            // Revert optimistic update
+            setIsSelected(!targetState);
+            const error = err instanceof Error ? err : new Error('Failed to toggle order bump');
+            setError(error);
+            return { success: false, error: error.message };
+        }
+        finally {
+            setIsToggling(false);
+        }
+    }, [checkout?.checkoutSession?.id, offerId, isSelected, apiService, refreshCoordinator, refreshCheckout]);
+    return {
+        isSelected,
+        isLoading: checkoutLoading,
+        isToggling,
+        error: error || checkoutError,
+        toggle,
+        isReady: !!checkout?.checkoutSession?.id,
+        checkout,
+    };
+}

package/dist/react/hooks/usePayment.d.ts

@@ -83,7 +83,7 @@ export interface PaymentInstrumentCustomer {
     token: string;
     isDefault: boolean;
     isActive: boolean;
-    metadata: {};
+    metadata: Record<string, unknown>;
     customerId: string;
     accountId: string;
     createdAt: string;

package/dist/react/hooks/usePayment.js

@@ -1,7 +1,7 @@
 import { useBasisTheory } from '@basis-theory/basis-theory-react';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { getBasisTheoryApiKey } from '../config/payment';
-import { useTagadaContextSafe } from '../providers/TagadaProvider';
+import { useTagadaContext } from '../providers/TagadaProvider';
 import { usePaymentPolling } from './usePaymentPolling';
 import { useThreeds } from './useThreeds';
 // Helper function to format expiry date
@@ -16,23 +16,7 @@ const getCardMonthAndYear = (expiryDate) => {
     };
 };
 export function usePayment() {
-    const context = useTagadaContextSafe();
-    // If context is not ready yet, return loading state
-    if (!context) {
-        return {
-            processCardPayment: async () => ({ paymentId: '', payment: {} }),
-            processApplePayPayment: async () => ({ paymentId: '', payment: {} }),
-            processPaymentWithInstrument: async () => ({ paymentId: '', payment: {} }),
-            createCardPaymentInstrument: async () => ({ id: '', token: '', type: 'card' }),
-            createApplePayPaymentInstrument: async () => ({ id: '', token: '', type: 'apple_pay' }),
-            getCardPaymentInstruments: async () => [],
-            isLoading: false,
-            error: null,
-            clearError: () => { },
-            currentPaymentId: null,
-        };
-    }
-    const { apiService, environment } = context;
+    const { apiService, environment } = useTagadaContext();
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
     const [currentPaymentId, setCurrentPaymentId] = useState(null);

package/dist/react/hooks/usePluginConfig.js

@@ -18,7 +18,7 @@
  *    - Headers for store/account info
  *    - Meta tags for deployment config
  */
-import { useTagadaContextSafe } from '../providers/TagadaProvider';
+import { useTagadaContext } from '../providers/TagadaProvider';
 // Simple cache for plugin configuration
 let cachedConfig = null;
 let configPromise = null;
@@ -161,18 +161,7 @@ export const loadPluginConfig = async (configVariant = 'default', rawConfig) =>
  * Gets config from TagadaProvider context (no parameters needed)
  */
 export const usePluginConfig = () => {
-    const context = useTagadaContextSafe();
-    // If context is not ready yet, return loading state
-    if (!context) {
-        return {
-            storeId: undefined,
-            accountId: undefined,
-            basePath: '/',
-            config: {},
-            loading: true,
-        };
-    }
-    const { pluginConfig, pluginConfigLoading } = context;
+    const { pluginConfig, pluginConfigLoading } = useTagadaContext();
     return {
         storeId: pluginConfig.storeId,
         accountId: pluginConfig.accountId,

package/dist/react/hooks/usePostPurchases.js

@@ -24,7 +24,7 @@ export function usePostPurchases(options) {
             // Auto-initialize checkout sessions if enabled
             if (autoInitializeCheckout && fetchedOffers.length > 0) {
                 for (const offer of fetchedOffers) {
-                    await initializeOfferCheckout(offer.id);
+                    void initializeOfferCheckout(offer.id);
                 }
             }
         }
@@ -69,9 +69,13 @@ export function usePostPurchases(options) {
             method: 'POST',
             body: JSON.stringify({
                 checkoutSessionId,
+                draft: false,
+                returnUrl: window.location.href,
                 metadata: {
                     comingFromPostPurchase: true,
                     postOrder: orderId,
+                    upsell: true,
+                    source: 'post_purchase_offer',
                 },
             }),
         });
@@ -244,6 +248,8 @@ export function usePostPurchases(options) {
                 metadata: {
                     comingFromPostPurchase: true,
                     postOrder: orderId,
+                    upsell: true,
+                    source: 'post_purchase_offer',
                 },
             }),
         });
@@ -268,17 +274,17 @@ export function usePostPurchases(options) {
         }));
     }, [checkoutSessions]);
     const getOrderSummary = useCallback((offerId) => {
-        return checkoutSessions[offerId]?.orderSummary || null;
+        return checkoutSessions[offerId]?.orderSummary ?? null;
     }, [checkoutSessions]);
     const isLoadingVariants = useCallback((offerId, productId) => {
-        return checkoutSessions[offerId]?.loadingVariants?.[productId] || false;
+        return checkoutSessions[offerId]?.loadingVariants?.[productId] ?? false;
     }, [checkoutSessions]);
     const isUpdatingOrderSummary = useCallback((offerId) => {
-        return checkoutSessions[offerId]?.isUpdatingSummary || false;
+        return checkoutSessions[offerId]?.isUpdatingSummary ?? false;
     }, [checkoutSessions]);
     useEffect(() => {
         if (enabled && orderId) {
-            fetchOffers();
+            void fetchOffers();
         }
     }, [enabled, orderId, fetchOffers]);
     const getOffer = useCallback((offerId) => {

package/dist/react/hooks/useProducts.js

@@ -1,23 +1,9 @@
 import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useTagadaContextSafe } from '../providers/TagadaProvider';
+import { useTagadaContext } from '../providers/TagadaProvider';
 import { usePluginConfig } from './usePluginConfig';
 export function useProducts(options = {}) {
-    const context = useTagadaContextSafe();
+    const { apiService } = useTagadaContext();
     const { storeId } = usePluginConfig();
-    // If context is not ready yet, return loading state
-    if (!context) {
-        return {
-            products: [],
-            isLoading: true,
-            error: null,
-            getVariant: () => undefined,
-            getProduct: () => undefined,
-            getAllVariants: () => [],
-            filterVariants: () => [],
-            refetch: async () => { },
-        };
-    }
-    const { apiService } = context;
     const [products, setProducts] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);

package/dist/react/index.d.ts

@@ -15,6 +15,10 @@ export { useLocale } from './hooks/useLocale';
 export { useLogin } from './hooks/useLogin';
 export { useOffers } from './hooks/useOffers';
 export { useOrderBump } from './hooks/useOrderBump';
+export { useOrderBumpV2 } from './hooks/useOrderBumpV2';
+export { useOrderBumpV3 } from './hooks/useOrderBumpV3';
+export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { useCheckoutSession } from './hooks/useCheckoutSession';
 export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
@@ -22,7 +26,7 @@ export { useShippingRates } from './hooks/useShippingRates';
 export type { UseShippingRatesOptions, UseShippingRatesResult } from './hooks/useShippingRates';
 export { useTranslations } from './hooks/useTranslations';
 export { useVipOffers } from './hooks/useVipOffers';
-export { useTagadaContext, useTagadaContextSafe } from './providers/TagadaProvider';
+export { useTagadaContext } from './providers/TagadaProvider';
 export { clearPluginConfigCache, debugPluginConfig, getPluginConfig, useBasePath, usePluginConfig } from './hooks/usePluginConfig';
 export type { PluginConfig } from './hooks/usePluginConfig';
 export { getAvailableLanguages, useCountryOptions, useISOData, useRegionOptions, useLanguageImport } from './hooks/useISOData';
@@ -41,6 +45,10 @@ export type { AuthState, Currency, Customer, Environment, EnvironmentConfig, Loc
 export type { CheckoutData, CheckoutInitParams, CheckoutLineItem, CheckoutSession, CheckoutSessionPreview, Promotion, UseCheckoutOptions, UseCheckoutResult } from './hooks/useCheckout';
 export type { Discount, DiscountCodeValidation, UseDiscountsOptions, UseDiscountsResult } from './hooks/useDiscounts';
 export type { OrderBumpPreview, UseOrderBumpOptions, UseOrderBumpResult } from './hooks/useOrderBump';
+export type { UseOrderBumpV2Options, UseOrderBumpV2Result } from './hooks/useOrderBumpV2';
+export type { UseOrderBumpV3Options, UseOrderBumpV3Result } from './hooks/useOrderBumpV3';
+export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
+export type { UseCheckoutSessionOptions, UseCheckoutSessionResult } from './hooks/useCheckoutSession';
 export type { UseVipOffersOptions, UseVipOffersResult, VipOffer, VipPreviewResponse } from './hooks/useVipOffers';
 export type { PostPurchaseOffer, PostPurchaseOfferItem, PostPurchaseOfferLineItem, PostPurchaseOfferSummary, UsePostPurchasesOptions, UsePostPurchasesResult } from './hooks/usePostPurchases';
 export type { Payment, PaymentPollingHook, PollingOptions } from './hooks/usePaymentPolling';

package/dist/react/index.js

@@ -18,13 +18,17 @@ export { useLocale } from './hooks/useLocale';
 export { useLogin } from './hooks/useLogin';
 export { useOffers } from './hooks/useOffers';
 export { useOrderBump } from './hooks/useOrderBump';
+export { useOrderBumpV2 } from './hooks/useOrderBumpV2';
+export { useOrderBumpV3 } from './hooks/useOrderBumpV3';
+export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { useCheckoutSession } from './hooks/useCheckoutSession';
 export { usePostPurchases } from './hooks/usePostPurchases';
 export { useProducts } from './hooks/useProducts';
 export { useSession } from './hooks/useSession';
 export { useShippingRates } from './hooks/useShippingRates';
 export { useTranslations } from './hooks/useTranslations';
 export { useVipOffers } from './hooks/useVipOffers';
-export { useTagadaContext, useTagadaContextSafe } from './providers/TagadaProvider';
+export { useTagadaContext } from './providers/TagadaProvider';
 // Plugin configuration hooks
 export { clearPluginConfigCache, debugPluginConfig, getPluginConfig, useBasePath, usePluginConfig } from './hooks/usePluginConfig';
 // ISO Data hooks

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

@@ -60,5 +60,4 @@ export declare function TagadaProvider({ children, environment, customApiConfig,
 localConfig, blockUntilSessionReady, // Default to new non-blocking behavior
 rawPluginConfig, }: TagadaProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare function useTagadaContext(): TagadaContextValue;
-export declare function useTagadaContextSafe(): TagadaContextValue | null;
 export {};

package/dist/react/providers/TagadaProvider.js

@@ -66,8 +66,19 @@ rawPluginConfig, }) {
         hasLoggedRef.current = true;
     }
     // Load plugin configuration directly (not using hook to avoid circular dependency)
-    const [pluginConfig, setPluginConfig] = useState({ basePath: '/', config: {} });
-    const [configLoading, setConfigLoading] = useState(true);
+    // Initialize with raw config if available to avoid empty config during loading
+    const [pluginConfig, setPluginConfig] = useState(() => {
+        if (rawPluginConfig) {
+            return {
+                storeId: rawPluginConfig.storeId,
+                accountId: rawPluginConfig.accountId,
+                basePath: rawPluginConfig.basePath ?? '/',
+                config: rawPluginConfig.config ?? {},
+            };
+        }
+        return { basePath: '/', config: {} };
+    });
+    const [configLoading, setConfigLoading] = useState(!rawPluginConfig);
     // Load plugin config on mount with the specified variant
     useEffect(() => {
         const loadConfig = async () => {
@@ -524,12 +535,9 @@ rawPluginConfig, }) {
         refreshCoordinator,
     ]);
     // Determine if we should show loading
-    // Phase 1 & 2 are mandatory: config loading and storeId availability
-    // Phase 3 (session initialization) is optional/non-blocking by default
-    const shouldShowLoading = configLoading || (!storeId && configLoading);
-    const canRenderChildren = blockUntilSessionReady
-        ? !configLoading && storeId && isInitialized // Old behavior: wait for all phases
-        : !configLoading && storeId; // New behavior: render after phases 1 & 2
+    // Always block until config is loaded (even if empty)
+    const shouldShowLoading = configLoading;
+    const canRenderChildren = !configLoading;
     return (_jsxs(TagadaContext.Provider, { value: contextValue, children: [shouldShowLoading && _jsx(InitializationLoader, {}), finalDebugMode && canRenderChildren && (_jsxs(_Fragment, { children: [_jsx("button", { onClick: () => setIsDebugDrawerOpen(true), style: {
                             position: 'fixed',
                             bottom: '16px',
@@ -560,10 +568,6 @@ export function useTagadaContext() {
     }
     return context;
 }
-// Safe version that returns null instead of throwing
-export function useTagadaContextSafe() {
-    return useContext(TagadaContext);
-}
 // Helper functions
 function getCurrencySymbol(code) {
     const symbols = {

package/dist/react/services/apiService.d.ts

@@ -49,6 +49,7 @@ export declare class ApiService {
     private onTokenClear?;
     constructor(options: ApiServiceOptions);
     updateToken(token: string | null): void;
+    getCurrentToken(): string | null;
     updateConfig(config: EnvironmentConfig): void;
     /**
      * Store the store ID in localStorage (deprecated - use usePluginConfig instead)

package/dist/react/services/apiService.js

@@ -10,6 +10,9 @@ export class ApiService {
     updateToken(token) {
         this.token = token;
     }
+    getCurrentToken() {
+        return this.token;
+    }
     updateConfig(config) {
         this.config = config;
     }

package/dist/v2/core/googleAutocomplete.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Google Autocomplete Core
+ * Pure functions for Google Places API integration
+ */
+export interface GooglePrediction {
+    place_id: string;
+    description: string;
+    structured_formatting?: {
+        main_text: string;
+        secondary_text: string;
+    };
+}
+export interface GooglePlaceDetails {
+    place_id: string;
+    formatted_address: string;
+    address_components: {
+        long_name: string;
+        short_name: string;
+        types: string[];
+    }[];
+    geometry: {
+        location: {
+            lat: number;
+            lng: number;
+        };
+    };
+}
+export interface AddressComponents {
+    streetNumber?: string;
+    route?: string;
+    city?: string;
+    state?: string;
+    postalCode?: string;
+    country?: string;
+    countryCode?: string;
+    locality?: string;
+    administrativeAreaLevel1?: string;
+    administrativeAreaLevel1Long?: string;
+    iso?: string;
+}
+export declare class GoogleAutocompleteCore {
+    private static apiKey;
+    private static service;
+    /**
+     * Initialize Google Places API
+     */
+    static initialize(apiKey: string): void;
+    /**
+     * Search for places
+     */
+    static searchPlaces(input: string, options?: {
+        types?: string[];
+        componentRestrictions?: {
+            country: string;
+        };
+    }): Promise<GooglePrediction[]>;
+    /**
+     * Get place details
+     */
+    static getPlaceDetails(placeId: string): Promise<GooglePlaceDetails | null>;
+    /**
+     * Extract address components from place details
+     */
+    static extractAddressComponents(placeDetails: GooglePlaceDetails): AddressComponents;
+}

package/dist/v2/core/googleAutocomplete.js

@@ -0,0 +1,94 @@
+/**
+ * Google Autocomplete Core
+ * Pure functions for Google Places API integration
+ */
+export class GoogleAutocompleteCore {
+    /**
+     * Initialize Google Places API
+     */
+    static initialize(apiKey) {
+        this.apiKey = apiKey;
+        if (typeof window !== 'undefined' && window.google) {
+            this.service = new window.google.maps.places.AutocompleteService();
+        }
+    }
+    /**
+     * Search for places
+     */
+    static async searchPlaces(input, options = {}) {
+        if (!this.service || !input.trim()) {
+            return [];
+        }
+        return new Promise((resolve, reject) => {
+            this.service.getPlacePredictions({
+                input,
+                types: options.types || ['address'],
+                componentRestrictions: options.componentRestrictions,
+            }, (predictions, status) => {
+                if (status === window.google.maps.places.PlacesServiceStatus.OK && predictions) {
+                    resolve(predictions);
+                }
+                else {
+                    resolve([]);
+                }
+            });
+        });
+    }
+    /**
+     * Get place details
+     */
+    static async getPlaceDetails(placeId) {
+        if (typeof window === 'undefined' || !window.google) {
+            return null;
+        }
+        return new Promise((resolve, reject) => {
+            const service = new window.google.maps.places.PlacesService(document.createElement('div'));
+            service.getDetails({
+                placeId,
+                fields: ['place_id', 'formatted_address', 'address_components', 'geometry'],
+            }, (place, status) => {
+                if (status === window.google.maps.places.PlacesServiceStatus.OK && place) {
+                    resolve(place);
+                }
+                else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+    /**
+     * Extract address components from place details
+     */
+    static extractAddressComponents(placeDetails) {
+        const components = {};
+        for (const component of placeDetails.address_components) {
+            const types = component.types;
+            if (types.includes('street_number')) {
+                components.streetNumber = component.long_name;
+            }
+            else if (types.includes('route')) {
+                components.route = component.long_name;
+            }
+            else if (types.includes('locality')) {
+                components.city = component.long_name;
+                components.locality = component.long_name;
+            }
+            else if (types.includes('administrative_area_level_1')) {
+                components.state = component.long_name;
+                components.administrativeAreaLevel1 = component.short_name;
+                components.administrativeAreaLevel1Long = component.long_name;
+            }
+            else if (types.includes('postal_code')) {
+                components.postalCode = component.long_name;
+            }
+            else if (types.includes('country')) {
+                components.country = component.long_name;
+                components.countryCode = component.short_name;
+                components.iso = component.short_name;
+            }
+        }
+        return components;
+    }
+}
+GoogleAutocompleteCore.apiKey = null;
+GoogleAutocompleteCore.service = null;

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

@@ -0,0 +1,8 @@
+/**
+ * Core functions and utilities for TagadaPay Plugin SDK v2
+ * Structured with utils (pure functions) and resources (API clients)
+ */
+export * from './utils';
+export * from './resources';
+export * from './googleAutocomplete';
+export * from './isoData';

package/dist/v2/core/index.js

@@ -0,0 +1,11 @@
+/**
+ * Core functions and utilities for TagadaPay Plugin SDK v2
+ * Structured with utils (pure functions) and resources (API clients)
+ */
+// Export utilities (pure functions)
+export * from './utils';
+// Export resources (axios-based API clients)
+export * from './resources';
+// Export legacy files that are still needed
+export * from './googleAutocomplete';
+export * from './isoData';

package/dist/v2/core/isoData.d.ts

@@ -0,0 +1,50 @@
+/**
+ * ISO Data Core
+ * Pure functions for country and region data management
+ * Uses the existing iso3166 data functions
+ */
+import { type SupportedLanguage } from '../../data/iso3166';
+export interface ISOCountry {
+    iso: string;
+    iso3: string;
+    numeric: number;
+    name: string;
+}
+export interface ISORegion {
+    iso: string;
+    name: string;
+}
+export declare class ISODataCore {
+    /**
+     * Get countries data for a specific language
+     */
+    static getCountriesData(language?: SupportedLanguage): Record<string, ISOCountry>;
+    /**
+     * Get regions for a specific country
+     */
+    static getRegions(countryCode: string, language?: SupportedLanguage): ISORegion[];
+    /**
+     * Find a specific region by ISO code
+     */
+    static findRegion(countryCode: string, regionCode: string, language?: SupportedLanguage): ISORegion | null;
+    /**
+     * Map Google Places state to ISO region (proven 100% success rate)
+     */
+    static mapGoogleToISO(googleState: string, googleStateLong: string, countryCode: string, language?: SupportedLanguage): ISORegion | null;
+    /**
+     * Check if language is registered
+     */
+    static isLanguageRegistered(language: SupportedLanguage): boolean;
+    /**
+     * Get registered languages
+     */
+    static getRegisteredLanguages(): SupportedLanguage[];
+    /**
+     * Import language data
+     */
+    static importLanguage(language: SupportedLanguage): Promise<void>;
+    /**
+     * Get available languages for ISO data
+     */
+    static getAvailableLanguages(): SupportedLanguage[];
+}