@funkit/connect 0.0.0-20260710210119

package/dist/modals/CheckoutModal/LoadingAccount.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { type ConnectablePaymentMethodInfo, PaymentMethod, type PaymentMethodAccountInfo, type PaymentMethodBrokerageInfo, type PaymentMethodVirtualBankInfo } from '../../domains/paymentMethods';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from './stepTransition';
+export type LoadingAccountState = CheckoutModalCommonState;
+export type LoadingAccountNext = {
+    chosenPaymentMethod: PaymentMethod.ACCOUNT_BALANCE;
+    paymentMethodInfo: PaymentMethodAccountInfo;
+} | {
+    chosenPaymentMethod: PaymentMethod.BROKERAGE;
+    paymentMethodInfo: PaymentMethodBrokerageInfo;
+} | {
+    chosenPaymentMethod: PaymentMethod.VIRTUAL_BANK;
+    paymentMethodInfo: PaymentMethodVirtualBankInfo;
+} | {
+    /** Can be set to null to skip auto payment method selection */
+    chosenPaymentMethod: null | PaymentMethod.TOKEN_TRANSFER;
+    paymentMethodInfo?: ConnectablePaymentMethodInfo;
+};
+export declare const LoadingAccountInfo: ModalStepInfo<FunCheckoutStep.LOADING_ACCOUNT>;
+/** A placeholder component to handle redirecting to the checkout history page */
+export declare function LoadingAccount({ modalState, onClose, onNext, }: ModalStepComponentProps<FunCheckoutStep.LOADING_ACCOUNT>): React.JSX.Element;

package/dist/modals/CheckoutModal/MeldCurrencySelect/MeldCurrencySelect.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { PaymentMethodCardInfo } from '../../../domains/paymentMethods';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type MeldCurrencySelectState = CheckoutModalCommonState & {
+    defaultCurrency: string;
+    paymentMethodInfo: PaymentMethodCardInfo;
+};
+export type MeldCurrencySelectNext = {
+    currency: string;
+};
+export declare const MeldCurrencySelectInfo: ModalStepInfo<FunCheckoutStep.MELD_CURRENCY_SELECT>;
+export declare function MeldCurrencySelect({ modalState, onNext, }: ModalStepComponentProps<FunCheckoutStep.MELD_CURRENCY_SELECT>): React.JSX.Element;

package/dist/modals/CheckoutModal/MeldCurrencySelect/currenciesWithMultipleCountries.d.ts

@@ -0,0 +1 @@
+export declare const currenciesWithMultipleCountries: Record<string, string[]>;

package/dist/modals/CheckoutModal/MeldCurrencySelect/utils.d.ts

@@ -0,0 +1 @@
+export declare const getFlagEmoji: (currencyCode: string) => string;

package/dist/modals/CheckoutModal/MeldQuotes/MeldQuotes.d.ts

@@ -0,0 +1,16 @@
+import type { MeldQuote, MeldServiceProvider } from '@funkit/api-base';
+import React from 'react';
+import type { PaymentMethodCardInfo } from '../../../domains/paymentMethods';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type MeldQuotesState = CheckoutModalCommonState & {
+    paymentMethodInfo: PaymentMethodCardInfo;
+    /** Checkout amount in fiat */
+    fiatAmount: number | undefined;
+    fiatCurrency: string | undefined;
+    provider?: MeldServiceProvider;
+};
+export type MeldQuotesNext = Record<string, never> | {
+    quote: MeldQuote;
+};
+export declare const MeldQuotesInfo: ModalStepInfo<FunCheckoutStep.MELD_QUOTES>;
+export declare function MeldQuotes({ modalState, onNext, }: ModalStepComponentProps<FunCheckoutStep.MELD_QUOTES>): React.JSX.Element;

package/dist/modals/CheckoutModal/MeldQuotes/useMeldLink.d.ts

@@ -0,0 +1,2 @@
+import { type MeldServiceProvider } from '@funkit/api-base';
+export declare const useMeldLink: (sourceAmount: number, sourceCurrencyCode?: string) => import("@tanstack/react-query").UseMutationResult<import("@funkit/api-base").MeldCreateCryptoWidgetResponse, Error, MeldServiceProvider, unknown>;

