import * as react_jsx_runtime from 'react/jsx-runtime';
import React, { ReactNode } from 'react';
import { C as Currency, f as BeninPaymentAnalyticsHandler, c as PaymentMessageOverrides, E as ErrorMessageResolver, d as EnvironmentWarningMessages, l as FedaPayConfig, b as PaymentValidationError, i as VerificationConfig, p as KkiaPaySuccessResponse, q as KkiaPayFailedResponse, K as KkiaPayConfig, a as PaymentProvider, m as FedaPayCallbackResponse } from './errors-Bkzdj0lJ.mjs';

/**
 * Global configuration for Benin Payment providers.
 */
interface BeninPaymentConfig {
    /**
     * Default FedaPay public key.
     * Will be used if no key is provided at the component level.
     * @example "pk_live_xxxxxxxxxxxx"
     */
    fedaPayPublicKey?: string;
    /**
     * Default KKiaPay public key.
     * Will be used if no key is provided at the component level.
     * @example "pk_xxxxxxxxxxxx"
     */
    kkiaPayPublicKey?: string;
    /**
     * Default currency for all transactions.
     * @default "XOF"
     */
    defaultCurrency?: Currency;
    /**
     * Force sandbox/test mode globally.
     * When true, all transactions will be in test mode.
     * @default false
     */
    isTestMode?: boolean;
    /**
     * Enable debug mode globally.
     * Shows console logs for all payment operations.
     * @default false
     */
    debug?: boolean;
    /**
     * Global analytics callback for standardized payment events.
     */
    onAnalyticsEvent?: BeninPaymentAnalyticsHandler;
    /**
     * Overrides the wording of built-in validation error messages
     * (missing key, invalid amount, SDK not loaded...) for every hook.
     * Can be refined per-hook via `useFedaPay`/`useKkiaPay` options.
     */
    messages?: PaymentMessageOverrides;
    /**
     * Resolves the message for arbitrary caught errors (SDK load failures,
     * network errors...) surfaced via a hook's `error` state. Falls back to
     * the built-in French translations when it returns `undefined`.
     */
    resolveErrorMessage?: ErrorMessageResolver;
    /**
     * Overrides the wording of dev-time console warnings (live key used in
     * sandbox mode, etc.) for every hook. Can be refined per-hook via
     * `useFedaPay`/`useKkiaPay` options.
     */
    environmentWarnings?: EnvironmentWarningMessages;
}
/**
 * Internal context value with resolved defaults.
 */
interface BeninPaymentContextValue {
    fedaPayPublicKey: string | undefined;
    kkiaPayPublicKey: string | undefined;
    defaultCurrency: Currency;
    isTestMode: boolean;
    debug: boolean;
    onAnalyticsEvent?: BeninPaymentAnalyticsHandler;
    messages?: PaymentMessageOverrides;
    resolveErrorMessage?: ErrorMessageResolver;
    environmentWarnings?: EnvironmentWarningMessages;
    isProviderMounted: boolean;
}
/**
 * Props for the BeninPaymentProvider component.
 */
interface BeninPaymentProviderProps extends BeninPaymentConfig {
    /** Child components that will have access to the payment context */
    children: ReactNode;
}
/**
 * Global provider for Benin Payment configuration.
 *
 * Wrap your application (or a section of it) with this provider to set
 * default values for all FedaPay and KKiaPay hooks and components.
 *
 * @example
 * ```tsx
 * import { BeninPaymentProvider } from "react-benin-payments";
 *
 * function App() {
 *   return (
 *     <BeninPaymentProvider
 *       fedaPayPublicKey="pk_live_xxxxxxxxxxxx"
 *       kkiaPayPublicKey="pk_xxxxxxxxxxxx"
 *       defaultCurrency="XOF"
 *       isTestMode={process.env.NODE_ENV === "development"}
 *       debug={true}
 *     >
 *       <YourApp />
 *     </BeninPaymentProvider>
 *   );
 * }
 * ```
 *
 * @example
 * ```tsx
 * // Components inside the provider can now use hooks without passing keys
 * function PaymentButton() {
 *   const { openDialog, loading } = useFedaPay({
 *     transaction: { amount: 5000 }
 *     // No need for public_key - it's taken from the provider!
 *   });
 *
 *   return <button onClick={openDialog}>Pay</button>;
 * }
 * ```
 */
