@blocklet/payment-react-headless 1.26.0

package/.eslintrc.js

@@ -0,0 +1,18 @@
+const { join } = require('path');
+
+module.exports = {
+  root: true,
+  extends: '@arcblock/eslint-config-ts',
+  parserOptions: {
+    project: [join(__dirname, 'tsconfig.json')],
+  },
+  rules: {
+    '@typescript-eslint/comma-dangle': 'off',
+    '@typescript-eslint/no-use-before-define': 'off',
+    '@typescript-eslint/indent': 'off',
+    'import/prefer-default-export': 'off',
+    'unicorn/filename-case': 'off',
+    // Downgrade to warn: logical expressions like `data?.items || []` trigger false positives
+    'react-hooks/exhaustive-deps': 'warn',
+  },
+};

package/build.config.ts

@@ -0,0 +1,30 @@
+import { defineBuildConfig, BuildEntry } from 'unbuild';
+
+const pattern = ['**/*.ts', '**/*.tsx', '!**/*.spec.ts', '!**/*.test.ts'];
+
+const shared: BuildEntry = {
+  builder: 'mkdist',
+  input: './src',
+  pattern,
+  ext: 'js',
+  esbuild: {
+    jsx: 'automatic',
+  },
+  declaration: true,
+};
+
+export default defineBuildConfig({
+  failOnWarn: false,
+  entries: [
+    {
+      ...shared,
+      outDir: './es',
+      format: 'esm',
+    },
+    {
+      ...shared,
+      outDir: './lib',
+      format: 'cjs',
+    },
+  ],
+});

package/es/checkout/context/CheckoutProvider.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface CheckoutProviderProps {
+    sessionId: string;
+    children: React.ReactNode;
+}
+export declare function CheckoutProvider({ sessionId, children }: CheckoutProviderProps): JSX.Element;

package/es/checkout/context/CheckoutProvider.js