package/dist/modals/CheckoutModal/MeldQuotes/useMeldQuotes.d.ts

@@ -0,0 +1,16 @@
+import { type MeldQuote } from '@funkit/api-base';
+import { type UseQueryResult } from '@tanstack/react-query';
+import type { ReactNode } from 'react';
+/**
+ * Triggered only when fiatCurrency is provided.
+ *
+ * - The source amount is debounced.
+ * - Query errors are discarded while the input amount is not equal to its debounced value.
+ * - In that case, `isOutdated` is also set to `true`.
+ */
+export declare const useMeldQuotes: (sourceAmount: number | undefined, fiatCurrency: string | undefined, meldEnabled?: boolean) => {
+    countdown: ReactNode;
+    query: UseQueryResult<MeldQuote[]> & {
+        isOutdated: boolean;
+    };
+};

package/dist/modals/CheckoutModal/MeldRedirect/MeldRedirect.d.ts

@@ -0,0 +1,14 @@
+import type { MeldQuote } from '@funkit/api-base';
+import React from 'react';
+import type { PaymentMethodCardInfo } from '../../../domains/paymentMethods';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type MeldRedirectState = CheckoutModalCommonState & {
+    paymentMethodInfo: PaymentMethodCardInfo;
+    /** Checkout amount in fiat */
+    fiatAmount: number | undefined;
+    fiatCurrency: string | undefined;
+    quote: MeldQuote;
+};
+export type MeldRedirectNext = Record<string, never>;
+export declare const MeldRedirectInfo: ModalStepInfo<FunCheckoutStep.MELD_REDIRECT>;
+export declare function MeldRedirect({ modalState, }: ModalStepComponentProps<FunCheckoutStep.MELD_REDIRECT>): React.JSX.Element;

package/dist/modals/CheckoutModal/SelectAsset/SelectAsset.d.ts

@@ -0,0 +1,18 @@
+import type { IndexedDynamicRoutingConfig } from '@funkit/fun-relay';
+import React from 'react';
+import { type PaymentMethodAccountInfo, type PaymentMethodBrokerageInfo } from '../../../domains/paymentMethods';
+import type { AssetHoldingsItem } from '../../../domains/wallet';
+import type { TransferTokenDefault } from '../../../hooks/useTokenAndChainDropdown';
+import { type DynamicTargetAssetCandidate } from '../../../providers/FunkitCheckoutContext';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type SelectAssetState = CheckoutModalCommonState & {
+    paymentMethodInfo: PaymentMethodBrokerageInfo | PaymentMethodAccountInfo;
+};
+export type SelectAssetNext = {
+    paymentMethodInfo?: PaymentMethodBrokerageInfo | PaymentMethodAccountInfo;
+    disconnectedBrokerage?: boolean;
+    transferToken?: TransferTokenDefault;
+};
+export declare const SelectAssetInfo: ModalStepInfo<FunCheckoutStep.SELECT_ASSET>;
+export declare function SelectAsset({ modalState, onNext, onClose, }: ModalStepComponentProps<FunCheckoutStep.SELECT_ASSET>): React.JSX.Element;
+export declare function isTreatedAsNativeToken(apiKey: string, asset: AssetHoldingsItem, dynamicTargetAssetCandidates: DynamicTargetAssetCandidate[], findDynamicPath: IndexedDynamicRoutingConfig[string]['findPath'], isUserSelected: boolean, isDirectTokenTransfer?: boolean): boolean;

package/dist/modals/CheckoutModal/SelectAsset/SelectAssetInfoSection.d.ts

@@ -0,0 +1,12 @@
+import { type FC } from 'react';
+import type { PaymentMethodInfo } from '../../../domains/paymentMethods';
+import type { TransferTokenDefault } from '../../../hooks/useTokenAndChainDropdown';
+interface SelectAssetInfoSectionProps {
+    totalBalance: number;
+    paymentMethodInfo: PaymentMethodInfo;
+    onTokenTransfer: (transferToken: TransferTokenDefault) => void;
+    onSelectSource: () => void;
+    isSourceNavWidgetEnabled: boolean;
+}
+export declare const SelectAssetInfoSection: FC<SelectAssetInfoSectionProps>;
+export {};