declare function BeninPaymentProvider({ fedaPayPublicKey, kkiaPayPublicKey, defaultCurrency, isTestMode, debug, onAnalyticsEvent, messages, resolveErrorMessage, environmentWarnings, children, }: BeninPaymentProviderProps): react_jsx_runtime.JSX.Element;
/**
 * Hook to access the global Benin Payment configuration.
 *
 * Returns the configuration from the nearest BeninPaymentProvider,
 * or default values if no provider is found.
 *
 * @returns The current payment configuration
 *
 * @example
 * ```tsx
 * function PaymentStatus() {
 *   const { isTestMode, defaultCurrency, debug } = useBeninConfig();
 *
 *   return (
 *     <div>
 *       Mode: {isTestMode ? "Test" : "Production"}
 *       Currency: {defaultCurrency}
 *     </div>
 *   );
 * }
 * ```
 */
declare function useBeninConfig(): BeninPaymentContextValue;
/**
 * Hook to check if the app is wrapped with BeninPaymentProvider.
 *
 * @returns true if provider is mounted, false otherwise
 */
declare function useIsBeninProviderMounted(): boolean;

/**
 * Options for the useFedaPay hook.
 */
interface UseFedaPayOptions {
    /**
     * Enable debug mode with styled console logs.
     * If not provided, uses the value from BeninPaymentProvider.
     * @default false
     */
    debug?: boolean;
    /**
     * Enable mock mode for testing.
     * When true, no real SDK is loaded and payments are simulated.
     * Automatically enabled when process.env.NODE_ENV === 'test'.
     * @default false
     */
    mock?: boolean;
    /**
     * Runs before opening the payment modal.
     * Return `false` to cancel opening without throwing an error.
     */
    onBeforePayment?: () => void | boolean | Promise<void | boolean>;
    /**
     * Receives standardized analytics events for the payment lifecycle.
     */
    onAnalyticsEvent?: BeninPaymentAnalyticsHandler;
    /**
     * Callback fired when validation fails or SDK errors occur.
     * @param error - The validation error with code and message
     */
    onError?: (error: PaymentValidationError) => void;
    /**
     * Overrides the wording of validation error messages for this hook only
     * (takes precedence over `BeninPaymentProvider`'s `messages`).
     */
    messages?: PaymentMessageOverrides;
    /**
     * Resolves the message for arbitrary caught errors (SDK load failures...)
     * for this hook only. Falls back to the provider's `resolveErrorMessage`,
     * then to the built-in translations.
     */
    resolveErrorMessage?: ErrorMessageResolver;
    /**
     * Overrides the wording of dev-time console warnings for this hook only
     * (takes precedence over `BeninPaymentProvider`'s `environmentWarnings`).
     */
    environmentWarnings?: EnvironmentWarningMessages;
}
/**
 * Return type for the useFedaPay hook.
 */
interface UseFedaPayReturn {
    /** Function to open the FedaPay payment dialog */
    openDialog: () => void;
    /** Whether the SDK is currently loading */
    loading: boolean;
    /** Error object if SDK loading failed */
    error: Error | null;
    /** Whether the SDK script has been successfully loaded */
    scriptLoaded: boolean;
    /** Whether running in mock mode */
    isMockMode: boolean;
    /** Whether backend verification is in progress */
    isVerifying: boolean;
    /** Whether async pre-validation is in progress */
    isPreparing: boolean;
}
/**
 * Configuration for useFedaPay that supports optional public_key.
 * When used inside BeninPaymentProvider, public_key can be omitted.
 */
