@funkit/connect 0.0.0-20260710210119

package/dist/components/CopyAddress/CopyInputDisplayedAddress.css.d.ts

@@ -0,0 +1,14 @@
+export declare const copyButtonWrapper: string;
+export declare const copyButton: string;
+export declare const copyButtonIcon: string;
+export declare const copyButtonIconBase: string;
+export declare const copyButtonIconActive: string;
+export declare const copyInputTextBox: string;
+export declare const copyInputTextBoxActive: string;
+export declare const copyInputText: string;
+export declare const displayedAddressText: string;
+export declare const copyInputTextWrapper: string;
+export declare const copyInputTextDefault: string;
+export declare const copyInputTextActive: string;
+export declare const textOut: string;
+export declare const textIn: string;

package/dist/components/CopyAddress/CopyInputDisplayedAddress.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+type CopyLabel = 'address' | 'invoice';
+interface CopyInputDisplayedAddressProps {
+    address: string;
+    onAddressCopied?: () => void;
+    truncateAddress?: boolean;
+    /**
+     * Word rendered after "Copy" in the button label. EN variant char-animates
+     * the raw word; i18n variant maps to `common.copyAddress` / `common.copyInvoice`.
+     */
+    label?: CopyLabel;
+}
+/**
+ * Main exported component that conditionally renders English or i18n version
+ */
+export declare function CopyInputDisplayedAddress(props: CopyInputDisplayedAddressProps): React.JSX.Element;
+export {};

package/dist/components/CopyAddress/OldCopyAddressButton.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+/** Use this button only in the old design components, for the future we should use `CopyAddressButton` which has a new design */
+export declare function OldCopyAddressButton({ address }: {
+    address: string;
+}): React.JSX.Element;

package/dist/components/CurrencySelector/CurrencySelector.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface CurrencySelectorProps {
+    selectedCurrency?: string;
+    isLoading?: boolean;
+    onClick?: (currency: string) => void;
+}
+export declare const CurrencySelector: ({ selectedCurrency, isLoading, onClick, }: CurrencySelectorProps) => React.JSX.Element;
+export {};

package/dist/components/Dialog/Dialog.css.d.ts

@@ -0,0 +1,14 @@
+export declare const easing: number[];
+export declare const DialogAnimationTimeIn = 0.25;
+export declare const DialogAnimationTimeOut = 0.12;
+export declare const overlay: string;
+export declare const content: string;
+export declare const titleContainer: string;
+/** Content that shouls overflow into topbar */
+export declare const topbarOverflowContent: string;
+/** Wrapper around DialogTitle to position its variable-opacity background */
+export declare const topbarFadeWrapper: string;
+/** Absolute-positioned background behind topbar (lets us modulate background opacity without making text/button transparent) */
+export declare const topbarFadeBackground: string;
+export declare const itemsAlignCenter: string;
+export declare const itemsAlignEnd: string;

package/dist/components/Dialog/Dialog.d.ts