package/dist/modals/CheckoutModal/SelectAsset/SelectAssetList.d.ts

@@ -0,0 +1,24 @@
+import { type FC } from 'react';
+import { type PaymentMethodInfo } from '../../../domains/paymentMethods';
+import type { AssetHoldingsItem } from '../../../domains/wallet';
+interface AssetOption {
+    asset: AssetHoldingsItem;
+    badgeText: string;
+    isDisabled: boolean;
+    isUserSelected: boolean;
+    priority: number;
+    minUsdWithFees?: number;
+}
+interface SelectAssetListProps {
+    isLoading: boolean;
+    assetOptions: AssetOption[];
+    selectedChainTokenSymbol: string | undefined;
+    paymentMethodInfo: PaymentMethodInfo;
+    navigateOnAssetClick: boolean;
+    onBalanceTopUpSwitch?: () => void;
+    onClose?: () => void;
+    onAssetSelect: (chainSymbolKey: string) => void;
+    onContinueWithToken: () => void;
+}
+export declare const SelectAssetList: FC<SelectAssetListProps>;
+export {};

package/dist/modals/CheckoutModal/SourceChange/ComplianceReviewBanner.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ComplianceReviewBannerProps {
+    checkoutId: string;
+}
+export declare function ComplianceReviewBanner({ checkoutId, }: ComplianceReviewBannerProps): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/SourceChange/ConnectedSource.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type ConnectablePaymentMethodInfo } from '../../../domains/paymentMethods';
+interface ConnectedSourceProps {
+    targetChainId: string;
+    paymentInfo: ConnectablePaymentMethodInfo;
+    selectedPaymentInfo: ConnectablePaymentMethodInfo | null;
+    showSelectedCheckmark?: boolean;
+    onSelect: () => void;
+    isDisabled?: boolean;
+}
+export declare const ConnectedSource: ({ paymentInfo, targetChainId, selectedPaymentInfo, showSelectedCheckmark, onSelect, isDisabled, }: ConnectedSourceProps) => React.JSX.Element | null;
+export {};

package/dist/modals/CheckoutModal/SourceChange/CryptoCashToggle.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import { type BoxProps } from '../../../components/Box/Box';
+import type { PaymentMethodType } from '../../../hooks/usePaymentSources';
+interface CryptoCashToggleProps {
+    activeTab: PaymentMethodType;
+    disabled?: boolean;
+    onTabChange: (tab: PaymentMethodType) => void;
+    marginTop?: BoxProps['marginTop'];
+    marginBottom?: BoxProps['marginBottom'];
+    style?: React.CSSProperties;
+    tabs: PaymentMethodType[];
+}
+export declare const CryptoCashToggle: ({ activeTab, disabled, onTabChange, marginTop, marginBottom, style, tabs: tabTypes, }: CryptoCashToggleProps) => React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/SourceChange/FlatList.d.ts

@@ -0,0 +1,31 @@
+import React, { type ReactNode } from 'react';
+import type { SourceGroup } from './buildSourceGroups';
+interface FlatListProps {
+    groups: SourceGroup[];
+    /**
+     * Class name applied to the outer Box that holds the groups.
+     * Caller decides between standard / compact styling so the renderer
+     * doesn't reach into FunkitConfig.
+     */
+    boxClassName: string;
+    /**
+     * Label rendered on the `FunDivider` between adjacent groups.
+     * Omit to render the divider without a label.
+     */
+    dividerLabel?: string;
+    /**
+     * Trailing content rendered after the groups, inside the outer Box.
+     * Used by the source-list flat layout to place PayPal at the
+     * bottom of the box.
+     */
+    footer?: ReactNode;
+    /** Applied as `data-testid` on the outer Box for snapshot scoping. */
+    testId?: string;
+}
+/**
+ * Pure presentational primitive: a single column of group bodies with
+ * a divider between adjacent groups and an optional footer. No
+ * provider/context dependencies — composition lives in the caller.
+ */
+export declare function FlatList({ groups, boxClassName, dividerLabel, footer, testId, }: FlatListProps): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/SourceChange/FormOfPaymentsList.d.ts