type UseFedaPayConfig = Omit<FedaPayConfig, "public_key"> & {
    /**
     * Your FedaPay public key.
     * Optional if using BeninPaymentProvider with fedaPayPublicKey set.
     */
    public_key?: string;
};
/**
 * React hook for integrating FedaPay payments.
 *
 * Handles script loading, validation, payment dialog, and backend verification.
 * Supports mock mode for testing without loading the actual SDK.
 *
 * Internally this is a thin binding over the framework-agnostic payment
 * engine (see `src/core`) configured with the FedaPay driver — the same
 * engine that powers `useKkiaPay`.
 *
 * @param config - FedaPay configuration (public_key optional if using Provider)
 * @param options - Optional settings for debug mode, mock mode, and error handling
 * @returns Object with `openDialog` function, loading states, and `isVerifying`
 *
 * @example
 * ```tsx
 * // With automatic backend verification
 * const { openDialog, loading, isVerifying } = useFedaPay({
 *   transaction: { amount: 5000 },
 *   verifyUrl: "/api/payments/verify",
 *   customVerifyHeaders: { "Authorization": "Bearer xxx" },
 *   onComplete: (response) => {
 *     // Called AFTER backend verification succeeds
 *     console.log("Payment verified!", response.transaction.id);
 *   }
 * });
 * ```
 */
declare function useFedaPay(config: UseFedaPayConfig, options?: UseFedaPayOptions): UseFedaPayReturn;

/**
 * Options for the useKkiaPay hook.
 */
interface UseKkiaPayOptions extends VerificationConfig {
    /**
     * Enable debug mode with styled console logs.
     * If not provided, uses the value from BeninPaymentProvider.
     * @default false
     */
    debug?: boolean;
    /**
     * Enable mock mode for testing.
     * When true, no real SDK is loaded and payments are simulated.
     * Automatically enabled when process.env.NODE_ENV === 'test'.
     * @default false
     */
    mock?: boolean;
    /**
     * Runs before opening the payment widget.
     * Return `false` to cancel opening without throwing an error.
     */
    onBeforePayment?: () => void | boolean | Promise<void | boolean>;
    /**
     * Receives standardized analytics events for the payment lifecycle.
     */
    onAnalyticsEvent?: BeninPaymentAnalyticsHandler;
    /**
     * Callback fired when payment is successful (after backend verification if configured).
     * @param data - Contains transactionId, amount, and phone
     */
    onSuccess?: (data: KkiaPaySuccessResponse) => void;
    /**
     * Callback fired when payment fails.
     * @param data - Contains error code and message
     */
    onFailed?: (data: KkiaPayFailedResponse) => void;
    /**
     * Callback fired when the widget is closed without completing payment.
     */
    onClose?: () => void;
    /**
     * Callback fired when validation fails or SDK errors occur.
     * @param error - The validation error with code and message
     */
    onValidationError?: (error: PaymentValidationError) => void;
    /**
     * Overrides the wording of validation error messages for this hook only
     * (takes precedence over `BeninPaymentProvider`'s `messages`).
     */
    messages?: PaymentMessageOverrides;
    /**
     * Resolves the message for arbitrary caught errors (SDK load failures...)
     * for this hook only. Falls back to the provider's `resolveErrorMessage`,
     * then to the built-in translations.
     */
    resolveErrorMessage?: ErrorMessageResolver;
    /**
     * Overrides the wording of dev-time console warnings for this hook only
     * (takes precedence over `BeninPaymentProvider`'s `environmentWarnings`).
     */
    environmentWarnings?: EnvironmentWarningMessages;
}
/**
 * Return type for the useKkiaPay hook.
 */
interface UseKkiaPayReturn {
    /** Function to open the KKiaPay payment widget */
    openKkiapay: (config: UseKkiaPayConfig) => void;
    /** Whether the SDK is currently loading */
    loading: boolean;
    /** Error object if SDK loading failed */
    error: Error | null;
    /** Whether the SDK script has been successfully loaded */
    scriptLoaded: boolean;
    /** Whether running in mock mode */
    isMockMode: boolean;
    /** Whether backend verification is in progress */
    isVerifying: boolean;
    /** Whether async pre-validation is in progress */
    isPreparing: boolean;
}
/**
 * Configuration for useKkiaPay that supports optional key.
 * When used inside BeninPaymentProvider, key can be omitted.
 */