@@ -0,0 +1,74 @@
+import React, { type ReactNode } from 'react';
+import { type BoxProps } from '../Box/Box';
+export { CHECKOUT_MODAL_TITLE_COUNTDOWN_ID, MODAL_BOTTOM_BAR_IDS, type ModalBottomBarIdType, useBottomSectionRef, useTitleCountdownRef, } from './hooks';
+interface DialogProps {
+    open: boolean;
+    onClose: () => void;
+    onAnimationComplete?: () => void;
+    titleId: string;
+    onMountAutoFocus?: (event: Event) => void;
+    children: ReactNode;
+    /** To hide the dialog without removing the object from the DOM **/
+    isHidden?: boolean;
+    /** Whether clicking outside the dialog or pressing escape key would close the modal */
+    isSmartCloseable?: boolean;
+    /** Whether side padding around the content of the modal should be applied */
+    withoutSidePadding?: boolean;
+    /** Whether the transition animation should be used on open/close */
+    withTransition?: boolean;
+    testId?: string;
+    /** Whether to use the fanatics bottom sheet style on mobile */
+    isFanaticsBottomSheet?: boolean;
+    /**
+     * Optional CSS `background` painted as a *translucent overlay* on top of
+     * the modal's regular `modalBackground`. Rendered as an absolutely-
+     * positioned sibling inside the modal outer; the underlying
+     * `modalBackground` still shows through wherever the overlay's layers are
+     * transparent. Use a stack of `linear-gradient(...)` with `rgba(..., 0)`
+     * stops (no opaque base) so the overlay reads correctly in both light
+     * and dark themes.
+     */
+    backgroundOverlay?: string;
+}
+/**
+ * Dialog components (title, content, bottom bar) must be rendered as direct children of Dialog for correct scrolling behavior
+ */
+export declare function Dialog({ children, onClose, onAnimationComplete, open, titleId, isHidden, isSmartCloseable, withoutSidePadding, withTransition, testId, isFanaticsBottomSheet, backgroundOverlay, }: DialogProps): React.ReactPortal | null;
+export declare namespace Dialog {
+    var Title: ({ title, titleMeta, hasCloseButton: hasCloseButtonProp, isCloseDisabled, onClose, hasBackButton: hasBackButtonProp, isBackDisabled, onBack, className, }: DialogTitleProps) => React.JSX.Element;
+    var Content: ({ children, fullHeight, className, id, paddingTop, withTopDivider, withBottomDivider, withoutBottomPadding, withoutSidePadding, extraContentTopPadding, withChildScrollArea, ...boxProps }: DialogContentProps) => React.JSX.Element;
+    var BottomSection: ({ paddingX, children, ...boxProps }: BoxProps) => React.JSX.Element;
+    var BottomBar: ({ topSection, topSectionVisible, actionButtonProps, onClose, onCloseLabel, }: import("../FunBottomBar/FunBottomBar").FunBottomBarProps) => React.JSX.Element | null;
+}
+interface DialogContentProps extends Omit<BoxProps, 'padding' | 'paddingX' | 'paddingY' | 'paddingLeft' | 'paddingRight' | 'paddingBottom'> {
+    children: ReactNode;
+    /** Whether the content should fill all available space */
+    fullHeight?: boolean;
+    withTopDivider?: 'always' | 'scroll' | 'never';
+    withBottomDivider?: 'always' | 'scroll' | 'never';
+    id?: string;
+    /** Whether bottom padding should be applied */
+    withoutBottomPadding?: boolean;
+    /** Whether side padding should be applied */
+    withoutSidePadding?: boolean;
+    /** Whether to add extra top padding to visually balance the FunBottomBar */
+    extraContentTopPadding?: boolean;
+    /**
+     * When true, Dialog.Content becomes a non-scrolling flex column container, delegating
+     * scrolling to a child PaddedScrollableArea. Applies expanded side margins so that
+     * full-width dividers inside the child can visually reach the dialog border edges.
+     */
+    withChildScrollArea?: boolean;
+}
+export interface DialogTitleProps {
+    title?: string;
+    titleMeta?: string;
+    /** Can hide the close button, eg. when using a countdown element in its place */
+    hasCloseButton?: boolean;
+    isCloseDisabled?: boolean;
+    onClose?: () => void;
+    hasBackButton?: boolean;
+    isBackDisabled?: boolean;
+    onBack?: () => void;
+    className?: string;
+}

package/dist/components/Dialog/DialogContent.css.d.ts