@@ -0,0 +1,49 @@
+import type { ExchangeRates, GetFopsResponse, SavedFormOfPayment, SwappedFormOfPayment } from '@funkit/api-base';
+import type { ListFormOfPayment, SyntheticFormOfPayment } from '@funkit/connect-core';
+import React, { type ReactNode } from 'react';
+/** FOP list normalized to hold real (Swapped) and synthetic methods together. */
+interface ListFopsData {
+    genericFormsOfPayments: ListFormOfPayment[];
+    savedFormsOfPayments: SavedFormOfPayment[];
+}
+interface FormOfPaymentsListProps {
+    fopsData?: GetFopsResponse;
+    isLoading: boolean;
+    selectedFop?: ListFormOfPayment | null;
+    /**
+     * Non-Swapped methods (e.g. Cash App Lightning) to interleave into the list.
+     * They flow through the same sort/section/slice machinery as real FOPs.
+     */
+    syntheticFops?: SyntheticFormOfPayment[];
+    onSelect: (fop: ListFormOfPayment) => void;
+    exchangeRatesData?: ExchangeRates;
+    enableSourceGroupLabels: boolean;
+    isDisabled?: boolean;
+    /**
+     * Maps a FOP to its disclaimer-limit string. Defaults to the rounded deposit
+     * limit (getFopsLimit). Return undefined to omit the limit and show only the
+     * processing time (the withdrawal off-ramp hides limits).
+     */
+    getDisclaimerLimit?: (fop: SwappedFormOfPayment, exchangeRates: ExchangeRates | undefined) => string | undefined;
+    /**
+     * Withdrawal off-ramp only: balance is below the cash sell minimum, so every
+     * cash method is disabled with a "Low Balance" badge. A single flag is enough
+     * while all providers share one minimum — switch to a `(fop) => boolean`
+     * predicate if per-provider minimums ever diverge.
+     */
+    isBelowMinimumBalance?: boolean;
+    /**
+     * Rendered above FOPs within a same list
+     */
+    cryptoPaymentMethodItem?: ReactNode;
+}
+interface FormOfPaymentSection {
+    items: ListFormOfPayment[];
+    labelKey: 'sourceChange.mostPopular' | 'sourceChange.savedPaymentMethods' | 'sourceChange.moreOptions';
+}
+export declare function getFormOfPaymentSections(fopsData: ListFopsData, fopPriority: readonly string[]): {
+    primary: FormOfPaymentSection;
+    secondary: FormOfPaymentSection;
+};
+export declare function FormOfPaymentsList({ fopsData, isLoading, selectedFop, syntheticFops, onSelect, exchangeRatesData, getDisclaimerLimit, enableSourceGroupLabels, isDisabled, isBelowMinimumBalance, cryptoPaymentMethodItem, }: FormOfPaymentsListProps): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/SourceChange/FormOfPaymentsListLoading.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const FormOfPaymentsListLoading: ({ className, count, enableSourceGroupLabels, }: {
+    className: string;
+    count?: number;
+    enableSourceGroupLabels: boolean;
+}) => React.JSX.Element;

package/dist/modals/CheckoutModal/SourceChange/GroupedList.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { SourceGroup } from './buildSourceGroups';
+interface GroupedListProps {
+    groups: SourceGroup[];
+    /**
+     * Render each group's `label` as a section header when true. False
+     * skips the headers but keeps the grouped container styling.
+     */
+    showLabels: boolean;
+    /**
+     * Class name applied to the inner box that holds each group's
+     * children. Caller decides between standard / compact styling so the
+     * renderer doesn't reach into FunkitConfig.
+     */
+    boxClassName: string;
+    /** Applied as `data-testid` on the outer Box for snapshot scoping. */
+    testId?: string;
+}
+/**
+ * Pure presentational primitive: groups rendered as separate boxes
+ * inside a grouped container, with optional section labels. No
+ * provider/context dependencies — composition lives in the caller.
+ */
+export declare function GroupedList({ groups, showLabels, boxClassName, testId, }: GroupedListProps): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/SourceChange/PayPal.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function PayPal(): React.JSX.Element | null;