type UseKkiaPayConfig = Omit<KkiaPayConfig, "key"> & {
    /**
     * Your KKiaPay public key.
     * Optional if using BeninPaymentProvider with kkiaPayPublicKey set.
     */
    key?: string;
};
/**
 * React hook for integrating KKiaPay payments.
 *
 * Handles script loading, event listeners, validation, widget management, and backend verification.
 * Supports mock mode for testing without loading the actual SDK.
 *
 * Internally this is a thin binding over the framework-agnostic payment
 * engine (see `src/core`) configured with the KKiaPay driver — the same
 * engine that powers `useFedaPay`.
 *
 * @param options - Configuration for callbacks, debug mode, mock mode, and verification
 * @returns Object with `openKkiapay` function, loading states, and `isVerifying`
 *
 * @example
 * ```tsx
 * // With automatic backend verification
 * const { openKkiapay, loading, isVerifying } = useKkiaPay({
 *   verifyUrl: "/api/payments/verify",
 *   customVerifyHeaders: { "Authorization": "Bearer xxx" },
 *   onSuccess: (data) => {
 *     // Called AFTER backend verification succeeds
 *     console.log("Payment verified!", data.transactionId);
 *   }
 * });
 * ```
 */
declare function useKkiaPay(options?: UseKkiaPayOptions): UseKkiaPayReturn;

/**
 * Unified payment result from any provider.
 */
interface UnifiedPaymentResult {
    /** Transaction ID from the provider */
    transactionId: string;
    /** Amount that was charged */
    amount: number;
    /** Payment status */
    status: "success" | "failed" | "pending";
    /** Original provider-specific response */
    rawResponse: FedaPayCallbackResponse | KkiaPaySuccessResponse;
}
/**
 * Config for useBeninPay hook.
 */
interface UseBeninPayConfig {
    /** The payment provider to use */
    provider: PaymentProvider;
    /**
     * FedaPay specific configuration.
     * Required when provider is "fedapay".
     */
    fedapay?: UseFedaPayConfig;
    /**
     * KKiaPay specific configuration.
     * Required when provider is "kkiapay".
     */
    kkiapay?: UseKkiaPayConfig;
}
/**
 * Options for useBeninPay hook.
 */
interface UseBeninPayOptions {
    /** Enable debug mode */
    debug?: boolean;
    /** Enable mock mode for testing */
    mock?: boolean;
    /** Runs before opening the selected payment provider modal/widget */
    onBeforePayment?: () => void | boolean | Promise<void | boolean>;
    /** Receives standardized analytics events for the payment lifecycle */
    onAnalyticsEvent?: BeninPaymentAnalyticsHandler;
    /** Callback on successful payment */
    onSuccess?: (result: UnifiedPaymentResult) => void;
    /** Callback on failed payment */
    onFailed?: (error: KkiaPayFailedResponse) => void;
    /** Callback when payment dialog is closed */
    onClose?: () => void;
    /** Callback on validation errors */
    onError?: (error: PaymentValidationError) => void;
    /** Overrides the wording of validation error messages for this hook only. */
    messages?: PaymentMessageOverrides;
    /** Resolves the message for arbitrary caught errors (SDK load failures...) for this hook only. */
    resolveErrorMessage?: ErrorMessageResolver;
    /** Overrides the wording of dev-time console warnings for this hook only. */
    environmentWarnings?: EnvironmentWarningMessages;
}
/**
 * Return type for useBeninPay hook.
 */