@@ -0,0 +1,39 @@
+export declare const DIALOG_WIDTH_WIDE = "450px";
+export declare const DIALOG_HEIGHT = 525;
+export declare const DIALOG_HEIGHT_SWAPPED_IFRAME = 525;
+export declare const DIALOG_INNER_PADDING_X = 12;
+export declare const SCROLL_BAR_WIDTH = 6;
+export declare const DIALOG_BOTTOM_PADDING = "15";
+/**
+ * note the border defined here is taken into account in the FunCheckoutModalHeightAnimationWrapper component in the `getPermittedHeight` function
+ * adjusting the border width will require adjusting the `getPermittedHeight` function
+ */
+export declare const dialog: string;
+export declare const dialogCompact: string;
+export declare const dialogMedium: string;
+export declare const dialogWide: string;
+export declare const withoutSidePadding: string;
+export declare const dialogMobile: string;
+/**
+ * Fanatics-specific bottom sheet style for mobile
+ * - No margins from sides/bottom (full width)
+ * - No border radius on bottom corners (only top)
+ * - Side paddings 20px instead of 24
+ * - Max height 80% of viewport
+ * - Internal scrolling when content exceeds height
+ */
+export declare const dialogFanaticsBottomSheet: string;
+export declare const dialogExtraWide: string;
+export declare const scrollContent: string;
+export declare const scrollbarHidden: string;
+export declare const fullHeightContent: string;
+/**
+ * Used when a child component (e.g. PaddedScrollableArea) owns its own scrolling.
+ * Dialog.Content becomes a non-scrolling flex column container.
+ * The margin/padding expansion needed for full-width dividers is applied as inline styles in Dialog.tsx.
+ */
+export declare const childScrollAreaContent: string;
+export declare const noPaddingContent: string;
+export declare const dividerTransition: string;
+export declare const contentExpanded: string;
+export declare const contentCollapsed: string;

package/dist/components/Dialog/FocusTrap.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function FocusTrap(props: React.JSX.IntrinsicElements['div']): React.JSX.Element;

package/dist/components/Dialog/hooks.d.ts

@@ -0,0 +1,20 @@
+export declare const MODAL_BOTTOM_BAR_WRAPPER_ID = "fun-modal-bottom-bar-wrapper";
+export declare const MODAL_BOTTOM_BAR_IDS: {
+    readonly checkout: "checkout-modal-bottom-bar";
+    readonly withdrawal: "withdrawal-modal-bottom-bar";
+    readonly connectwallet: "connect-wallet-modal-bottom-bar";
+};
+export type ModalBottomBarIdType = keyof typeof MODAL_BOTTOM_BAR_IDS;
+export declare function useBottomSectionRef(modalBottomBarIdType?: ModalBottomBarIdType): HTMLElement | null;
+export declare const CHECKOUT_MODAL_TITLE_COUNTDOWN_ID = "checkout-modal-title-countdown";
+export declare function useTitleCountdownRef(): HTMLElement | null;
+export declare function useGeneralBottomBarElement(): HTMLElement | null;
+export declare function useCheckoutBottomBarElement(): HTMLElement | null;
+export declare function useWithdrawalBottomBarElement(): HTMLElement | null;
+export declare function useConnectWalletBottomBarElement(): HTMLElement | null;
+/**
+ * Hook to observe if a ref's children are empty, with special handling for bottom bar nodes.
+ * @param ref - React ref to the DOM node to observe
+ * @param setHasNoChildren - Setter to update if the node has no children
+ */
+export declare function useBottomBarHasNoChildren(): boolean;

package/dist/components/Dropdown/AccountSelectDropdown.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import type { BaseActiveDropdownItemProps } from './BaseActiveDropdownItem';
+export interface AccountSelectOption {
+    /** Stable identifier, also the dropdown's selected value. */
+    value: string;
+    label: string;
+    /** Secondary line under the label, e.g. a formatted balance. */
+    description?: React.ReactNode;
+}
+export interface AccountSelectAction {
+    /** Stable id; must not collide with an account {@link AccountSelectOption.value}. */
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    onSelect: () => void;
+}
+export interface AccountSelectDropdownProps {
+    accounts: AccountSelectOption[];
+    selectedValue: string;
+    onSelect: (value: string) => void;
+    /**
+     * Optional row rendered below the accounts, separated by a divider — e.g. a
+     * "Transfer between accounts" action. It carries no selected state.
+     */
+    action?: AccountSelectAction;
+    /** Secondary prefix shown on the trigger, e.g. "Deposit to". */
+    prefixLabel?: string;
+    /** Field label rendered above the trigger. */
+    label?: string;
+    size?: BaseActiveDropdownItemProps['size'];
+    /**
+     * Fixed width (px) of the options popover. Defaults to the trigger width;
+     * set this to make the popover narrower than the (full-width) trigger. The
+     * popover is right-aligned to the trigger.
+     */
+    dropdownWidth?: number;
+    testId?: string;
+}
+/**
+ * A dropdown for picking between a small set of accounts (each with a balance
+ * subline + a selected check), with an optional trailing action row below a
+ * divider. Built on {@link BaseDropdown}; selection routes through each
+ * {@link BaseDropdownItem} so Radix closes the menu on choose.
+ */
+export declare function AccountSelectDropdown({ accounts, selectedValue, onSelect, action, prefixLabel, label, size, dropdownWidth, testId, }: AccountSelectDropdownProps): React.JSX.Element;

