@funkit/connect 0.0.0-20260710210119

package/dist/providers/FunkitConfigContext.d.ts

@@ -0,0 +1,279 @@
+import { type ComponentType, type JSX, type ReactNode } from 'react';
+import type { BluvoExchangeType } from '../consts/bluvo';
+import type { PaymentMethod } from '../domains/paymentMethods';
+import type { SourceChangeTopComponentProps } from '../modals/CheckoutModal/stepTransition';
+export interface FunkitTextCustomizationsConfig {
+    virtualFiat: string;
+    brokerageOrExchange: string;
+    debitOrCredit: string;
+    accountBalance: string;
+    selectAccount: string;
+    sourceChangeTitle?: string;
+    perpsTransferTitle: string;
+    sourceMethodTitle: string;
+    tokensListTitle: string;
+    transferTokens: string;
+    bitcoinLightning: string;
+    cashAppLightning: string;
+    receiveDropdownTitle: string;
+    receiveDropdownLabel: string;
+    txStatus?: {
+        failed?: {
+            description?: string;
+            title?: string;
+        };
+        delayed?: {
+            description?: string;
+            title?: string;
+        };
+        depositPending?: {
+            description?: string;
+            title?: string;
+        };
+        depositSucceeded?: {
+            description?: string;
+            title?: string;
+        };
+        submitting?: {
+            description?: string;
+            title?: string;
+        };
+        waitingForExchange?: {
+            description?: string;
+            title?: string;
+        };
+        withdrawalPending?: {
+            description?: string;
+            title?: string;
+        };
+        withdrawalSucceeded?: {
+            description?: string;
+            title?: string;
+        };
+    };
+    confirmationScreen: {
+        payAmountLabel: string;
+        receiveAmountLabel: string;
+        sourceLabel?: string;
+    };
+    paymentMethodSubtitles: {
+        accountBalance?: string;
+        brokerageOrExchange?: string;
+        debitOrCredit?: string;
+        paypal?: string;
+        transferTokens?: string;
+        bitcoinLightning?: string;
+        cashAppLightning?: string;
+        virtualFiat?: string;
+    };
+}
+export interface FunkitUiDestinationConfig {
+    /** What icon (15x15) to show in the `destination` row - defaults to user wallet icon  */
+    icon?: ReactNode;
+    /** What text to show in the `destination` row - defaults to formatted destination wallet address  */
+    text?: string;
+    /** Which url to redirect to. If not specified, defaults to the block explorer of the recipientAddr of the checkout*/
+    url?: string;
+}
+export interface FunkitUiSelectedRouteConfig {
+    /** Image URL for passthrough routes (required) */
+    passthroughImage: string;
+    /** Label for passthrough routes - defaults to "Native Bridge" */
+    passthroughLabel?: string;
+}
+export type FunkitPaymentMethodIconsConfig = Partial<Record<PaymentMethod, {
+    src: string;
+    size?: {
+        width: number;
+        height: number;
+    };
+}>>;
+export interface FunkitUiCustomizationsConfig {
+    /** Title alignment - defaults to "center" */
+    alignTitle?: 'left' | 'center';
+    /** Always shows checkout modal top divider even if content cannot scroll - defaults to `false` */
+    alwaysShowTopDivider?: boolean;
+    /** Whether to show modal title in topbars - defaults to true */
+    showModalTitle?: boolean;
+    /** Whether to show CTA in uppercase - defaults to false */
+    callToActionsUppercase?: boolean;
+    /** Whether to enable compact list style for option boxes - defaults to false */
+    enableCompactList?: boolean;
+    checkoutHistory?: {
+        /** Whether to show the bottom "Get help" text in a {@link FunAlert} - defaults to true */
+        showGetHelpAsAlert?: boolean;
+        /** Show a simplified UI with less rows and no "More details" section - defaults to false */
+        simplifiedUi?: boolean;
+    };
+    confirmationScreen?: {
+        /** Custom destination icon and text used in checkout summary */
+        destinationConfig?: FunkitUiDestinationConfig;
+        /** when source and destination are the same address, show destination as payment method instead of source - defaults to false */
+        preferDestinationWhenSame?: boolean;
+        /** Whether to show the bottom disclaimer in a {@link FunAlert} - defaults to true */
+        showDisclaimerAsAlert?: boolean;
+        /** Whether to show the total payment amount in USD below the token amount equivalent - defaults to false */
+        showPaymentAmountUsd?: boolean;
+        /** Whether to show the total receive amount in USD below the token amount equivalent - defaults to false */
+        showReceiveAmountUsd?: boolean;
+        /** Whether to show the amount summary above the payment method summary rather than below - defaults to false */
+        showAmountSummaryAbovePaymentMethod?: boolean;
+        /**
+         * Whether and how to show transaction fee's digest.
+         * - "none": show nothing (default)
+         * - "chainDependent": show price impact and additionally show gas as well for eth-mainnet
+         */
+        showTransactionDigest?: 'none' | 'chainDependent';
+        /** Whether to show the amount of tokens below the USD equivalent - defaults to true */
+        showTokenAmount?: boolean;
+        /** Instead of showing the dollar value centered, show it left-aligned with "Deposit" label - defaults to false */
+        showLeftAlignedDollarValueWithLabel?: boolean;
+        /** Whether to show "Instant" instead of "< 1 min" for time estimates under 1 minute - defaults to false */
+        showInstantTimeEstimate?: boolean;
+        /**
+         * Whether to show the "Selected Route" row (Relay / Across / passthrough).
+         * Defaults to false. Providing {@link selectedRouteConfig} also shows the
+         * row, for passthrough-branding back-compat.
+         */
+        showSelectedRoute?: boolean;
+        /**
+         * Passthrough-route branding (image + label) for the "Selected Route" row.
+         * Defining it also shows the row; to show the row without passthrough
+         * branding, use {@link showSelectedRoute} instead.
+         */
+        selectedRouteConfig?: FunkitUiSelectedRouteConfig;
+        /**
+         * How to indicate the current step during transaction progress.
+         * - "spinner": show the animated spinner (default)
+         * - "textual": show a textual "1 of 2" step indicator instead
+         */
+        stepIndicatorType?: 'spinner' | 'textual';
+    };
+    inputAmountScreen?: {
+        /** Whether to allow entering an amount of tokens, rather than only USD - defaults to true */
+        allowTokenAmountInput?: boolean;
+    };
+    selectAssetScreen?: {
+        /** Whether the secondary token symbol is visible - defaults to true */
+        isSecondaryTokenSymbolVisible?: boolean;
+        /** Whether to navigate directly on asset click, rather than having to select then click Continue - defaults to false */
+        navigateOnAssetClick?: boolean;
+        /** Function that returns a custom React component to render before other UIs in the select asset screen */
+        customTopComponent?: () => ReactNode;
+    };
+    transferCryptoScreen?: {
+        /** Whether to show the "You Send -> You Receive" block in the transfer crypto screen - defaults to false */
+        showYouSendYouReceive?: boolean;
+        /** Function that returns a custom React component to render before other UIs in the transfer crypto screen */
+        customTopComponent?: () => ReactNode;
+    };
+    withdrawalScreen?: {
+        /** Function that returns a custom React component to render before other UIs in the withdrawal amount screen */
+        customTopComponent?: () => ReactNode;
+    };
+    selectBrokerageScreen?: {
+        /** Function that returns a custom React component to render before other UIs in the select brokerage screen */
+        customTopComponent?: () => ReactNode;
+    };
+    connectExchangeScreen?: {
+        /** Function that returns a custom React component to render before other UIs in the connect exchange screen */
+        customTopComponent?: () => ReactNode;
+        /** Function that returns a custom React component to render instead of the normal page */
+        CustomComponent?: ComponentType<{
+            appName: string;
+            exchangeIcon: JSX.Element | null;
+            exchangeName: string;
+            exchangeType: BluvoExchangeType | null;
+        }>;
+    };
+    sourceChangeScreen?: {
+        bottomBarCloseButton?: {
+            /** Whether the bottom bar close button is visible - defaults to false */
+            enabled?: boolean;
+            /** Translation key for label - defaults to `'common.close'` */
+            labelKey?: 'sourceChange.exploreMarketsFirst' | 'common.close';
+        };
+        /** Whether to show target asset selection menu if dynamicTargetAssetCandidates exist - defaults to false */
+        showTargetAssetSelection?: boolean;
+        /** Whether to show wallet option when balance is insufficient - defaults to false (hides wallet) */
+        showWalletOnInsufficientBalance?: boolean;
+        /** Whether to show the wallet connect payment option - defaults to true */
+        showWalletConnect?: boolean;
+        /**
+         * Renders custom content before other UIs in the source change screen.
+         * Receives modal navigation handles so it can jump to another step (e.g.
+         * open a transfer step). Existing zero-arg components remain valid.
+         */
+        customTopComponent?: (props?: SourceChangeTopComponentProps) => ReactNode;
+        /**
+         * Render a full-width divider beneath {@link customTopComponent} (matching
+         * the target-asset selector divider). Defaults to false.
+         */
+        showCustomTopComponentDivider?: boolean;
+        paymentMethodIcons?: {
+            primary?: FunkitPaymentMethodIconsConfig;
+            /** Custom secondary icon or "value icon" in the context of FunPaymentMethodItem */
+            secondary?: FunkitPaymentMethodIconsConfig;
+        };
+    };
+    customIcons?: {
+        paymentDestination?: ComponentType;
+        paymentSource?: ComponentType;
+        timeEstimate?: ComponentType;
+        youReceive?: ComponentType;
+        youSend?: ComponentType;
+        fiatTabIcon?: ComponentType<{
+            size?: number;
+        }>;
+        cryptoTabIcon?: ComponentType<{
+            size?: number;
+        }>;
+    };
+    /** Font family names to pass to embedded widgets */
+    customFontFamily?: {
+        primary?: string;
+        secondary?: string;
+        tertiary?: string;
+    };
+}
+/**
+ * Makes all properties of T required except for custom components which remains optional.
+ * Used for internal screen configs where we want defaults for all settings but allow
+ * custom slot components to be optionally provided.
+ */
+type RequiredExceptCustomComponents<T> = Required<Omit<T & {}, `${string}Component`>>;
+export type FunkitUiCustomizationsConfigInternal = Required<FunkitUiCustomizationsConfig> & {
+    confirmationScreen: FunkitUiCustomizationsConfig['confirmationScreen'] & Required<Omit<FunkitUiCustomizationsConfig['confirmationScreen'] & {}, 'destinationConfig' | 'selectedRouteConfig'>>;
+    inputAmountScreen: Required<FunkitUiCustomizationsConfig['inputAmountScreen'] & {}>;
+    selectAssetScreen: RequiredExceptCustomComponents<FunkitUiCustomizationsConfig['selectAssetScreen']>;
+    transferCryptoScreen: RequiredExceptCustomComponents<FunkitUiCustomizationsConfig['transferCryptoScreen']>;
+    withdrawalScreen: RequiredExceptCustomComponents<FunkitUiCustomizationsConfig['withdrawalScreen']>;
+    selectBrokerageScreen: RequiredExceptCustomComponents<FunkitUiCustomizationsConfig['selectBrokerageScreen']>;
+    connectExchangeScreen: RequiredExceptCustomComponents<FunkitUiCustomizationsConfig['connectExchangeScreen']>;
+    sourceChangeScreen: RequiredExceptCustomComponents<FunkitUiCustomizationsConfig['sourceChangeScreen']> & {
+        bottomBarCloseButton: Required<Required<FunkitUiCustomizationsConfig['sourceChangeScreen'] & {}>['bottomBarCloseButton']>;
+    };
+};
+export type FunkitConfig = {
+    /** Funkit api key **/
+    apiKey: string;
+    /** App name **/
+    appName: string;
+    /** Text customizations across all widgets **/
+    textCustomizations?: Partial<FunkitTextCustomizationsConfig>;
+    /** UI customizations across all widgets **/
+    uiCustomizations?: FunkitUiCustomizationsConfig;
+    /** used to link funkit users to your own user system */
+    externalUserId?: string;
+    /** Email prefilled into the Swapped fiat onramp/offramp iframe. Set once at provider init. */
+    prefillFiatEmail?: string;
+    /** Disable Datadog logging - defaults to false (logging enabled) */
+    disableLogging?: boolean;
+};
+interface FinalFunkitConfigInternal extends FunkitConfig {
+    textCustomizations: FunkitTextCustomizationsConfig;
+    uiCustomizations: FunkitUiCustomizationsConfigInternal;
+}
+export declare const FunkitConfigContext: import("react").Context<FunkitConfig>;
+export declare function useFunkitConfig(): FinalFunkitConfigInternal;
+export {};