interface UseBeninPayReturn {
    /** Function to initiate payment */
    pay: () => void;
    /** Whether the SDK is loading */
    loading: boolean;
    /** Error if SDK loading failed */
    error: Error | null;
    /** Whether SDK is ready */
    isReady: boolean;
    /** Current provider being used */
    provider: PaymentProvider;
    /** Whether running in mock mode */
    isMockMode: boolean;
    /** Whether backend verification is in progress */
    isVerifying: boolean;
    /** The most recent successful transaction, if any */
    lastTransaction: UnifiedPaymentResult | null;
    /** Whether async pre-validation is in progress */
    isPreparing: boolean;
}
/**
 * Universal payment hook that abstracts FedaPay and KKiaPay.
 *
 * Allows switching between payment providers without changing your code structure.
 * Provides a unified interface for both providers.
 *
 * @param config - Configuration including provider selection
 * @param options - Options for callbacks and modes
 * @returns Unified payment interface
 *
 * @example
 * ```tsx
 * import { useBeninPay } from "react-benin-payments";
 *
 * function PaymentButton() {
 *   // Easy provider switching - just change this value!
 *   const provider = useFeatureFlag("payment_provider") || "fedapay";
 *
 *   const { pay, loading, isReady } = useBeninPay(
 *     {
 *       provider,
 *       fedapay: { transaction: { amount: 5000 } },
 *       kkiapay: { amount: 5000 }
 *     },
 *     {
 *       onSuccess: (result) => {
 *         console.log(`Paid via ${provider}!`, result.transactionId);
 *       }
 *     }
 *   );
 *
 *   return (
 *     <button onClick={pay} disabled={loading || !isReady}>
 *       {loading ? "Loading..." : `Pay with ${provider}`}
 *     </button>
 *   );
 * }
 * ```
 *
 * @example
 * ```tsx
 * // Mock mode for testing
 * const { pay, isMockMode } = useBeninPay(
 *   { provider: "fedapay", fedapay: { transaction: { amount: 1000 } } },
 *   { mock: true }
 * );
 * ```
 */
declare function useBeninPay(config: UseBeninPayConfig, options?: UseBeninPayOptions): UseBeninPayReturn;

/**
 * Possible statuses for a transaction returned by your backend.
 */
type TransactionStatus = "pending" | "approved" | "declined" | "cancelled" | "unknown";
type PaymentStatusTransport = "polling" | "websocket";
interface PaymentStatusWebSocketLike {
    close: () => void;
    onopen: ((event: Event) => void) | null;
    onmessage: ((event: MessageEvent) => void) | null;
    onerror: ((event: Event) => void) | null;
    onclose: ((event: CloseEvent) => void) | null;
}
interface UsePaymentStatusWebSocketMessage {
    status?: TransactionStatus;
}
/**
 * Options for the usePaymentStatus hook.
 */
interface UsePaymentStatusOptions {
    /**
     * URL of your backend endpoint that returns the transaction status.
     * The hook sends: GET `checkUrl?transactionId=xxx&provider=yyy`
     * Expected response: `{ status: TransactionStatus }`
     * @example "/api/payments/status"
     */
    checkUrl?: string;
    /**
     * Transaction ID returned by FedaPay or KKiaPay after payment.
     */
    transactionId: string;
    /**
     * The payment provider used for this transaction.
     */
    provider: "fedapay" | "kkiapay";
    /**
     * How often to poll in milliseconds.
     * @default 3000
     */
    pollInterval?: number;
    /**
     * Transport used to follow status updates.
     * @default "polling"
     */
    transport?: PaymentStatusTransport;
    /**
     * WebSocket endpoint used when `transport` is `"websocket"`.
     * @example "wss://api.example.com/payments/status"
     */
    websocketUrl?: string;
    /**
     * Optional WebSocket protocols.
     */
    websocketProtocols?: string | string[];
    /**
     * Optional factory used to create the WebSocket instance.
     * Useful for tests or custom runtimes.
     */
    websocketFactory?: (url: string, protocols?: string | string[]) => PaymentStatusWebSocketLike;
    /**
     * Parses incoming WebSocket messages into a transaction status.
     * By default expects either a raw status string or `{ status: ... }`.
     */
    parseWebSocketMessage?: (event: MessageEvent) => TransactionStatus | UsePaymentStatusWebSocketMessage | null | undefined;
    /**
     * Maximum number of polling attempts before stopping.
     * Prevents infinite loops if the backend never returns a terminal status.
     * @default 10
     */
    maxAttempts?: number;
    /**
     * Custom headers to include in every status check request.
     * @example { "Authorization": "Bearer xxx" }
     */
    customHeaders?: Record<string, string>;
    /**
     * Called every time the status changes.
     * @param status - The new transaction status
     */
    onStatusChange?: (status: TransactionStatus) => void;
    /**
     * Whether to start polling immediately when the hook mounts.
     * Set to false to delay polling until you call startPolling().
     * @default true
     */
    enabled?: boolean;
    /**
     * Enable debug logs.
     * If not provided, uses the value from BeninPaymentProvider.
     * @default false
     */
    debug?: boolean;
}
/**
 * Return type for the usePaymentStatus hook.
 */