package/dist/components/Dropdown/BaseActiveDropdownItem.css.d.ts

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

package/dist/components/Dropdown/BaseActiveDropdownItem.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { type BoxProps } from '../Box/Box';
+export type BaseActiveDropdownItemSize = 'compact' | 'regular' | 'large';
+export interface BaseActiveDropdownItemProps {
+    iconComponent?: React.ReactNode;
+    label: React.ReactNode;
+    isOpened?: boolean;
+    onClick?: () => void;
+    horizontalIconGap?: BoxProps['gap'];
+    alwaysVisibleLabel?: string;
+    tagComponent?: React.ReactNode;
+    tagPosition?: 'start' | 'end';
+    size?: BaseActiveDropdownItemSize;
+    color?: BoxProps['color'];
+    arrowColor?: BoxProps['color'];
+    background?: BoxProps['background'];
+    labelStyle?: React.CSSProperties;
+    /**
+     * Render the dropdown caret in a tight 8×8 wrapper instead of the default
+     * 16×16. Only affects the caret icon — not paddings, fonts, or hit area on
+     * the active item itself.
+     */
+    compactIcon?: boolean;
+}
+/**
+ * Represents the component used to open the dropdown, usually displayed all the time.
+ */
+declare function BaseActiveDropdownItem({ iconComponent, label, isOpened, onClick, horizontalIconGap, alwaysVisibleLabel, tagComponent, tagPosition, size, color, arrowColor, background, labelStyle, compactIcon, }: BaseActiveDropdownItemProps): React.JSX.Element;
+export default BaseActiveDropdownItem;

package/dist/components/Dropdown/BaseDropdown.css.d.ts

@@ -0,0 +1,5 @@
+export declare const SCROLL_GRADIENT_SIZE_PX = 48;
+export declare const BORDER_RADIUS = "dropdown";
+export declare const scrollableDropdownStyles: string;
+export declare const scrollGradientWrapperStyles: string;
+export declare const baseDropdownItemWrapperStyles: string;

package/dist/components/Dropdown/BaseDropdown.d.ts