package/dist/providers/FunkitConnectChainContext.d.ts

@@ -0,0 +1,15 @@
+import React, { type ReactNode } from 'react';
+import type { Chain } from '../wagmi/chains';
+export interface FunkitConnectChain extends Chain {
+    iconUrl?: string | (() => Promise<string>) | null;
+    iconBackground?: string;
+}
+interface FunkitConnectChainProviderProps {
+    initialChain?: number;
+    children: ReactNode;
+}
+export declare function FunkitConnectChainProvider({ children, initialChain, }: FunkitConnectChainProviderProps): React.JSX.Element;
+export declare const useFunkitConnectChains: () => FunkitConnectChain[];
+export declare const useFunkitConnectChainsById: () => Record<number, FunkitConnectChain>;
+export declare const useInitialChainId: () => number | undefined;
+export {};

package/dist/providers/FunkitFlagsProvider.d.ts

@@ -0,0 +1,26 @@
+import React, { type ReactNode } from 'react';
+import type { FlagKey } from '@funkit/utils';
+import { flagConfig as offlineConfig } from '../utils/flags/config';
+import type { InferFlagType } from '../utils/flags/types';
+export type FlagValue<K extends FlagKey> = InferFlagType<(typeof offlineConfig)[K]>;
+export type FlagValues = {
+    [K in FlagKey]?: FlagValue<K>;
+};
+export type GetFlagFunction = <K extends FlagKey>(flagKey: K, fallback?: FlagValue<K>) => FlagValue<K>;
+export interface FunkitFlagsContextValue {
+    /** Error fetching flag config from server */
+    error: Error | null;
+    /** Loaded flags - each flag may be undefined if configuration from server was missing or invalid */
+    flags: FlagValues;
+    /** Synchronously reads a single flag (derived for current user) - returns fallback while loading */
+    getFlag: GetFlagFunction;
+    /** Whether flags are currently loading */
+    isLoading: boolean;
+}
+export declare const FunkitFlagsContext: React.Context<FunkitFlagsContextValue>;
+export declare function FunkitFlagsProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useFlags(): FunkitFlagsContextValue;
+export type FlagMiddleware<K extends FlagKey> = (flagValue: FlagValue<K>) => FlagValue<K>;
+export declare function useFlag<K extends FlagKey>(flagKey: K, fallback?: FlagValue<K>, middleware?: FlagMiddleware<K>): FlagValue<K>;