package/dist/modals/CheckoutModal/SourceChange/SourceChange.d.ts

@@ -0,0 +1,84 @@
+import { type SwappedFormOfPayment } from '@funkit/api-base';
+import React from 'react';
+import type { Hex } from 'viem';
+import { type ConnectablePaymentMethodInfo, PaymentMethod, type PaymentMethodBitcoinLightningInfo, type PaymentMethodCardInfo, type PaymentMethodCashAppLightningInfo, type PaymentMethodVirtualBankIncompleteInfo } from '../../../domains/paymentMethods';
+import type { FunkitCheckoutQuoteResult } from '../../../domains/quote';
+import { type PaymentMethodType } from '../../../hooks/usePaymentSources';
+import { type CustomWithdrawalConfig, type WalletWithdrawalConfig } from '../../../providers/FunkitCheckoutContext';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type SourceChangeState = CheckoutModalCommonState & {
+    paymentMethodInfo: ConnectablePaymentMethodInfo | null;
+    /** Persisted payment method type filter (crypto/fiat tab) */
+    paymentMethodTypeFilter?: PaymentMethodType;
+    /**
+     * Resolved single-method withdrawal config, seeded while the Withdraw tab is
+     * open so the modal-level effect in `FunCheckoutModal` can enter withdrawal
+     * mode in lockstep with the tab — the withdraw tab may render withdrawal-mode
+     * UI while still on SourceChange. Cleared when leaving the tab so the effect
+     * reverts back to deposit mode. Read only by that effect.
+     */
+    withdrawalConfig?: WalletWithdrawalConfig | CustomWithdrawalConfig;
+};
+export type SourceChangeNext = {
+    connectNew: false;
+    paymentMethodInfo: ConnectablePaymentMethodInfo;
+    brokerageFailed: false;
+} | {
+    connectNew: true;
+    paymentMethod: Exclude<PaymentMethod, PaymentMethod.CARD | PaymentMethod.VIRTUAL_BANK | PaymentMethod.BITCOIN_LIGHTNING | PaymentMethod.CASH_APP_LIGHTNING>;
+    brokerageFailed: false;
+} | {
+    connectNew: true;
+    paymentMethod: PaymentMethod.BITCOIN_LIGHTNING;
+    paymentMethodInfo: PaymentMethodBitcoinLightningInfo;
+    brokerageFailed: false;
+} | {
+    connectNew: true;
+    paymentMethod: PaymentMethod.CASH_APP_LIGHTNING;
+    paymentMethodInfo: PaymentMethodCashAppLightningInfo;
+    brokerageFailed: false;
+} | {
+    connectNew: true;
+    paymentMethod: PaymentMethod.VIRTUAL_BANK;
+    paymentMethodInfo: PaymentMethodVirtualBankIncompleteInfo;
+    brokerageFailed: false;
+} | {
+    connectNew: true;
+    paymentMethod: PaymentMethod.CARD;
+    paymentMethodInfo: PaymentMethodCardInfo;
+    brokerageFailed: false;
+} | {
+    brokerageFailed: true;
+    paymentMethodInfo: ConnectablePaymentMethodInfo;
+} | {
+    /** Navigate to Swapped iframe with a selected payment option */
+    swappedIframe: true;
+    selectedPaymentOption: SwappedFormOfPayment;
+    /** Payment method type filter to restore when returning */
+    paymentMethodTypeFilter: PaymentMethodType;
+} | {
+    /**
+     * Skip the asset-select screen; land on InputAmount with the
+     * source asset pre-set on the checkout context. Used by the
+     * Native fast-path row.
+     */
+    skipAssetSelect: true;
+    paymentMethodInfo: ConnectablePaymentMethodInfo;
+} | {
+    /** Enter the cashier withdrawal flow with a resolved single-method config. */
+    withdraw: true;
+    withdrawalConfig: WalletWithdrawalConfig | CustomWithdrawalConfig;
+} | {
+    /**
+     * Inline withdrawal (swapped-withdrawal flag off): the amount form is
+     * rendered directly in the Withdraw tab, so on success we jump straight
+     * to the completion screen rather than through WITHDRAWAL_ENTER_AMOUNT.
+     */
+    withdrawComplete: true;
+    hash: Hex;
+    withdrawnAmount: string;
+    tokenSymbol: string;
+    quote?: FunkitCheckoutQuoteResult;
+};
+export declare const SourceChangeInfo: ModalStepInfo<FunCheckoutStep.SOURCE_CHANGE>;
+export declare function SourceChange({ modalState, onClose, onNext, onStepChange, setModalState, }: ModalStepComponentProps<FunCheckoutStep.SOURCE_CHANGE>): React.JSX.Element;