@@ -0,0 +1,73 @@
+import React from 'react';
+import { type BoxProps } from '../Box/Box';
+import { type BaseActiveDropdownItemProps } from './BaseActiveDropdownItem';
+import './BaseDropdownAnimation.css';
+import { type BaseDropdownGroup, type BaseDropdownOption } from './BaseDropdown.utils';
+export type { BaseDropdownGroup, BaseDropdownOption, } from './BaseDropdown.utils';
+export { NO_SELECTION_VALUE } from './BaseDropdown.utils';
+/** gap between the icon and the label of the item */
+export declare const HORIZONTAL_ICON_GAP = "4";
+/** safe spacing, ie. padding, on the left & right of the active item and dropdown item */
+export declare const HORIZONTAL_OUTER_PADDING_X = "12";
+export interface BaseDropdownProps<T = string, G extends string = never> {
+    value: string;
+    activeItemProps?: Partial<Pick<BaseActiveDropdownItemProps, 'iconComponent' | 'label' | 'color' | 'alwaysVisibleLabel' | 'tagComponent' | 'tagPosition' | 'background' | 'labelStyle' | 'compactIcon'>>;
+    /**
+     * List of groups to show and the corresponding labels, in the expected order.
+     *
+     * _Defaults to ungrouped dropdown behavior_
+     */
+    groups?: BaseDropdownGroup<T, G>[];
+    /**
+     * Additional group displayed after configured groups (only if there are non-empty groups).
+     * - "all": display all options (grouped options will effectively be shown twice in total)
+     * - "others": display only ungrouped options
+     *
+     * _Defaults to "others"_
+     */
+    additionalGroup?: 'all' | 'others';
+    /**
+     * Label for the {@link additionalGroup}.
+     *
+     * Shows only if the additional group is not empty.
+     */
+    additionalGroupLabel?: string;
+    /**
+     * If specified, show an "Unselect" option with value {@link NO_SELECTION_VALUE} above other options/groups
+     *
+     * _Defaults to `false`_
+     */
+    allowUnselect?: boolean;
+    /**
+     * Label for {@link allowUnselect}
+     */
+    unselectLabel?: string;
+    options: BaseDropdownOption<T>[];
+    onOpen?: () => void;
+    onOptionSelected?: (item: BaseDropdownOption<T>) => void;
+    renderDropdownOption: (item: BaseDropdownOption<T>, isSelected: boolean) => React.ReactNode;
+    searchableOptions?: boolean;
+    searchPlaceholder?: string;
+    placeholder?: string;
+    resetSearchOnClose?: boolean;
+    openToTopOnMobile?: boolean;
+    alwaysOpenToTop?: boolean;
+    openDropdownFullWidth?: boolean;
+    preloadIconUrls?: string[];
+    horizontalIconGap?: BoxProps['gap'];
+    openDropdownBackgroundColor?: BoxProps['background'];
+    size?: BaseActiveDropdownItemProps['size'];
+    isLoading?: boolean;
+    label?: string;
+    /**
+     * If provided, the dropdown will be scrollable and the max height will be set to the provided value.
+     * This is useful for dropdowns that have a lot of options and normally would be too tall to fit in the modal and overflow beyond the modal is not supported right now.
+     * This values should be set so that the last dropdown item is partially visible to indicate that there are more options.
+     */
+    maxDropdownHeight?: number;
+    dropdownWidth?: number;
+    dropdownAlign?: 'start' | 'center' | 'end';
+    testId?: string;
+}
+declare function BaseDropdown<T extends string = string, G extends string = never>({ activeItemProps, value, options, groups, additionalGroup, additionalGroupLabel, allowUnselect, unselectLabel, onOptionSelected, onOpen, renderDropdownOption, searchableOptions, searchPlaceholder, placeholder, resetSearchOnClose, openToTopOnMobile, alwaysOpenToTop, openDropdownFullWidth, isLoading, preloadIconUrls, horizontalIconGap, openDropdownBackgroundColor, size, label, maxDropdownHeight, dropdownWidth, dropdownAlign, testId, }: BaseDropdownProps<T, G>): React.JSX.Element;
+export default BaseDropdown;

package/dist/components/Dropdown/BaseDropdown.utils.d.ts

@@ -0,0 +1,23 @@
+export declare const NO_SELECTION_VALUE = "";
+export declare const ADDITIONAL_GROUP_KEY = "__additional__";
+export interface BaseDropdownOption<T = string> {
+    label: string;
+    value: T;
+}
+export interface BaseDropdownGroup<T = string, G extends string = never> {
+    key: G;
+    label: string;
+    values: T[];
+}
+export interface OrganizedDropdownGroup<T, G extends string> {
+    key: G | typeof ADDITIONAL_GROUP_KEY | typeof NO_SELECTION_VALUE;
+    label: string | undefined;
+    options: BaseDropdownOption<T>[];
+}
+export interface OrganizeDropdownGroupsResult<T, G extends string> {
+    organizedGroups: OrganizedDropdownGroup<T, G>[];
+    organizedOptions: BaseDropdownOption<T>[];
+}
+export declare function buildAllOptions<T extends string>(options: BaseDropdownOption<T>[], allowUnselect: boolean, unselectLabel?: string): BaseDropdownOption<T>[];
+export declare function filterOptions<T extends string>(allOptions: BaseDropdownOption<T>[], searchInput: string): BaseDropdownOption<T>[];
+export declare function organizeDropdownGroups<T extends string, G extends string>(filteredOptions: BaseDropdownOption<T>[], groups: BaseDropdownGroup<T, G>[] | undefined, additionalGroup: 'all' | 'others', additionalGroupLabel: string | undefined): OrganizeDropdownGroupsResult<T, G>;