interface UsePaymentStatusReturn {
    /** Current transaction status returned by your backend */
    status: TransactionStatus;
    /** Whether a status check is currently in progress */
    loading: boolean;
    /** Error from the last failed check */
    error: Error | null;
    /** Total number of polling attempts made */
    attempts: number;
    /** Whether the polling loop is currently active */
    isPolling: boolean;
    /** Stop the polling loop */
    stopPolling: () => void;
    /** Resume polling (resets attempt counter and status to pending) */
    startPolling: () => void;
    /** Trigger a single immediate check without affecting the polling loop */
    refetch: () => void;
}
/**
 * Hook to poll your backend for a transaction status after payment.
 *
 * Automatically stops polling when a terminal status is reached
 * (approved, declined, cancelled) or when maxAttempts is exceeded.
 *
 * @example
 * ```tsx
 * // After a FedaPay payment completes:
 * const { status, isPolling, attempts } = usePaymentStatus({
 *   checkUrl: "/api/payments/status",
 *   transactionId: response.transaction.reference,
 *   provider: "fedapay",
 *   pollInterval: 3000,
 *   maxAttempts: 10,
 *   onStatusChange: (status) => {
 *     if (status === "approved") router.push("/success");
 *     if (status === "declined") router.push("/failed");
 *   },
 * });
 *
 * return (
 *   <div>
 *     {isPolling && <p>Vérification en cours... (tentative {attempts}/10)</p>}
 *     {status === "approved" && <p>Paiement confirmé !</p>}
 *     {status === "declined" && <p>Paiement refusé.</p>}
 *   </div>
 * );
 * ```
 */
declare function usePaymentStatus(options: UsePaymentStatusOptions): UsePaymentStatusReturn;

/**
 * Storage strategy for payment history.
 *
 * - `"memory"` — In-memory only. Cleared when the component unmounts or the
 *   page is refreshed. Best for ephemeral UX flows (default).
 * - `"session"` — Persisted in `sessionStorage`. Survives page reloads within
 *   the same browser tab, cleared when the tab/browser closes.
 * - `"local"` — Persisted in `localStorage`. Survives full browser restarts.
 *   Use when you want cross-session history (e.g. a receipts page).
 */
type PaymentHistoryStorage = "memory" | "session" | "local";
/**
 * A single entry in the payment history.
 * Extends UnifiedPaymentResult with audit fields.
 */
interface PaymentHistoryEntry extends UnifiedPaymentResult {
    /** ISO 8601 timestamp of when the payment was recorded */
    recordedAt: string;
    /** The payment provider used for this transaction */
    provider?: PaymentProvider;
}
/**
 * Options for the usePaymentHistory hook.
 */
interface UsePaymentHistoryOptions {
    /**
     * Storage strategy for persisting history.
     * @default "memory"
     */
    storage?: PaymentHistoryStorage;
    /**
     * Key to use in sessionStorage or localStorage.
     * Change this if you have multiple independent payment flows.
     * @default "rbp_payment_history"
     */
    storageKey?: string;
    /**
     * Maximum number of entries to keep.
     * When exceeded, the oldest entries are dropped.
     * @default 50
     */
    maxEntries?: number;
}
/**
 * Return type for the usePaymentHistory hook.
 */