package/dist/providers/FunkitHistoryContext.d.ts

@@ -0,0 +1,45 @@
+import { type CheckoutHistoryItem, type DirectExecution } from '@funkit/api-base';
+import React, { type ReactNode } from 'react';
+import type { Address, Hex } from 'viem';
+import { type MergedCheckoutHistoryItem } from '../utils/checkout';
+import { type PurifiedCheckoutHistoryItem } from '../utils/purifyCheckoutHistoryItem';
+export type { HistoricalCheckoutItem, ServerCheckoutConfig, } from '../domains/clientMetadata';
+export type { FunkitCheckoutQuoteResult } from '../domains/quote';
+interface FunkitCheckoutHistoryContextInterface {
+    checkoutHistoryList: MergedCheckoutHistoryItem[];
+    isCheckoutHistoryInited: boolean;
+    isRefreshingCheckoutHistory: boolean;
+    refreshCheckoutHistory(): void;
+    startCheckoutHistoryListener(recipientAddr?: Address, expedited?: boolean): NodeJS.Timeout;
+    stopCheckoutHistoryListener(cancelIntervalId?: NodeJS.Timeout): void;
+}
+export declare function FunkitCheckoutHistoryProvider({ children, }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useCheckoutHistoryContext(): FunkitCheckoutHistoryContextInterface;
+/**
+ * External hook to listen for checkout history every 5000ms
+ * @param userId ID of the user (wallet address)
+ * @returns PurifiedCheckoutHistoryItem[]
+ */
+export declare function useCheckoutsListenerByUserId(userId: string | undefined): {
+    data?: PurifiedCheckoutHistoryItem[];
+    isLoading: boolean;
+};
+/**
+ * External hook to listen for checkout history every 5000ms
+ * @param checkoutId ID of the checkout
+ * @returns PurifiedCheckoutHistoryItem | null
+ */
+export declare function useCheckoutListenerByCheckoutId(checkoutId: Hex | undefined): {
+    data?: PurifiedCheckoutHistoryItem | null;
+    isLoading: boolean;
+};
+/**
+ * Internal hook to handle post-checkout, PER-BACKEND-CHECKOUT ITEM.
+ */
+export declare const useFunkitPostCheckoutInternal: (checkoutId: string | undefined) => {
+    isLoading: boolean;
+    checkoutHistoryInfo: CheckoutHistoryItem | undefined;
+    directExecutionInfo: DirectExecution | undefined;
+};

package/dist/providers/FunkitI18nProvider.d.ts

@@ -0,0 +1,12 @@
+import React, { type ReactNode } from 'react';
+import { type Locale } from '../locales';
+interface FunkitI18nProviderProps {
+    children: ReactNode;
+    locale?: Locale;
+}
+/**
+ * Provider for internationalization using react-i18next
+ * Wraps the application with I18nextProvider and manages locale changes
+ */
+export declare function FunkitI18nProvider({ children, locale, }: FunkitI18nProviderProps): React.JSX.Element;
+export {};

package/dist/providers/FunkitMoonpayProvider.d.ts

@@ -0,0 +1,10 @@
+export interface FunkitUserIpInfo {
+    alpha2: string;
+    state: string;
+}
+export declare function useFunkitUserIp(): {
+    isLoadingGeoCheck: boolean;
+    isUserGeoblocked: boolean;
+    userIpInfo: FunkitUserIpInfo | undefined;
+    isUserLoggedIn: boolean;
+};

package/dist/providers/FunkitProvider.d.ts

@@ -0,0 +1,35 @@
+import { type QueryClient } from '@tanstack/react-query';
+import React, { type ReactNode } from 'react';
+import type { Chain } from '../wagmi/chains';
+import type { Locale } from '../locales';
+import { type CreateFunkitWagmiConfigParameters } from '../config/getDefaultConfig';
+import { type AvatarComponent } from './AvatarContext';
+import { type FunkitConfig } from './FunkitConfigContext';
+import { type Theme } from './FunkitThemeProvider';
+import { type ModalSizes } from './ModalSizeContext';
+export declare const useThemeRootProps: () => {
+    "data-rk": string;
+};
+interface FunkitProviderInnerProps {
+    initialChain?: number;
+    id?: string;
+    children: ReactNode;
+    theme?: Theme;
+    avatar?: AvatarComponent;
+    locale?: Locale;
+    funkitConfig: FunkitConfig;
+    debug?: boolean | undefined;
+    sandbox?: boolean | undefined;
+    modalSize?: ModalSizes;
+    useStyleRefForTheme?: boolean;
+}
+export type FunkitWagmiConfig = Omit<CreateFunkitWagmiConfigParameters, 'funkitApiKey' | 'initialChainId' | 'appName'> & {
+    projectId: string;
+};
+export interface FunkitProviderProps extends Omit<FunkitProviderInnerProps, 'initialChain'> {
+    initialChain?: Chain | number;
+    wagmiConfig?: FunkitWagmiConfig;
+    queryClient?: QueryClient;
+}
+export declare function FunkitProvider(props: FunkitProviderProps): React.JSX.Element;
+export {};

package/dist/providers/FunkitQuoteContext.d.ts

@@ -0,0 +1,86 @@
+import type { Dnum } from 'dnum';
+import React, { type Dispatch, type ReactNode } from 'react';
+import type { FunkitCheckoutQuoteResult } from '../domains/quote';
+import { type FunkitActiveCheckoutItem } from './FunkitCheckoutContext';
+export type ApprovalMethod = 'approve' | 'sign';
+export declare const APPROVAL_METHOD_DEFAULT: ApprovalMethod;
+export type CheckoutQuoteError = {
+    maxTargetAssetAmount?: Dnum;
+    minTargetAssetAmount?: Dnum;
+    reason: 'insufficientBalance';
+} | {
+    maxTargetAssetAmount?: Dnum;
+    minTargetAssetAmount?: Dnum;
+    minTargetUsdAmount?: number;
+    reason: 'insufficientAmount';
+} | {
+    originalError: Error;
+    reason: 'internal';
+};
+export type CheckoutQuoteResult = {
+    success: true;
+} | {
+    error: CheckoutQuoteError;
+    success: false;
+};
+type GetCheckoutQuoteResponse = CheckoutQuoteResult & {
+    shellCheckoutItemWithNextQuote: FunkitActiveCheckoutItem;
+    quoteState: CheckoutQuoteState;
+};
+interface CheckoutQuoteState {
+    /** Whether the checkout quote is being fetched **/
+    isQuoting: boolean;
+    /** Latest checkout estimated fees and time **/
+    latestQuote: null | FunkitCheckoutQuoteResult;
+    /** The quotation step message **/
+    quoteStepMessage: string;
+    /** Error messages associated with checkout quote **/
+    quoteErrorMessage: ReactNode;
+}
+interface FunkitQuoteContextInterface extends CheckoutQuoteState {
+    clearCheckoutQuoteMessages: () => void;
+    getCheckoutQuote: (disableInformationStreaming?: boolean) => Promise<GetCheckoutQuoteResponse>;
+    setCheckoutQuote: Dispatch<React.SetStateAction<FunkitCheckoutQuoteResult | null>>;
+    setQuoteProgress: (state: Omit<CheckoutQuoteState, 'latestQuote'>) => void;
+    usePermit: boolean | undefined;
+    preferredApprovalMethod: ApprovalMethod;
+    setPreferredApprovalMethod: (next: ApprovalMethod) => void;
+    showApprovalMethodToggle: boolean;
+    /**
+     * Per-checkout EIP-2612 permit capability of the target asset. `undefined` =
+     * unknown (loading or feature-agnostic — Relay falls back server-side), set
+     * by prefetch hooks (e.g., Aave's `useAaveTargetReservePermit`). Folded into
+     * `showApprovalMethodToggle` so consumers don't need their own asset gate.
+     */
+    targetAssetSupportsPermit: boolean | undefined;
+    setTargetAssetSupportsPermit: (value: boolean | undefined) => void;
+    /**
+     * Current on-chain ERC-20 allowance from the user to the destination spender
+     * (e.g. the Aave Pool). When ≥ the supply amount, no approve / permit is
+     * needed and the toggle is hidden via `showApprovalMethodToggle`. `undefined`
+     * = unknown (loading or not applicable to this flow).
+     */
+    targetAssetPoolAllowance: bigint | undefined;
+    setTargetAssetPoolAllowance: (value: bigint | undefined) => void;
+}
+/**
+ * Shared preconditions (wallet-executed account-balance flows only), then a
+ * per-flow gate. Aave native supply is capability-gated: EIP-2612 support
+ * (`undefined` = still loading → show optimistically, `false` = hide) and no
+ * covering Pool allowance — never the feature flag (ENG-4070). The Relay
+ * flow's source-side Permit2-vs-approve choice stays behind the
+ * `enable-permit-toggle` Statsig rollout gate.
+ */
+export declare function shouldShowApprovalMethodToggle({ isPermitToggleGateOn, isDirectExecution, isAccountBalancePayment, isAaveNativeSupplyFlow, targetAssetSupportsPermit, targetAssetAllowanceCoversAmount, }: {
+    isPermitToggleGateOn: boolean;
+    isDirectExecution: boolean;
+    isAccountBalancePayment: boolean;
+    isAaveNativeSupplyFlow: boolean;
+    targetAssetSupportsPermit: boolean | undefined;
+    targetAssetAllowanceCoversAmount: boolean;
+}): boolean;
+export declare function FunkitQuoteProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useQuoteContext(): FunkitQuoteContextInterface;
+export {};

package/dist/providers/FunkitQuoteContext.track.d.ts

@@ -0,0 +1,8 @@
+import type { QuoteMode } from '../domains/quoteMode';
+import type { CheckoutModalEvent } from '../hooks/track/CheckoutModalEvent';
+import type { WithdrawModalEvent } from '../hooks/track/WithdrawModalEvent';
+import type { TrackEventData } from '../hooks/track/useTrack';
+import type { FunkitActiveCheckoutItem } from './FunkitCheckoutContext';
+import type { FunkitCheckoutQuoteResult } from './FunkitHistoryContext';
+export declare const trackEventFromBaseQuote: (checkoutItem: FunkitActiveCheckoutItem, eventName: CheckoutModalEvent | WithdrawModalEvent, quoteMode?: QuoteMode) => TrackEventData;
+export declare const trackEventFromFinalQuote: (finalEstimation: FunkitCheckoutQuoteResult, checkoutItem: FunkitActiveCheckoutItem, eventName: CheckoutModalEvent | WithdrawModalEvent, quoteMode?: QuoteMode) => TrackEventData;

package/dist/providers/FunkitSandboxContext.d.ts

@@ -0,0 +1,2 @@
+export declare const FunkitSandboxContext: import("react").Context<boolean>;
+export declare const useIsFunkitSandboxMode: () => boolean;

package/dist/providers/FunkitStatsigProvider.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { ReactNode } from 'react';
+export declare const STATSIG_CLIENT_KEY: "client-UmFd8WIJljA7cLmZuDqs3X25M8sKd5WIQP4BSC2bRbM";
+interface FunkitStatsigProviderProps {
+    children: ReactNode;
+    isDevelopment?: boolean;
+}
+export declare function FunkitStatsigProvider({ children, isDevelopment, }: FunkitStatsigProviderProps): React.JSX.Element;
+export {};