package/dist/components/Dropdown/BaseDropdownItem.css.d.ts

@@ -0,0 +1,2 @@
+export declare const enabledDropdownItemStyles: string;
+export declare const disabledDropdownItemStyles: string;

package/dist/components/Dropdown/BaseDropdownItem.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { type BoxProps } from '../Box/Box';
+interface BaseDropdownItemProps {
+    iconComponent?: React.ReactNode;
+    label: React.ReactNode;
+    /** Optional secondary line rendered under the label (e.g. a balance). */
+    description?: React.ReactNode;
+    id: string;
+    onClick?: (id: string) => void;
+    isSelected?: boolean;
+    isDisabled?: boolean;
+    horizontalIconGap?: BoxProps['gap'];
+    tagComponent?: React.ReactNode;
+    borderRadius?: BoxProps['borderRadius'];
+    horizontalPadding?: BoxProps['paddingX'];
+    verticalPadding?: BoxProps['paddingY'];
+}
+/**
+ * Represents a single option in a dropdown.
+ */
+declare function BaseDropdownItem({ iconComponent, label, description, id, onClick, isSelected, isDisabled, borderRadius, horizontalIconGap, tagComponent, horizontalPadding, verticalPadding, }: BaseDropdownItemProps): React.JSX.Element;
+export default BaseDropdownItem;

package/dist/components/Dropdown/ChainDropdown.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import type { TokenTransferSourceChainsAndAssets } from '../../modals/CheckoutModal/TransferToken/TransferToken';
+import type { BaseActiveDropdownItemProps } from './BaseActiveDropdownItem';
+import { type BaseDropdownProps } from './BaseDropdown';
+interface ChainDropdownProps {
+    assets: TokenTransferSourceChainsAndAssets;
+    /** Chain IDs in display order. If provided, determines the dropdown order. */
+    chainIdSortOrder?: number[];
+    selectedChainId?: number;
+    selectedToken?: string;
+    onChainSelected: (chainId: number | undefined, 
+    /**
+     * If true, it will trigger automatic updates for the matching token in the parent component.
+     */
+    autoUpdate?: boolean) => void;
+    /** Provides option to allow going back to unselected state and displays that state as a selectable option */
+    allowUnselect?: boolean;
+    activeItemProps?: BaseDropdownProps['activeItemProps'];
+    openDropdownBackgroundColor?: BaseDropdownProps['openDropdownBackgroundColor'];
+    openDropdownFullWidth?: BaseDropdownProps['openDropdownFullWidth'];
+    size?: BaseActiveDropdownItemProps['size'];
+    isLoading?: BaseDropdownProps['isLoading'];
+    alwaysOpenToTop?: BaseDropdownProps['alwaysOpenToTop'];
+    maxDropdownHeight?: BaseDropdownProps['maxDropdownHeight'];
+    tagComponent?: (value: string) => React.ReactNode;
+    placeholder?: string;
+    testId?: string;
+}
+export declare const ChainDropdown: ({ assets, chainIdSortOrder, selectedChainId: propSelectedChainId, selectedToken, allowUnselect, onChainSelected, activeItemProps, size, openDropdownBackgroundColor, openDropdownFullWidth, isLoading, alwaysOpenToTop, maxDropdownHeight, tagComponent, placeholder, testId, }: ChainDropdownProps) => React.JSX.Element;
+export {};