package/dist/modals/CheckoutModal/SourceChange/SourceChangeLoading.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare function SourceChangeLoading({ onClose }: {
+    onClose: () => void;
+}): React.JSX.Element;

package/dist/modals/CheckoutModal/SourceChange/SourceList.d.ts

@@ -0,0 +1,27 @@
+import React, { type ReactNode } from 'react';
+interface SourceListProps {
+    preferred: ReactNode[];
+    moreSources: ReactNode[];
+    unavailable: ReactNode[];
+    isFallback: boolean;
+    /**
+     * Pre-rendered Native fast-path row, threaded through to
+     * `buildSourceGroups`. Caller (SourceChange) owns the row's click
+     * handler since it depends on the modal's `onNext` callback.
+     */
+    nativeRow?: ReactNode;
+    testId?: string;
+}
+/**
+ * Contextual composer for the source-change payment-method list.
+ * Reads translation, funkit config, and the source-list-relevant
+ * Statsig flags directly; runs `buildSourceGroups`; dispatches to the
+ * matching layout primitive — `FlatList` for the non-Swapped path
+ * (with a PayPal footer + "more" divider label) or `GroupedList` for
+ * the Swapped path (with optional section labels).
+ *
+ * `SourceList` has no DOM of its own; the primitive it returns owns
+ * the outer `data-testid` element.
+ */
+export declare function SourceList({ preferred, moreSources, unavailable, isFallback, nativeRow, testId, }: SourceListProps): React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/SourceChange/buildSourceGroups.d.ts

@@ -0,0 +1,70 @@
+import type { TFunction } from 'i18next';
+import { type ReactNode } from 'react';
+export interface SourceGroup {
+    /** Section header. Omit to render the group's body without a header. */
+    label?: string;
+    /**
+     * Optional tooltip surfaced via an info icon next to the label.
+     * Only renders when `showLabels` and `label` are both set.
+     */
+    labelTooltip?: string;
+    children: ReactNode;
+}
+interface BuildSourceGroupsArgs {
+    /** Customer identity — used to dispatch to per-customer section composition. */
+    apiKey: string;
+    preferred: ReactNode[];
+    moreSources: ReactNode[];
+    unavailable: ReactNode[];
+    isFallback: boolean;
+    isSwappedEnabled: boolean;
+    enableSourceGroupLabels: boolean;
+    t: TFunction;
+    /**
+     * Pre-rendered Native fast-path row. Caller resolves the customer's
+     * native asset, looks up the wallet holding, and constructs the row
+     * component; this function decides where in the Aave section
+     * structure it belongs. Only the Aave branch consumes it; the
+     * default branch ignores it.
+     */
+    nativeRow?: ReactNode;
+}
+export type BuildSourceGroupsResult = {
+    layout: 'flat';
+    groups: SourceGroup[];
+} | {
+    layout: 'grouped';
+    groups: SourceGroup[];
+    showLabels: boolean;
+};
+/**
+ * Composes source-list sections from `usePaymentSources` buckets +
+ * the relevant Statsig flags + the customer identity. Returns a
+ * discriminated layout shape; the composer (`SourceList`) dispatches
+ * to the matching layout primitive.
+ *
+ * **Default branch** (most customers) mirrors SourceList's prior
+ * output:
+ * - `isSwappedEnabled=false` → flat layout. One group for `preferred`
+ *   (if any), one combined group for `moreSources + unavailable` (if
+ *   any), with a single divider between them. (`SourceList` places
+ *   `<PayPal />` as the flat footer.)
+ * - `isSwappedEnabled=true` → grouped layout. Same two groups, but
+ *   rendered in separate boxes with `showLabels` toggling the section
+ *   headers ("Connected" / "Most popular" / "More options"). The
+ *   "More options" header is suppressed when no preferred group
+ *   precedes it.
+ *
+ * **Aave branch** (per Figma, [ENG-3743](https://linear.app/funxyz/issue/ENG-3743)
+ * + [ENG-3747](https://linear.app/funxyz/issue/ENG-3747)
+ * + [ENG-3755](https://linear.app/funxyz/issue/ENG-3755)):
+ * - "Native" section with the user's underlying-asset row when
+ *   `nativeRow` is provided.
+ * - Second section flattens preferred + moreSources + unavailable
+ *   into "Use other assets" (with native present) or "Use any asset"
+ *   (without). Header carries a tooltip via `labelTooltip`.
+ * - Layout is always `grouped` with `showLabels=true` for Aave so the
+ *   section headers render.
+ */
+export declare function buildSourceGroups(args: BuildSourceGroupsArgs): BuildSourceGroupsResult;
+export {};