interface UsePaymentHistoryReturn {
    /** Full list of recorded payments, ordered from most recent to oldest */
    history: PaymentHistoryEntry[];
    /** The most recently recorded payment, or `null` if history is empty */
    lastTransaction: PaymentHistoryEntry | null;
    /** Sum of all `amount` values across the recorded transactions */
    totalPaid: number;
    /** Number of entries in history */
    count: number;
    /**
     * Add a payment result to history.
     *
     * Automatically called by `useBeninPay` when integrated, but can be called
     * manually for advanced use-cases (e.g. recording a server-confirmed payment).
     *
     * Duplicate `transactionId` values are silently ignored.
     *
     * @param result - The UnifiedPaymentResult returned by useBeninPay's onSuccess
     * @param provider - The provider that processed the payment
     */
    addToHistory: (result: UnifiedPaymentResult, provider?: PaymentProvider) => void;
    /**
     * Remove a specific entry from history by its `transactionId`.
     * No-op if the ID is not found.
     */
    removeFromHistory: (transactionId: string) => void;
    /** Clear all entries from history (and from storage if applicable) */
    clearHistory: () => void;
}
/**
 * Hook for tracking payment history within a session or across sessions.
 *
 * Supports three storage strategies: in-memory (default), sessionStorage, and
 * localStorage. Automatically deduplicates entries by `transactionId` and
 * enforces a configurable `maxEntries` limit.
 *
 * @example
 * ```tsx
 * // Basic in-memory usage
 * const { history, lastTransaction, totalPaid, clearHistory } = usePaymentHistory();
 *
 * // Persist across page reloads within the tab
 * const { history } = usePaymentHistory({ storage: "session" });
 *
 * // Integrated with useBeninPay
 * const { addToHistory } = usePaymentHistory({ storage: "session" });
 *
 * const { pay } = useBeninPay(config, {
 *   onSuccess: (result) => addToHistory(result, "fedapay"),
 * });
 * ```
 *
 * @example
 * ```tsx
 * // Display a receipt list
 * const { history, totalPaid, count } = usePaymentHistory({ storage: "session" });
 *
 * return (
 *   <div>
 *     <p>{count} paiement(s) — Total : {formatXOF(totalPaid)}</p>
 *     <ul>
 *       {history.map((entry) => (
 *         <li key={entry.transactionId}>
 *           {entry.transactionId} — {formatXOF(entry.amount)} ({entry.status})
 *         </li>
 *       ))}
 *     </ul>
 *   </div>
 * );
 * ```
 */
declare function usePaymentHistory(options?: UsePaymentHistoryOptions): UsePaymentHistoryReturn;

interface UseRetryPaymentOptions<TResult = unknown> {
    /**
     * Nombre maximum de tentatives après le premier échec.
     * @default 3
     */
    maxRetries?: number;
    /**
     * Délai de base en millisecondes avant la première tentative de retry.
     * @default 1000
     */
    baseDelay?: number;
    /**
     * Facteur multiplicateur exponentiel pour le délai après chaque échec.
     * Exemple pour factor = 2, delay = 1000: 1000ms, 2000ms, 4000ms...
     * @default 2
     */
    backoffFactor?: number;
    /** Callback appelé avant chaque nouvelle tentative */
    onRetry?: (attempt: number, delayMs: number, error: unknown) => void;
    /** Callback appelé en cas de succès final */
    onSuccess?: (data: TResult) => void;
    /** Callback appelé quand toutes les tentatives sont épuisées */
    onFail?: (error: unknown) => void;
}
interface UseRetryPaymentReturn<TArgs extends unknown[], TResult> {
    /** Déclenche l'action asynchrone avec backoff en cas d'échec */
    execute: (...args: TArgs) => Promise<TResult | undefined>;
    /** Annule la tentative en cours et stoppe le retry */
    cancel: () => void;
    /** Indique si l'action (ou ses retrys) est en cours d'exécution */
    isPending: boolean;
    /** L'erreur du dernier échec rencontré */
    error: unknown | null;
    /** Le nombre de retrys effectués jusqu'à présent (0 si premier essai) */
    attemptCount: number;
}
/**
 * Hook utilitaire pour retenter automatiquement une action de paiement
 * (ex: vérification de statut API, initialisation asynchrone) avec
 * un système de délai exponentiel (exponential backoff).
 *
 * @example
 * ```tsx
 * const { execute, isPending, error, attemptCount } = useRetryPayment(
 *   async (transactionId) => {
 *     return await verifyOnMyBackend(transactionId);
 *   },
 *   {
 *     maxRetries: 3,
 *     baseDelay: 2000,
 *     onSuccess: (data) => console.log("Paiement validé !", data),
 *     onFail: (err) => console.error("Échec définitif", err),
 *     onRetry: (attempt, delay) => console.log(`Essai ${attempt} dans ${delay}ms`)
 *   }
 * );
 * ```
 */
