@solvapay/react 1.0.8-preview.6 → 1.0.8-preview.8

package/dist/index-Sj2lHLl8.d.cts

@@ -0,0 +1,798 @@
+import * as _stripe_stripe_js from '@stripe/stripe-js';
+import { PaymentIntent } from '@stripe/stripe-js';
+import { ActivatePlanResult, ProcessPaymentResult } from '@solvapay/server';
+import { AuthAdapter } from './adapters/auth.cjs';
+
+/**
+ * Typed copy bundle surfaced through `<SolvaPayProvider config={{ copy }} />`.
+ *
+ * Every user-visible string in `@solvapay/react` routes through this bundle via
+ * `useCopy()`. Values are either plain templates with `{placeholder}` tokens or
+ * function-form resolvers (currently only used for mandate variants) that
+ * receive a `MandateContext` and return the final string.
+ */
+type MandateContext = {
+    merchant: {
+        legalName: string;
+        displayName?: string;
+        supportEmail?: string;
+        termsUrl?: string;
+        privacyUrl?: string;
+    };
+    plan?: {
+        name?: string;
+        interval?: string;
+        intervalCount?: number;
+        trialDays?: number;
+        measures?: string;
+        billingCycle?: string;
+    };
+    product?: {
+        name?: string;
+    };
+    amountFormatted: string;
+    trialDays?: number;
+};
+type MandateTemplate = string | ((ctx: MandateContext) => string);
+interface SolvaPayCopy {
+    mandate: {
+        recurring: MandateTemplate;
+        oneTime: MandateTemplate;
+        topup: MandateTemplate;
+        usageMetered: MandateTemplate;
+        freeTier: MandateTemplate;
+    };
+    cta: {
+        payNow: string;
+        topUp: string;
+        subscribe: string;
+        trialStart: string;
+        payAmount: string;
+        addAmount: string;
+        startUsing: string;
+        processing: string;
+    };
+    interval: {
+        day: string;
+        week: string;
+        month: string;
+        year: string;
+        every: string;
+        free: string;
+        trial: string;
+    };
+    terms: {
+        checkboxLabel: string;
+    };
+    customer: {
+        chargingTo: string;
+        emailLabel: string;
+        nameLabel: string;
+    };
+    balance: {
+        credits: string;
+        currencyEquivalent: string;
+    };
+    product: {
+        currentProductLabel: string;
+    };
+    topup: {
+        selectOrEnterAmount: string;
+        minAmount: string;
+        maxAmount: string;
+    };
+    activation: {
+        paymentRequired: string;
+        invalidConfiguration: string;
+        unexpectedResponse: string;
+        failed: string;
+    };
+    planSelector: {
+        heading: string;
+        currentBadge: string;
+        popularBadge: string;
+        freeBadge: string;
+        perIntervalShort: string;
+        continueButton: string;
+        backButton: string;
+        trialBadge: string;
+    };
+    amountPicker: {
+        selectAmountLabel: string;
+        customAmountLabel: string;
+        creditEstimateExact: string;
+        creditEstimateApprox: string;
+    };
+    activationFlow: {
+        heading: string;
+        activateButton: string;
+        activatingLabel: string;
+        topupHeading: string;
+        topupSubheading: string;
+        continueToPayment: string;
+        changeAmountButton: string;
+        retryingHeading: string;
+        retryingSubheading: string;
+        activatedHeading: string;
+        activatedSubheading: string;
+        tryAgainButton: string;
+        backButton: string;
+    };
+    cancelPlan: {
+        button: string;
+        buttonLoading: string;
+        confirmRecurring: string;
+        confirmUsageBased: string;
+    };
+    cancelledNotice: {
+        heading: string;
+        expiresLabel: string;
+        daysRemaining: string;
+        dayRemaining: string;
+        accessUntil: string;
+        accessEnded: string;
+        cancelledOn: string;
+        reactivateButton: string;
+        reactivateButtonLoading: string;
+    };
+    creditGate: {
+        lowBalanceHeading: string;
+        lowBalanceSubheading: string;
+        topUpCta: string;
+    };
+    errors: {
+        paymentInitFailed: string;
+        topupInitFailed: string;
+        configMissingPlanOrProduct: string;
+        configMissingAmount: string;
+        unknownError: string;
+        stripeUnavailable: string;
+        paymentIntentUnavailable: string;
+        cardElementMissing: string;
+        paymentUnexpected: string;
+        paymentProcessingFailed: string;
+        paymentRequires3ds: string;
+        paymentProcessingTimeout: string;
+        paymentStatusPrefix: string;
+    };
+}
+/**
+ * Deep-partial type for consumer overrides — every nested key is optional so
+ * integrators can override only the strings they care about.
+ */
+type PartialSolvaPayCopy = {
+    [K in keyof SolvaPayCopy]?: Partial<SolvaPayCopy[K]>;
+};
+
+interface PurchaseInfo {
+    reference: string;
+    productName: string;
+    productRef?: string;
+    status: string;
+    startDate: string;
+    endDate?: string;
+    cancelledAt?: string;
+    cancellationReason?: string;
+    amount?: number;
+    currency?: string;
+    planType?: string;
+    isRecurring?: boolean;
+    nextBillingDate?: string;
+    billingCycle?: string;
+    planRef?: string;
+    planSnapshot?: {
+        reference?: string;
+        price?: number;
+        meterRef?: string;
+        limit?: number;
+        freeUnits?: number;
+        creditsPerUnit?: number;
+        planType?: string;
+        billingCycle?: string | null;
+        features?: Record<string, unknown> | null;
+    };
+    usage?: {
+        used: number;
+        overageUnits?: number;
+        overageCost?: number;
+        periodStart?: string;
+        periodEnd?: string;
+    };
+}
+interface CustomerPurchaseData {
+    customerRef?: string;
+    email?: string;
+    name?: string;
+    purchases: PurchaseInfo[];
+}
+interface PaymentIntentResult {
+    clientSecret: string;
+    publishableKey: string;
+    accountId?: string;
+    customerRef?: string;
+}
+/**
+ * Subset of merchant identity surfaced by `GET /v1/sdk/merchant`.
+ * Used by `<MandateText>` and customer-facing trust signals.
+ */
+interface Merchant {
+    displayName: string;
+    legalName: string;
+    supportEmail?: string;
+    supportUrl?: string;
+    termsUrl?: string;
+    privacyUrl?: string;
+    country?: string;
+    defaultCurrency?: string;
+    statementDescriptor?: string;
+    logoUrl?: string;
+}
+interface UseMerchantReturn {
+    merchant: Merchant | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface Product {
+    reference: string;
+    name?: string;
+    description?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+interface UseProductReturn {
+    product: Product | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+interface UsePlanOptions {
+    /** Plan reference (e.g. `'pln_premium'`). */
+    planRef?: string;
+    /**
+     * Optional product reference. When provided, the hook reuses the
+     * `usePlans` cache instead of fetching a dedicated plan endpoint.
+     */
+    productRef?: string;
+    /**
+     * Fetcher for plan lookup when `productRef` is not provided. Required in
+     * that mode so the hook stays dependency-free.
+     */
+    fetcher?: (productRef: string) => Promise<Plan[]>;
+}
+interface UsePlanReturn {
+    plan: Plan | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Optional customer fields forwarded to payment-intent creation so the
+ * backend customer record is authoritative. Read back via `useCustomer()`
+ * after the intent is created.
+ */
+interface PrefillCustomer {
+    name?: string;
+    email?: string;
+}
+interface TopupPaymentResult {
+    clientSecret: string;
+    publishableKey: string;
+    accountId?: string;
+    customerRef?: string;
+}
+interface UseTopupOptions {
+    amount: number;
+    currency?: string;
+}
+interface UseTopupReturn {
+    loading: boolean;
+    error: Error | null;
+    stripePromise: Promise<_stripe_stripe_js.Stripe | null> | null;
+    clientSecret: string | null;
+    startTopup: () => Promise<void>;
+    reset: () => void;
+}
+interface TopupFormProps {
+    amount: number;
+    currency?: string;
+    onSuccess?: (paymentIntent: PaymentIntent) => void;
+    onError?: (error: Error) => void;
+    returnUrl?: string;
+    submitButtonText?: string;
+    className?: string;
+    buttonClassName?: string;
+}
+interface PurchaseStatus {
+    loading: boolean;
+    /** True when data already exists but a background refetch is in progress */
+    isRefetching: boolean;
+    /** Last fetch error, or null if the most recent fetch succeeded */
+    error: Error | null;
+    customerRef?: string;
+    email?: string;
+    name?: string;
+    purchases: PurchaseInfo[];
+    hasProduct: (productName: string) => boolean;
+    /** @deprecated Use hasProduct instead */
+    hasPlan: (productName: string) => boolean;
+    /**
+     * Primary active purchase (paid or free) - most recent purchase with status === 'active'
+     * Backend keeps purchases as 'active' until expiration, even when cancelled.
+     * null if no active purchase exists
+     */
+    activePurchase: PurchaseInfo | null;
+    /**
+     * Check if user has any active paid purchase (amount > 0)
+     * Checks purchases with status === 'active'.
+     * Backend keeps purchases as 'active' until expiration, even when cancelled.
+     */
+    hasPaidPurchase: boolean;
+    /**
+     * Most recent active paid purchase (sorted by startDate)
+     * Returns purchase with status === 'active' and amount > 0.
+     * null if no active paid purchase exists
+     */
+    activePaidPurchase: PurchaseInfo | null;
+}
+/**
+ * SolvaPay Provider Configuration
+ * Sensible defaults for minimal code, but fully customizable
+ */
+interface BalanceStatus {
+    loading: boolean;
+    credits: number | null;
+    displayCurrency: string | null;
+    creditsPerMinorUnit: number | null;
+    displayExchangeRate: number | null;
+    refetch: () => Promise<void>;
+    adjustBalance: (credits: number) => void;
+}
+interface SolvaPayConfig {
+    /**
+     * API route configuration
+     * Defaults to standard Next.js API routes
+     */
+    api?: {
+        checkPurchase?: string;
+        createPayment?: string;
+        processPayment?: string;
+        createTopupPayment?: string;
+        customerBalance?: string;
+        cancelRenewal?: string;
+        reactivateRenewal?: string;
+        activatePlan?: string;
+        listPlans?: string;
+        getMerchant?: string;
+        getProduct?: string;
+    };
+    /**
+     * BCP-47 locale tag (e.g. 'en', 'sv-SE'). Threaded through every SDK
+     * component, `Intl.NumberFormat`, and Stripe Elements. Defaults to the
+     * runtime default (typically 'en').
+     */
+    locale?: string;
+    /**
+     * Partial copy overrides. Keys not supplied fall back to the bundled English
+     * defaults — consumers only provide the strings they actually want to change.
+     */
+    copy?: PartialSolvaPayCopy;
+    /**
+     * Authentication configuration
+     * Uses adapter pattern for flexible auth provider support
+     */
+    auth?: {
+        /**
+         * Auth adapter instance
+         * Default: checks localStorage for 'auth_token' key
+         *
+         * @example
+         * ```tsx
+         * import { createSupabaseAuthAdapter } from '@solvapay/react-supabase';
+         *
+         * <SolvaPayProvider
+         *   config={{
+         *     auth: {
+         *       adapter: createSupabaseAuthAdapter({
+         *         supabaseUrl: process.env.NEXT_PUBLIC_SUPABASE_URL!,
+         *         supabaseAnonKey: process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+         *       })
+         *     }
+         *   }}
+         * >
+         * ```
+         */
+        adapter?: AuthAdapter;
+        /**
+         * @deprecated Use `adapter` instead. Will be removed in a future version.
+         * Function to get auth token
+         */
+        getToken?: () => Promise<string | null>;
+        /**
+         * @deprecated Use `adapter` instead. Will be removed in a future version.
+         * Function to get user ID (for cache key)
+         */
+        getUserId?: () => Promise<string | null>;
+    };
+    /**
+     * Custom fetch implementation
+     * Default: uses global fetch
+     */
+    fetch?: typeof fetch;
+    /**
+     * Request headers to include in all API calls
+     * Default: empty
+     */
+    headers?: HeadersInit | (() => Promise<HeadersInit>);
+    /**
+     * Custom error handler
+     * Default: logs to console
+     */
+    onError?: (error: Error, context: string) => void;
+}
+interface CancelResult {
+    reference?: string;
+    status?: string;
+    cancelledAt?: string;
+    [key: string]: unknown;
+}
+interface ReactivateResult {
+    reference?: string;
+    status?: string;
+    [key: string]: unknown;
+}
+
+interface SolvaPayContextValue {
+    purchase: PurchaseStatus;
+    refetchPurchase: () => Promise<void>;
+    createPayment: (params: {
+        planRef?: string;
+        productRef?: string;
+        customer?: PrefillCustomer;
+    }) => Promise<PaymentIntentResult>;
+    processPayment?: (params: {
+        paymentIntentId: string;
+        productRef: string;
+        planRef?: string;
+    }) => Promise<ProcessPaymentResult>;
+    createTopupPayment: (params: {
+        amount: number;
+        currency?: string;
+    }) => Promise<TopupPaymentResult>;
+    cancelRenewal: (params: {
+        purchaseRef: string;
+        reason?: string;
+    }) => Promise<CancelResult>;
+    reactivateRenewal: (params: {
+        purchaseRef: string;
+    }) => Promise<ReactivateResult>;
+    activatePlan: (params: {
+        productRef: string;
+        planRef: string;
+    }) => Promise<ActivatePlanResult>;
+    customerRef?: string;
+    updateCustomerRef?: (newCustomerRef: string) => void;
+    balance: BalanceStatus;
+    /** @internal Provider config — used by SDK hooks, not part of public API */
+    _config?: SolvaPayConfig;
+}
+interface SolvaPayProviderProps {
+    /**
+     * Configuration object with sensible defaults
+     * If not provided, uses standard Next.js API routes
+     */
+    config?: SolvaPayConfig;
+    /**
+     * Custom API functions (override config defaults)
+     * Use only if you need custom logic beyond standard API routes
+     */
+    createPayment?: (params: {
+        planRef?: string;
+        productRef?: string;
+        customer?: PrefillCustomer;
+    }) => Promise<PaymentIntentResult>;
+    checkPurchase?: () => Promise<CustomerPurchaseData>;
+    processPayment?: (params: {
+        paymentIntentId: string;
+        productRef: string;
+        planRef?: string;
+    }) => Promise<ProcessPaymentResult>;
+    createTopupPayment?: (params: {
+        amount: number;
+        currency?: string;
+    }) => Promise<TopupPaymentResult>;
+    children: React.ReactNode;
+}
+interface ProductBadgeProps {
+    children?: (props: {
+        purchases: PurchaseInfo[];
+        loading: boolean;
+        displayPlan: string | null;
+        shouldShow: boolean;
+    }) => React.ReactNode;
+    as?: React.ElementType;
+    className?: string | ((props: {
+        purchases: PurchaseInfo[];
+    }) => string);
+}
+/** @deprecated Use ProductBadgeProps instead */
+type PlanBadgeProps = ProductBadgeProps;
+interface PurchaseGateProps {
+    /** @deprecated Use requireProduct instead */
+    requirePlan?: string;
+    requireProduct?: string;
+    children: (props: {
+        hasAccess: boolean;
+        purchases: PurchaseInfo[];
+        loading: boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Error type for payment operations
+ */
+interface PaymentError extends Error {
+    code?: string;
+    type?: string;
+}
+/**
+ * Plan returned by the SolvaPay API.
+ *
+ * All fields are optional except `reference` so the type stays compatible
+ * with partial JSON responses from custom fetcher functions.
+ */
+interface Plan {
+    type?: 'recurring' | 'one-time' | 'usage-based';
+    reference: string;
+    name?: string;
+    description?: string;
+    price?: number;
+    currency?: string;
+    currencySymbol?: string;
+    freeUnits?: number;
+    setupFee?: number;
+    trialDays?: number;
+    billingCycle?: string;
+    billingModel?: 'pre-paid' | 'post-paid';
+    creditsPerUnit?: number;
+    measures?: string;
+    limit?: number;
+    rolloverUnusedUnits?: boolean;
+    limits?: Record<string, unknown>;
+    features?: Record<string, unknown> | string[];
+    requiresPayment?: boolean;
+    default?: boolean;
+    isActive?: boolean;
+    maxActiveUsers?: number;
+    accessExpiryDays?: number;
+    status?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    interval?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for usePlans hook
+ */
+interface UsePlansOptions {
+    /**
+     * Fetcher function to retrieve plans
+     */
+    fetcher: (productRef: string) => Promise<Plan[]>;
+    /**
+     * Product reference to fetch plans for
+     */
+    productRef?: string;
+    /**
+     * Optional filter function to filter plans.
+     * Receives plan and its index (after sorting, if sortBy is provided).
+     */
+    filter?: (plan: Plan, index: number) => boolean;
+    /**
+     * Optional sort function to sort plans
+     */
+    sortBy?: (a: Plan, b: Plan) => number;
+    /**
+     * Auto-select first paid plan on load
+     */
+    autoSelectFirstPaid?: boolean;
+    /**
+     * Plan reference to select initially when plans load.
+     * Applied at most once when selectionReady is true.
+     * Takes priority over autoSelectFirstPaid.
+     */
+    initialPlanRef?: string;
+    /**
+     * When false, plans still fetch but auto-selection is deferred.
+     * When it transitions to true, one-shot initial selection fires.
+     * Defaults to true.
+     */
+    selectionReady?: boolean;
+}
+/**
+ * Return type for usePlans hook
+ */
+interface UsePlansReturn {
+    plans: Plan[];
+    loading: boolean;
+    error: Error | null;
+    selectedPlanIndex: number;
+    selectedPlan: Plan | null;
+    setSelectedPlanIndex: (index: number) => void;
+    selectPlan: (planRef: string) => void;
+    refetch: () => Promise<void>;
+    /** True after the one-shot initial selection has been applied */
+    isSelectionReady: boolean;
+}
+/**
+ * Props for headless PricingSelector component
+ */
+interface PricingSelectorProps {
+    /**
+     * Product reference to fetch plans for
+     */
+    productRef?: string;
+    /**
+     * Fetcher function to retrieve plans
+     */
+    fetcher: (productRef: string) => Promise<Plan[]>;
+    /**
+     * Optional filter function
+     */
+    filter?: (plan: Plan, index: number) => boolean;
+    /**
+     * Optional sort function
+     */
+    sortBy?: (a: Plan, b: Plan) => number;
+    /**
+     * Auto-select first paid plan on load
+     */
+    autoSelectFirstPaid?: boolean;
+    /**
+     * Render prop function
+     */
+    children: (props: UsePlansReturn & {
+        purchases: PurchaseInfo[];
+        isPaidPlan: (planRef: string) => boolean;
+        isCurrentPlan: (planRef: string) => boolean;
+    }) => React.ReactNode;
+}
+/**
+ * Return type for usePurchaseStatus hook
+ *
+ * Provides advanced purchase status helpers and utilities.
+ * Focuses on cancelled purchase logic and date formatting.
+ * For basic purchase data and paid status, use usePurchase() instead.
+ */
+interface PurchaseStatusReturn {
+    /**
+     * Most recent cancelled paid purchase (sorted by startDate)
+     * null if no cancelled paid purchase exists
+     */
+    cancelledPurchase: PurchaseInfo | null;
+    /**
+     * Whether to show cancelled purchase notice
+     * true if cancelledPurchase exists
+     */
+    shouldShowCancelledNotice: boolean;
+    /**
+     * Format a date string to locale format (e.g., "January 15, 2024")
+     * Returns null if dateString is not provided
+     */
+    formatDate: (dateString?: string) => string | null;
+    /**
+     * Calculate days until expiration date
+     * Returns null if endDate is not provided, otherwise returns days (0 or positive)
+     */
+    getDaysUntilExpiration: (endDate?: string) => number | null;
+}
+/**
+ * Payment form props - simplified and minimal
+ */
+/**
+ * Discriminated checkout-completion result surfaced by `<PaymentForm>` and
+ * `<CheckoutLayout>` via their `onResult` callback. Integrators handling
+ * both paid and free plans should use `onResult` to get a single typed
+ * callback; paid-only integrators keep using `onSuccess(paymentIntent)`.
+ */
+type PaymentResult = {
+    kind: 'paid';
+    paymentIntent: PaymentIntent;
+};
+type ActivationResult = {
+    kind: 'activated';
+    result: ActivatePlanResult;
+};
+type CheckoutResult = PaymentResult | ActivationResult;
+interface PaymentFormProps {
+    /**
+     * Plan reference to checkout. When omitted, the SDK auto-resolves the plan from
+     * productRef (requires exactly one active plan or a default plan). Pass explicitly
+     * when the product has multiple plans without a default.
+     */
+    planRef?: string;
+    /**
+     * Product reference. Required when planRef is omitted (for plan resolution)
+     * and for processing payment after confirmation.
+     */
+    productRef?: string;
+    /**
+     * Callback when payment succeeds. Fires on paid flows only — preserved
+     * exactly for backwards compatibility. Free/activation flows do NOT fire
+     * `onSuccess`; use `onResult` to receive both paid and activated results.
+     */
+    onSuccess?: (paymentIntent: PaymentIntent) => void;
+    /**
+     * Unified callback fired on both paid and activated completions with a
+     * discriminated result. Safe to provide alongside `onSuccess` — for paid
+     * flows both fire (in order: `onSuccess` first, then `onResult`).
+     */
+    onResult?: (result: CheckoutResult) => void;
+    /**
+     * Override the default free-plan activation step. When provided, the form
+     * awaits this promise on submit and fires `onResult` when it resolves.
+     * When omitted, the default behavior calls `activatePlan` from context.
+     */
+    onFreePlan?: (plan: Plan) => Promise<unknown> | void;
+    /**
+     * Callback when payment fails
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Return URL after payment completion. Defaults to current page URL if not provided.
+     */
+    returnUrl?: string;
+    /**
+     * Text for the submit button. Defaults to "Pay Now"
+     */
+    submitButtonText?: string;
+    /**
+     * Optional className for the form container
+     */
+    className?: string;
+    /**
+     * Optional className for the submit button
+     */
+    buttonClassName?: string;
+    /**
+     * Customer name/email to forward to backend PaymentIntent creation so the
+     * server-side customer record is authoritative. Echoed back via
+     * `useCustomer()` after the intent is created.
+     */
+    prefillCustomer?: PrefillCustomer;
+    /**
+     * When true, the default tree renders a terms/privacy checkbox and gates
+     * the submit button until it is ticked. No-op when custom `children` are
+     * passed — compose `<PaymentForm.TermsCheckbox />` yourself.
+     */
+    requireTermsAcceptance?: boolean;
+}
+interface BalanceBadgeProps {
+    className?: string;
+    numberOnly?: boolean;
+    children?: (props: {
+        credits: number | null;
+        loading: boolean;
+        displayCurrency: string | null;
+        creditsPerMinorUnit: number | null;
+    }) => React.ReactNode;
+}
+interface UseTopupAmountSelectorOptions {
+    currency: string;
+    minAmount?: number;
+    maxAmount?: number;
+}
+interface UseTopupAmountSelectorReturn {
+    quickAmounts: number[];
+    selectedAmount: number | null;
+    customAmount: string;
+    resolvedAmount: number | null;
+    selectQuickAmount: (amount: number) => void;
+    setCustomAmount: (value: string) => void;
+    error: string | null;
+    validate: () => boolean;
+    reset: () => void;
+    currencySymbol: string;
+}
+type PurchaseStatusValue = 'pending' | 'active' | 'trialing' | 'past_due' | 'cancelled' | 'expired' | 'suspended' | 'refunded';
+
+export type { ActivationResult as A, BalanceBadgeProps as B, CheckoutResult as C, PaymentError as D, PaymentIntentResult as E, PaymentResult as F, PlanBadgeProps as G, PurchaseStatusValue as H, SolvaPayConfig as I, TopupPaymentResult as J, MandateContext as M, Plan as P, ReactivateResult as R, SolvaPayProviderProps as S, TopupFormProps as T, UsePlansReturn as U, PaymentFormProps as a, PrefillCustomer as b, ProductBadgeProps as c, PurchaseGateProps as d, PricingSelectorProps as e, UseTopupAmountSelectorReturn as f, PurchaseInfo as g, PurchaseStatus as h, SolvaPayContextValue as i, UsePlansOptions as j, UsePlanOptions as k, UsePlanReturn as l, UseProductReturn as m, UseMerchantReturn as n, SolvaPayCopy as o, PurchaseStatusReturn as p, CancelResult as q, UseTopupOptions as r, UseTopupReturn as s, BalanceStatus as t, UseTopupAmountSelectorOptions as u, PartialSolvaPayCopy as v, Product as w, CustomerPurchaseData as x, MandateTemplate as y, Merchant as z };