package/dist/modals/CheckoutModal/SourceChange/sourceChange.css.d.ts

@@ -0,0 +1,8 @@
+export declare const WITH_EMPTY_STATE_DATA_ATTRIBUTE = "data-with-empty-state";
+export declare const emptyStateStyles: string;
+export declare const sourceListBoxStyles: string;
+export declare const sourceListGroupContainerStyles: string;
+export declare const sourceListGroupContainerNoLabelsStyles: string;
+export declare const sourceListCompactBoxStyles: string;
+export declare const paymentMethodStaticArea: string;
+export declare const fullWidthContentDivider: string;

package/dist/modals/CheckoutModal/SourceChange/useSourceChangeLayout.d.ts

@@ -0,0 +1,10 @@
+import type { BoxProps } from '../../../components/Box/Box';
+/**
+ * Layout decisions shared between SourceChange and SourceChangeLoading so the
+ * loading skeleton can't drift from the loaded screen.
+ */
+export declare function useSourceChangeLayout(): {
+    isTargetAssetSelectable: boolean;
+    showContentDivider: boolean;
+    cryptoCashToggleMarginTop: BoxProps['marginTop'];
+};

package/dist/modals/CheckoutModal/SwappedIframe/SwappedIframe.css.d.ts

@@ -0,0 +1 @@
+export declare const scrollableIframeWrapper: string;

package/dist/modals/CheckoutModal/SwappedIframe/SwappedIframe.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const _default: React.MemoExoticComponent<() => React.JSX.Element | null>;
+export default _default;

package/dist/modals/CheckoutModal/SwappedIframe/SwappedIframeController.d.ts

@@ -0,0 +1,17 @@
+import type { SwappedFormOfPayment } from '@funkit/api-base';
+import React from 'react';
+import type { PaymentMethodType } from '../../../hooks/usePaymentSources';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../../../modals/CheckoutModal/stepTransition';
+export type SwappedIframeState = CheckoutModalCommonState & {
+    /** The selected payment option from the fops API */
+    selectedPaymentOption: SwappedFormOfPayment;
+    /** Payment method type filter to restore when returning to SOURCE_CHANGE */
+    paymentMethodTypeFilter?: PaymentMethodType;
+    /** Set to true when an error occurs (iframe error or load timeout) */
+    error?: boolean;
+};
+export type SwappedIframeNext = {
+    success?: boolean;
+};
+export declare const SwappedIframeInfo: ModalStepInfo<FunCheckoutStep.SWAPPED_IFRAME>;
+export declare function SwappedIframeController({ modalState, onBack, onClose, setModalState, }: ModalStepComponentProps<FunCheckoutStep.SWAPPED_IFRAME>): React.JSX.Element;

package/dist/modals/CheckoutModal/SwappedIframe/index.d.ts

@@ -0,0 +1 @@
+export { SwappedIframeController, SwappedIframeInfo, type SwappedIframeNext, type SwappedIframeState, } from './SwappedIframeController';