@@ -0,0 +1,209 @@
+import { jsx } from "react/jsx-runtime";
+import { useMemo, useState, useRef, useEffect } from "react";
+import { useMemoizedFn } from "ahooks";
+import { useCheckoutSession } from "../hooks/useCheckoutSession.js";
+import { usePaymentMethod as usePaymentMethodHook } from "../hooks/usePaymentMethod.js";
+import { useCustomerForm as useCustomerFormHook } from "../hooks/useCustomerForm.js";
+import { useSubmit as useSubmitHook } from "../hooks/useSubmit.js";
+import { checkHasDynamicPricing, fetchExchangeRate, BASE_INTERVAL } from "../core/exchangeRate.js";
+import { recalculatePromotionIfNeeded } from "../core/lineItems.js";
+import { SessionContext } from "./SessionContext.js";
+import { PaymentMethodContext } from "./PaymentMethodContext.js";
+import { ExchangeRateContext } from "./ExchangeRateContext.js";
+import { CustomerFormContext } from "./CustomerFormContext.js";
+import { SubmitReactContext } from "./SubmitContext.js";
+export function CheckoutProvider({ sessionId, children }) {
+  const {
+    isLoading,
+    error,
+    errorCode,
+    refresh,
+    setSessionData,
+    sessionData,
+    resolvedSessionId,
+    vendorCount,
+    product,
+    subscription,
+    pageInfo
+  } = useCheckoutSession(sessionId);
+  const session = sessionData?.checkoutSession;
+  const effectiveSessionId = resolvedSessionId || sessionId;
+  const items = session?.line_items || [];
+  const isDonation = session?.submit_type === "donate";
+  const sessionValue = useMemo(
+    () => ({
+      sessionData,
+      sessionId,
+      effectiveSessionId,
+      isLoading,
+      error,
+      errorCode,
+      refresh,
+      items,
+      session: session || null,
+      isDonation,
+      vendorCount,
+      product,
+      subscription,
+      pageInfo
+    }),
+    [
+      sessionData,
+      sessionId,
+      effectiveSessionId,
+      isLoading,
+      error,
+      errorCode,
+      refresh,
+      items,
+      session,
+      isDonation,
+      vendorCount,
+      product,
+      subscription,
+      pageInfo
+    ]
+  );
+  const paymentMethodHook = usePaymentMethodHook(sessionData, effectiveSessionId, refresh);
+  const prevCurrencyRef = useRef(null);
+  useEffect(() => {
+    const currId = paymentMethodHook.currency?.id || null;
+    if (!currId || !session || session.status === "complete") return;
+    if (prevCurrencyRef.current === null || currId !== prevCurrencyRef.current) {
+      prevCurrencyRef.current = currId;
+      recalculatePromotionIfNeeded(session, effectiveSessionId, currId).then(() => refresh(true));
+    }
+  }, [paymentMethodHook.currency?.id, session?.id]);
+  const paymentMethodValue = useMemo(
+    () => ({
+      current: paymentMethodHook.current,
+      currency: paymentMethodHook.currency,
+      available: paymentMethodHook.available,
+      currencies: paymentMethodHook.currencies,
+      isStripe: paymentMethodHook.isStripe,
+      isCrypto: paymentMethodHook.isCrypto,
+      isCredit: paymentMethodHook.isCredit,
+      switching: paymentMethodHook.switching,
+      setType: paymentMethodHook.setType,
+      types: paymentMethodHook.types,
+      setCurrency: paymentMethodHook.setCurrency,
+      stripe: paymentMethodHook.stripe
+    }),
+    [
+      paymentMethodHook.current,
+      paymentMethodHook.currency,
+      paymentMethodHook.available,
+      paymentMethodHook.currencies,
+      paymentMethodHook.isStripe,
+      paymentMethodHook.isCrypto,
+      paymentMethodHook.isCredit,
+      paymentMethodHook.switching,
+      paymentMethodHook.setType,
+      paymentMethodHook.types,
+      paymentMethodHook.setCurrency,
+      paymentMethodHook.stripe
+    ]
+  );
+  const [exchangeRate, setExchangeRate] = useState(null);
+  const [rateProvider, setRateProvider] = useState(null);
+  const [rateProviderDisplay, setRateProviderDisplay] = useState(null);
+  const [rateFetchedAt, setRateFetchedAt] = useState(null);
+  const [rateStatus, setRateStatus] = useState("loading");
+  const intervalRef = useRef(null);
+  const fetchingRef = useRef(false);
+  const mountedRef = useRef(true);
+  const hasDynamicPricing = useMemo(() => checkHasDynamicPricing(items), [items]);
+  const fetchRate = useMemoizedFn(async () => {
+    if (!effectiveSessionId || !hasDynamicPricing || paymentMethodHook.isStripe) {
+      setRateStatus(hasDynamicPricing ? "unavailable" : "available");
+      if (paymentMethodHook.isStripe) {
+        setExchangeRate(null);
+        setRateProvider(null);
+        setRateProviderDisplay(null);
+        setRateFetchedAt(null);
+      }
+      return;
+    }
+    if (fetchingRef.current) return;
+    fetchingRef.current = true;
+    try {
+      setRateStatus("loading");
+      const result = await fetchExchangeRate(effectiveSessionId, paymentMethodHook.currency?.id);
+      if (!mountedRef.current) return;
+      if (result.rate) {
+        setExchangeRate(result.rate);
+        setRateProvider(result.provider);
+        setRateProviderDisplay(result.providerDisplay);
+        setRateFetchedAt(result.fetchedAt);
+        setRateStatus("available");
+      } else {
+        setRateStatus("unavailable");
+      }
+    } catch {
+      if (!mountedRef.current) return;
+      setRateStatus("unavailable");
+    } finally {
+      fetchingRef.current = false;
+    }
+  });
+  useEffect(() => {
+    mountedRef.current = true;
+    if (!hasDynamicPricing || paymentMethodHook.isStripe || !effectiveSessionId || session?.status === "complete") {
+      if (paymentMethodHook.isStripe) {
+        setExchangeRate(null);
+        setRateProvider(null);
+        setRateProviderDisplay(null);
+        setRateFetchedAt(null);
+      }
+      if (session?.status === "complete") {
+        setRateStatus("available");
+      } else {
+        setRateStatus(hasDynamicPricing ? "unavailable" : "available");
+      }
+      return void 0;
+    }
+    fetchRate();
+    intervalRef.current = setInterval(fetchRate, BASE_INTERVAL);
+    const handleVisibility = () => {
+      if (!document.hidden) {
+        fetchRate();
+      }
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    return () => {
+      mountedRef.current = false;
+      if (intervalRef.current) clearInterval(intervalRef.current);
+      document.removeEventListener("visibilitychange", handleVisibility);
+    };
+  }, [hasDynamicPricing, paymentMethodHook.isStripe, effectiveSessionId, paymentMethodHook.currency?.id, session?.status]);
+  const exchangeRateValue = useMemo(
+    () => ({
+      rate: exchangeRate,
+      provider: rateProvider,
+      providerDisplay: rateProviderDisplay,
+      fetchedAt: rateFetchedAt,
+      status: rateStatus,
+      hasDynamicPricing,
+      refresh: fetchRate
+    }),
+    [exchangeRate, rateProvider, rateProviderDisplay, rateFetchedAt, rateStatus, hasDynamicPricing, fetchRate]
+  );
+  const customerForm = useCustomerFormHook(
+    sessionData,
+    paymentMethodHook.currency?.id || null,
+    paymentMethodHook.current?.id || null
+  );
+  const submit = useSubmitHook(
+    sessionData,
+    effectiveSessionId,
+    paymentMethodHook.currency?.id || null,
+    paymentMethodHook.isStripe,
+    paymentMethodHook.isCredit,
+    isDonation,
+    customerForm.values,
+    customerForm.validate,
+    refresh,
+    setSessionData
+  );
+  return /* @__PURE__ */ jsx(SessionContext.Provider, { value: sessionValue, children: /* @__PURE__ */ jsx(PaymentMethodContext.Provider, { value: paymentMethodValue, children: /* @__PURE__ */ jsx(ExchangeRateContext.Provider, { value: exchangeRateValue, children: /* @__PURE__ */ jsx(CustomerFormContext.Provider, { value: customerForm, children: /* @__PURE__ */ jsx(SubmitReactContext.Provider, { value: submit, children }) }) }) }) });
+}

package/es/checkout/context/CustomerFormContext.d.ts

@@ -0,0 +1,4 @@
+import type { UseCustomerFormReturn } from '../hooks/useCustomerForm';
+export type CustomerFormContextValue = UseCustomerFormReturn;
+export declare const CustomerFormContext: import("react").Context<UseCustomerFormReturn | null>;
+export declare function useCustomerFormContext(): CustomerFormContextValue;

package/es/checkout/context/CustomerFormContext.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "react";
+export const CustomerFormContext = createContext(null);
+export function useCustomerFormContext() {
+  const ctx = useContext(CustomerFormContext);
+  if (!ctx) {
+    throw new Error("useCustomerFormContext must be used within <CheckoutProvider>");
+  }
+  return ctx;
+}

package/es/checkout/context/ExchangeRateContext.d.ts

@@ -0,0 +1,11 @@
+export interface ExchangeRateContextValue {
+    rate: string | null;
+    provider: string | null;
+    providerDisplay: string | null;
+    fetchedAt: number | null;
+    status: 'loading' | 'available' | 'unavailable';
+    hasDynamicPricing: boolean;
+    refresh: () => Promise<void>;
+}
+export declare const ExchangeRateContext: import("react").Context<ExchangeRateContextValue | null>;
+export declare function useExchangeRateContext(): ExchangeRateContextValue;

package/es/checkout/context/ExchangeRateContext.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "react";
+export const ExchangeRateContext = createContext(null);
+export function useExchangeRateContext() {
+  const ctx = useContext(ExchangeRateContext);
+  if (!ctx) {
+    throw new Error("useExchangeRateContext must be used within <CheckoutProvider>");
+  }
+  return ctx;
+}

package/es/checkout/context/PaymentMethodContext.d.ts

@@ -0,0 +1,26 @@
+import type { TPaymentMethodExpanded, TPaymentCurrency } from '@blocklet/payment-types';
+export interface PaymentMethodContextValue {
+    current: TPaymentMethodExpanded;
+    currency: TPaymentCurrency;
+    available: TPaymentMethodExpanded[];
+    currencies: TPaymentCurrency[];
+    isStripe: boolean;
+    isCrypto: boolean;
+    isCredit: boolean;
+    switching: boolean;
+    setType: (type: 'stripe' | 'crypto') => Promise<void>;
+    types: Array<{
+        type: 'stripe' | 'crypto';
+        label: string;
+        currencies: TPaymentCurrency[];
+        active: boolean;
+    }>;
+    setCurrency: (currencyId: string) => Promise<void>;
+    stripe: {
+        publishableKey: string | null;
+        clientSecret: string | null;
+        status: 'idle' | 'ready' | 'processing' | 'succeeded' | 'failed';
+    } | null;
+}
+export declare const PaymentMethodContext: import("react").Context<PaymentMethodContextValue | null>;
+export declare function usePaymentMethodContext(): PaymentMethodContextValue;

package/es/checkout/context/PaymentMethodContext.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "react";
+export const PaymentMethodContext = createContext(null);
+export function usePaymentMethodContext() {
+  const ctx = useContext(PaymentMethodContext);
+  if (!ctx) {
+    throw new Error("usePaymentMethodContext must be used within <CheckoutProvider>");
+  }
+  return ctx;
+}

package/es/checkout/context/SessionContext.d.ts

@@ -0,0 +1,45 @@
+import type { TLineItemExpanded, TCheckoutSessionExpanded } from '@blocklet/payment-types';
+import type { SessionData } from '../hooks/useCheckoutSession';
+export interface SessionContextValue {
+    sessionData: SessionData | null;
+    sessionId: string;
+    effectiveSessionId: string;
+    isLoading: boolean;
+    error: string | null;
+    errorCode: 'SESSION_EXPIRED' | 'EMPTY_LINE_ITEMS' | null;
+    refresh: (forceRefresh?: boolean) => Promise<void>;
+    items: TLineItemExpanded[];
+    session: TCheckoutSessionExpanded | null | undefined;
+    isDonation: boolean;
+    vendorCount: number;
+    product: {
+        name: string;
+        description: string;
+        images: string[];
+        features: Array<{
+            name: string;
+            icon?: string;
+        }>;
+        billing: {
+            mode: 'payment' | 'subscription';
+            interval: 'month' | 'year' | 'week' | 'day' | null;
+            intervalCount: number;
+            displayInterval: string;
+        };
+        metadata: Record<string, string>;
+    } | null;
+    subscription: {
+        mode: 'payment' | 'subscription' | 'setup';
+        showStake: boolean;
+        confirmMessage: string;
+    } | null;
+    pageInfo: {
+        formPurposeDescription?: {
+            en: string;
+            zh: string;
+        };
+        showProductFeatures: boolean;
+    } | null;
+}
+export declare const SessionContext: import("react").Context<SessionContextValue | null>;
+export declare function useSessionContext(): SessionContextValue;

package/es/checkout/context/SessionContext.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "react";
+export const SessionContext = createContext(null);
+export function useSessionContext() {
+  const ctx = useContext(SessionContext);
+  if (!ctx) {
+    throw new Error("useSessionContext must be used within <CheckoutProvider>");
+  }
+  return ctx;
+}

package/es/checkout/context/SubmitContext.d.ts

@@ -0,0 +1,4 @@
+import type { UseSubmitReturn } from '../hooks/useSubmit';
+export type SubmitContextValue = UseSubmitReturn;
+export declare const SubmitReactContext: import("react").Context<UseSubmitReturn | null>;
+export declare function useSubmitContext(): SubmitContextValue;

package/es/checkout/context/SubmitContext.js

@@ -0,0 +1,9 @@
+import { createContext, useContext } from "react";
+export const SubmitReactContext = createContext(null);
+export function useSubmitContext() {
+  const ctx = useContext(SubmitReactContext);
+  if (!ctx) {
+    throw new Error("useSubmitContext must be used within <CheckoutProvider>");
+  }
+  return ctx;
+}

package/es/checkout/context/index.d.ts

@@ -0,0 +1,6 @@
+export { CheckoutProvider, type CheckoutProviderProps } from './CheckoutProvider';
+export { SessionContext, useSessionContext, type SessionContextValue } from './SessionContext';
+export { PaymentMethodContext, usePaymentMethodContext, type PaymentMethodContextValue } from './PaymentMethodContext';
+export { ExchangeRateContext, useExchangeRateContext, type ExchangeRateContextValue } from './ExchangeRateContext';
+export { CustomerFormContext, useCustomerFormContext, type CustomerFormContextValue } from './CustomerFormContext';
+export { SubmitReactContext, useSubmitContext, type SubmitContextValue } from './SubmitContext';

package/es/checkout/context/index.js

@@ -0,0 +1,6 @@
+export { CheckoutProvider } from "./CheckoutProvider.js";
+export { SessionContext, useSessionContext } from "./SessionContext.js";
+export { PaymentMethodContext, usePaymentMethodContext } from "./PaymentMethodContext.js";
+export { ExchangeRateContext, useExchangeRateContext } from "./ExchangeRateContext.js";
+export { CustomerFormContext, useCustomerFormContext } from "./CustomerFormContext.js";
+export { SubmitReactContext, useSubmitContext } from "./SubmitContext.js";

package/es/checkout/core/billingInterval.d.ts

@@ -0,0 +1,15 @@
+import type { TLineItemExpanded } from '@blocklet/payment-types';
+export type BillingIntervalType = 'month' | 'year' | 'week' | 'day';
+export interface BillingIntervalOption {
+    interval: BillingIntervalType;
+    priceId: string;
+    amount: string;
+    savings: string | null;
+}
+export interface BillingIntervalInfo {
+    current: BillingIntervalType | null;
+    available: BillingIntervalOption[];
+    /** The first item used to derive billing info */
+    firstItem: TLineItemExpanded;
+}
+export declare function parseBillingInterval(items: TLineItemExpanded[]): BillingIntervalInfo | null;

package/es/checkout/core/billingInterval.js

@@ -0,0 +1,36 @@
+export function parseBillingInterval(items) {
+  if (!items.length) return null;
+  const firstItem = items[0];
+  const price = firstItem.upsell_price || firstItem.price;
+  const recurring = price?.recurring;
+  if (!recurring) return null;
+  const currentInterval = recurring.interval;
+  const upsell = price?.upsell;
+  const upsellTo = upsell?.upsells_to;
+  const available = [];
+  if (upsellTo?.recurring?.interval && upsellTo.recurring.interval !== currentInterval) {
+    available.push({
+      interval: upsellTo.recurring.interval,
+      priceId: upsell?.upsells_to_id || "",
+      amount: upsellTo.unit_amount || "0",
+      savings: null
+    });
+  }
+  if (firstItem.upsell_price_id && firstItem.price?.recurring) {
+    const origInterval = firstItem.price.recurring.interval;
+    if (origInterval && origInterval !== currentInterval) {
+      available.push({
+        interval: origInterval,
+        priceId: firstItem.price_id,
+        amount: firstItem.price.unit_amount || "0",
+        savings: null
+      });
+    }
+  }
+  if (available.length === 0) return null;
+  return {
+    current: currentInterval,
+    available,
+    firstItem
+  };
+}

package/es/checkout/core/crossSell.d.ts

@@ -0,0 +1,4 @@
+import type { TCheckoutSessionExpanded, TPrice } from '@blocklet/payment-types';
+export declare function addCrossSellItem(sessionId: string, crossSellItemId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
+export declare function removeCrossSellItem(sessionId: string, session: TCheckoutSessionExpanded | undefined | null, currencyId: string | null | undefined, refresh: (force?: boolean) => Promise<void>): Promise<void>;
+export declare function fetchCrossSellItem(sessionId: string): Promise<TPrice | null>;

package/es/checkout/core/crossSell.js

@@ -0,0 +1,30 @@
+import api, { API } from "../../shared/api.js";
+import { recalculatePromotionIfNeeded } from "./lineItems.js";
+export async function addCrossSellItem(sessionId, crossSellItemId, session, currencyId, refresh) {
+  await api.put(API.CROSS_SELL(sessionId), { to: crossSellItemId });
+  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+  await refresh(true);
+}
+export async function removeCrossSellItem(sessionId, session, currencyId, refresh) {
+  await api.delete(API.CROSS_SELL(sessionId));
+  await recalculatePromotionIfNeeded(session, sessionId, currencyId);
+  await refresh(true);
+}
+const pendingFetches = /* @__PURE__ */ new Map();
+export function fetchCrossSellItem(sessionId) {
+  const existing = pendingFetches.get(sessionId);
+  if (existing) return existing;
+  const promise = (async () => {
+    try {
+      const { data } = await api.get(`${API.CROSS_SELL(sessionId)}?skipError=true`);
+      if (data && !data.error) {
+        return data;
+      }
+    } catch {
+    }
+    return null;
+  })();
+  pendingFetches.set(sessionId, promise);
+  promise.finally(() => pendingFetches.delete(sessionId));
+  return promise;
+}

package/es/checkout/core/customerForm.d.ts

@@ -0,0 +1,5 @@
+import type { TCheckoutSessionExpanded, TCustomer } from '@blocklet/payment-types';
+import type { FieldConfig, CheckoutFormData } from '../types';
+export declare function buildFields(session: TCheckoutSessionExpanded | undefined | null): FieldConfig[];
+export declare function createInitialValues(session: TCheckoutSessionExpanded | undefined | null, customer: TCustomer | undefined | null): CheckoutFormData;
+export declare function setNestedValue<T extends Record<string, unknown>>(obj: T, path: string, value: unknown): T;

package/es/checkout/core/customerForm.js

@@ -0,0 +1,105 @@
+export function buildFields(session) {
+  const fields = [];
+  fields.push({
+    name: "customer_name",
+    type: "text",
+    required: true
+  });
+  fields.push({
+    name: "customer_email",
+    type: "email",
+    required: true
+  });
+  if (session?.phone_number_collection?.enabled) {
+    fields.push({
+      name: "customer_phone",
+      type: "phone",
+      required: true
+    });
+  }
+  const addressMode = session?.billing_address_collection;
+  if (addressMode === "required") {
+    fields.push(
+      {
+        name: "billing_address.country",
+        type: "country",
+        required: true,
+        group: "address"
+      },
+      {
+        name: "billing_address.line1",
+        type: "text",
+        required: true,
+        group: "address"
+      },
+      {
+        name: "billing_address.line2",
+        type: "text",
+        required: false,
+        group: "address"
+      },
+      {
+        name: "billing_address.city",
+        type: "text",
+        required: true,
+        group: "address"
+      },
+      {
+        name: "billing_address.state",
+        type: "text",
+        required: true,
+        group: "address"
+      },
+      {
+        name: "billing_address.postal_code",
+        type: "text",
+        required: true,
+        group: "address"
+      }
+    );
+  } else if (addressMode === "auto") {
+    fields.push(
+      {
+        name: "billing_address.state",
+        type: "text",
+        required: false,
+        group: "address"
+      },
+      {
+        name: "billing_address.postal_code",
+        type: "text",
+        required: false,
+        group: "address"
+      }
+    );
+  }
+  return fields;
+}
+export function createInitialValues(session, customer) {
+  return {
+    customer_name: customer?.name || "",
+    customer_email: session?.customer_details?.email || customer?.email || "",
+    customer_phone: customer?.phone || "",
+    payment_method: "",
+    payment_currency: session?.currency_id || "",
+    billing_address: {
+      country: customer?.address?.country || "",
+      state: customer?.address?.state || "",
+      city: customer?.address?.city || "",
+      line1: customer?.address?.line1 || "",
+      line2: customer?.address?.line2 || "",
+      postal_code: customer?.address?.postal_code || ""
+    }
+  };
+}
+export function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  if (parts.length === 1) {
+    return { ...obj, [path]: value };
+  }
+  const [head, ...rest] = parts;
+  return {
+    ...obj,
+    [head]: setNestedValue(obj[head] || {}, rest.join("."), value)
+  };
+}

package/es/checkout/core/exchangeRate.d.ts

@@ -0,0 +1,11 @@
+import type { TLineItemExpanded } from '@blocklet/payment-types';
+export declare const BASE_INTERVAL = 30000;
+export declare const MAX_INTERVAL = 120000;
+export declare function checkHasDynamicPricing(items: TLineItemExpanded[]): boolean;
+export declare function fetchExchangeRate(sessionId: string, currencyId: string | null | undefined): Promise<{
+    rate: string | null;
+    provider: string | null;
+    providerDisplay: string | null;
+    fetchedAt: number | null;
+}>;
+export declare function getBackoffInterval(failCount: number): number;