package/dist/components/Dropdown/ReceiveTokenDropdown.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { DynamicTargetAssetCandidate } from '../../providers/FunkitCheckoutContext';
+import type { BaseActiveDropdownItemProps } from './BaseActiveDropdownItem';
+import { type BaseDropdownProps } from './BaseDropdown';
+interface ReceiveTokenDropdownProps {
+    chainId: number;
+    displayedChainId?: number;
+    tokens: DynamicTargetAssetCandidate[];
+    onTokenSelected: (token: DynamicTargetAssetCandidate) => void;
+    selectedToken?: string;
+    label?: string;
+    activeItemLabel?: string;
+    activeItemProps?: BaseDropdownProps['activeItemProps'];
+    maxDropdownHeight?: BaseDropdownProps['maxDropdownHeight'];
+    size?: BaseActiveDropdownItemProps['size'];
+}
+export declare const ReceiveTokenDropdown: ({ tokens, chainId, selectedToken, onTokenSelected, label, activeItemLabel, activeItemProps, maxDropdownHeight, size, displayedChainId, }: ReceiveTokenDropdownProps) => React.JSX.Element;
+export {};

package/dist/components/Dropdown/TokenAndChainDropdown.d.ts

@@ -0,0 +1,42 @@
+import React, { type ReactNode } from 'react';
+import type { TokenTransferSourceChainsAndAssets } from '../../modals/CheckoutModal/TransferToken/TransferToken';
+import type { BaseDropdownProps } from './BaseDropdown';
+interface TokenAndChainDropdownProps {
+    isLoading: boolean;
+    selectedToken: string | undefined;
+    selectedChainId: number | undefined;
+    assets: TokenTransferSourceChainsAndAssets;
+    /**
+     * Callback fired after token selection
+     */
+    onTokenSelected: (token: string, chainId?: number, autoUpdate?: boolean) => void;
+    /**
+     * Callback fired after chain selection
+     */
+    onChainSelected: (chainId?: number, autoUpdate?: boolean) => void;
+    tokenLabel?: string;
+    chainLabel?: string;
+    /** Placeholder shown in the token dropdown when no token is selected */
+    tokenPlaceholder?: string;
+    /** Placeholder shown in the chain dropdown when no chain is selected */
+    chainPlaceholder?: string;
+    chainLabelAddon?: ReactNode;
+    alwaysOpenToTop?: boolean;
+    maxTokenDropdownHeight?: BaseDropdownProps['maxDropdownHeight'];
+    maxChainDropdownHeight?: BaseDropdownProps['maxDropdownHeight'];
+    openChainDropdownFullWidth?: BaseDropdownProps['openDropdownFullWidth'];
+    chainTagComponent?: (value: string) => ReactNode;
+    /**
+     * Override to hide the new token badge
+     */
+    hideNewTokenBadge?: boolean;
+    /** Token symbols to show in a separate "Popular" group */
+    popularTokenSymbols?: string[];
+    /** Token symbols to prioritize at top of dropdown */
+    priorityTokenSymbols?: string[];
+    /** Determines the chain display order */
+    chainIdSortOrder?: number[];
+}
+/** Combines together chain and token dropdowns */
+export declare const TokenAndChainDropdown: ({ isLoading, selectedToken, selectedChainId, assets, onTokenSelected, onChainSelected, tokenLabel, chainLabel, tokenPlaceholder, chainPlaceholder, chainLabelAddon, alwaysOpenToTop, maxTokenDropdownHeight, maxChainDropdownHeight, openChainDropdownFullWidth, chainTagComponent, hideNewTokenBadge, popularTokenSymbols, priorityTokenSymbols, chainIdSortOrder, }: TokenAndChainDropdownProps) => React.JSX.Element;
+export {};

package/dist/components/Dropdown/TokenDropdown.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { TokenTransferSourceChainsAndAssets } from '../../modals/CheckoutModal/TransferToken/TransferToken';
+import { type BaseDropdownProps } from './BaseDropdown';
+interface TokenDropdownProps {
+    selectedChainId: number | undefined;
+    assets: TokenTransferSourceChainsAndAssets;
+    onTokenSelected: (token: string, chainId?: number, 
+    /**
+     * If true, it will trigger automatic updates for the matching chain in the parent component.
+     */
+    autoUpdate?: boolean) => void;
+    selectedToken: string | undefined;
+    isLoading?: BaseDropdownProps['isLoading'];
+    alwaysOpenToTop?: BaseDropdownProps['alwaysOpenToTop'];
+    maxDropdownHeight?: BaseDropdownProps['maxDropdownHeight'];
+    /**
+     * Override to hide the new token badge
+     */
+    hideNewTokenBadge?: boolean;
+    /** Token symbols to show in a separate "Popular" group */
+    popularTokenSymbols?: string[];
+    /** Token symbols to prioritize at top of dropdown */
+    priorityTokenSymbols?: string[];
+    /** Placeholder shown when no token is selected */
+    placeholder?: string;
+    /**
+     * Test ID for the token dropdown
+     */
+    testId?: string;
+}
+export declare const TokenDropdown: ({ assets, selectedChainId, selectedToken, onTokenSelected, isLoading, alwaysOpenToTop, maxDropdownHeight, hideNewTokenBadge, popularTokenSymbols, priorityTokenSymbols, placeholder, testId, }: TokenDropdownProps) => React.JSX.Element;
+export {};