package/dist/modals/CheckoutModal/TransferToken/CheckoutNotification.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { CheckoutHistoryItem } from '@funkit/api-base';
+import type { Address } from 'viem';
+import { type CheckoutStatus } from '../../../domains/checkout';
+export type NotificationStatus = CheckoutStatus | 'delayed';
+interface CheckoutNotificationProps {
+    checkout: CheckoutHistoryItem;
+    onClose: (id: string) => void;
+    onHelp: (depositAddress: Address) => void;
+}
+export declare const CheckoutNotification: ({ checkout: defaultCheckout, onClose, onHelp, }: CheckoutNotificationProps) => React.JSX.Element | null;
+export {};

package/dist/modals/CheckoutModal/TransferToken/CheckoutNotifications.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import type { CheckoutNotificationsProps } from './types';
+export declare const CheckoutNotifications: ({ onHelp, isVisible, variant, }: CheckoutNotificationsProps) => React.JSX.Element | null;

package/dist/modals/CheckoutModal/TransferToken/CheckoutNotifications.track.d.ts

@@ -0,0 +1,5 @@
+import type { TrackEventData } from '../../../hooks/track/useTrack';
+import type { NotificationItem } from './types';
+export declare function getNotificationId(item: NotificationItem): string;
+export declare function buildNotificationMetadata(item: NotificationItem, extras: Record<string, unknown>): Record<string, unknown>;
+export declare const trackEventFromNotification: (item: NotificationItem) => TrackEventData;

package/dist/modals/CheckoutModal/TransferToken/DirectExecutionNotification.d.ts

@@ -0,0 +1,18 @@
+import type { TFunction } from 'i18next';
+import React from 'react';
+import type { Address } from 'viem';
+import type { MergedMultiStepDirectExecution } from '../../../domains/checkoutNotifications';
+interface DirectExecutionNotificationProps {
+    directExecution: MergedMultiStepDirectExecution;
+    onClose: (id: string) => void;
+    onHelp: (depositAddress: Address) => void;
+}
+export declare const getNotificationProcessingConfig: ({ t, isSyntheticDE, }: {
+    t: TFunction;
+    isSyntheticDE: boolean;
+}) => {
+    title: string;
+    description: string;
+};
+export declare const DirectExecutionNotification: ({ directExecution, onClose, onHelp, }: DirectExecutionNotificationProps) => React.JSX.Element;
+export {};

package/dist/modals/CheckoutModal/TransferToken/TransferToken.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { type TransferTokenDefault } from '../../../hooks/useTokenAndChainDropdown';
+import { type CheckoutModalCommonState, FunCheckoutStep, type ModalStepComponentProps, type ModalStepInfo } from '../stepTransition';
+export type TransferTokenState = CheckoutModalCommonState & {
+    transferToken?: TransferTokenDefault;
+};
+export type TransferTokenNext = Record<string, never>;
+export interface TokenTransferSourceChainsAndAssets {
+    [chainId: number]: string[];
+}
+export declare const TransferTokenInfo: ModalStepInfo<FunCheckoutStep.TRANSFER_TOKEN>;
+export declare function TransferToken({ onNext, onStepChange, modalState, }: ModalStepComponentProps<FunCheckoutStep.TRANSFER_TOKEN>): React.JSX.Element;

package/dist/modals/CheckoutModal/TransferToken/types.d.ts

@@ -0,0 +1,15 @@
+import type { CheckoutHistoryItem } from '@funkit/api-base';
+import type { Address } from 'viem';
+import type { MergedMultiStepDirectExecution, NotificationVariant } from '../../../domains/checkoutNotifications';
+export type { NotificationVariant };
+export type NotificationItem = (MergedMultiStepDirectExecution & {
+    isDirectExecution: true;
+}) | (CheckoutHistoryItem & {
+    isDirectExecution: false;
+});
+export interface CheckoutNotificationsProps {
+    onHelp: (depositAddress: Address) => void;
+    /** To control notifications visibility on specific pages, without changing internal dismissal state */
+    isVisible: boolean;
+    variant: NotificationVariant | undefined;
+}