declare function useRetryPayment<TArgs extends unknown[], TResult>(action: (...args: TArgs) => Promise<TResult>, options?: UseRetryPaymentOptions<TResult>): UseRetryPaymentReturn<TArgs, TResult>;

interface PaymentStatusBadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
    /** Le statut de la transaction à afficher */
    status: TransactionStatus;
    /** Surcharge des libellés par défaut pour chaque statut */
    labels?: Partial<Record<TransactionStatus, React.ReactNode>>;
    /** Surcharge des classes CSS spécifiques par statut (ex: Tailwind) */
    statusClasses?: Partial<Record<TransactionStatus, string>>;
    /** Si true, aucun style en ligne par défaut ne sera appliqué (Headless) */
    unstyled?: boolean;
}
/**
 * Composant visuel permettant d'afficher le statut d'un paiement.
 *
 * Il intègre des couleurs et libellés par défaut (en français) pour chaque statut.
 * Peut être utilisé en mode "Headless" (`unstyled={true}`) pour laisser
 * votre propre framework CSS (comme Tailwind) gérer le visuel via `statusClasses`.
 *
 * @example
 * // Mode par défaut (styles en ligne injectés)
 * <PaymentStatusBadge status="approved" />
 *
 * @example
 * // Mode Headless avec Tailwind CSS
 * <PaymentStatusBadge
 *   status="pending"
 *   unstyled
 *   className="px-3 py-1 rounded-full text-sm font-medium"
 *   statusClasses={{
 *     pending: "bg-yellow-100 text-yellow-800",
 *     approved: "bg-green-100 text-green-800"
 *   }}
 * />
 */
declare const PaymentStatusBadge: React.FC<PaymentStatusBadgeProps>;

export { type UsePaymentHistoryReturn as A, BeninPaymentProvider as B, type UseRetryPaymentOptions as C, type UseRetryPaymentReturn as D, PaymentStatusBadge as E, type PaymentStatusBadgeProps as F, type PaymentStatusTransport as P, type TransactionStatus as T, type UseFedaPayOptions as U, useIsBeninProviderMounted as a, type BeninPaymentConfig as b, type BeninPaymentProviderProps as c, useFedaPay as d, useKkiaPay as e, useBeninPay as f, usePaymentStatus as g, usePaymentHistory as h, useRetryPayment as i, type UseFedaPayReturn as j, type UseFedaPayConfig as k, type UseKkiaPayOptions as l, type UseKkiaPayReturn as m, type UseKkiaPayConfig as n, type UnifiedPaymentResult as o, type UseBeninPayConfig as p, type UseBeninPayOptions as q, type UseBeninPayReturn as r, type PaymentStatusWebSocketLike as s, type UsePaymentStatusWebSocketMessage as t, useBeninConfig as u, type UsePaymentStatusOptions as v, type UsePaymentStatusReturn as w, type PaymentHistoryStorage as x, type PaymentHistoryEntry as y, type UsePaymentHistoryOptions as z };