package/dist/components/ErrorBoundary/ErrorBoundary.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+interface ErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+interface ErrorBoundaryState {
+    hasError: boolean;
+}
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+    constructor(props: ErrorBoundaryProps);
+    static getDerivedStateFromError(_: Error): ErrorBoundaryState;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | bigint | boolean | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | React.JSX.Element | null | undefined;
+}
+export default ErrorBoundary;

package/dist/components/ErrorBoundary/ErrorFallback.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const ErrorFallback: () => React.JSX.Element;

package/dist/components/FreeUsdcBanner/FreeUsdcBanner.css.d.ts

@@ -0,0 +1,15 @@
+export declare const chainIconAnimations: string[];
+export declare const motionTransitionEnter: {
+    duration: number;
+    ease: readonly [0.3, 0, 0, 1];
+};
+export declare const motionTransitionExit: {
+    duration: number;
+    ease: readonly [0.8, 0, 0.2, 1];
+};
+export declare const bannerWrapper: string;
+export declare const clusterWrapper: string;
+export declare const chainIconScale: string;
+export declare const usdcIconAnchor: string;
+export declare const textContent: string;
+export declare const dismissButton: string;

package/dist/components/FreeUsdcBanner/FreeUsdcBanner.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import { type BoxProps } from '../Box/Box';
+export declare const FreeUsdcBanner: ({ marginBottom, type, }: Pick<BoxProps, "marginBottom"> & {
+    type: "deposit" | "withdrawal";
+}) => React.JSX.Element;

package/dist/components/FunAlert/FunAlert.d.ts

@@ -0,0 +1,12 @@
+import React, { type ReactNode } from 'react';
+import { type BoxProps } from '../Box/Box';
+interface FunAlertProps {
+    icon?: ReactNode;
+    description: ReactNode;
+    type?: 'info' | 'error';
+    verticalAlignment?: 'top' | 'center';
+    paddingX?: BoxProps['paddingX'];
+    testId?: string;
+}
+export declare function FunAlert({ icon, description, type, verticalAlignment, paddingX, testId, }: FunAlertProps): React.JSX.Element;
+export {};

package/dist/components/FunAsset/FunAssetItem.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AssetHoldingsItem } from '../../utils/assets';
+interface FunAssetItemProps {
+    asset: AssetHoldingsItem;
+    isActive?: boolean;
+    isDisabled?: boolean;
+    badgeText: string | null;
+    badgeTooltip?: string;
+    onClick: () => void;
+    testId?: string;
+    isChainIconHidden?: boolean;
+}
+export declare const FunAssetItem: ({ asset, isActive, isDisabled, isChainIconHidden, badgeText, badgeTooltip, onClick, testId, }: FunAssetItemProps) => React.JSX.Element;
+export declare function FunAssetItemSkeleton(): React.JSX.Element;
+export {};

package/dist/components/FunAsset/FunAssetLoading.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface FunAssetLoadingProps {
+    /** Number of skeleton assets to display */
+    count?: number;
+}
+export declare function FunAssetLoading({ count }: FunAssetLoadingProps): React.JSX.Element;
+export {};

package/dist/components/FunAssetAvatar/FunAssetAvatar.css.d.ts

@@ -0,0 +1,2 @@
+export declare const containerStyle: string;
+export declare const chainContainerStyle: string;