@liberfi.io/react 0.1.2 → 0.1.4

package/dist/index.d.mts

@@ -1,310 +1,442 @@
 import * as react from 'react';
 import { PropsWithChildren } from 'react';
 import * as _liberfi_io_types from '@liberfi.io/types';
-import { API, Chain, Token, TokenResolution, TokenCandle, TokenHolder, TokenMarketData, TokenSecurity, TokenStats, TradeActivity, WalletPnl, WalletPortfolioPnls, WalletPortfolios, Portfolio, PortfolioPnl } from '@liberfi.io/types';
+import { API, Chain, Token, TokenResolution, TokenCandle, TokenHolder, TokenMarketData, TokenSecurity, TokenStats, Trade, WalletPnl, WalletPortfolioPnls, WalletPortfolios, Portfolio, PortfolioPnl, Activity } from '@liberfi.io/types';
 import * as _tanstack_react_query from '@tanstack/react-query';
-import { UseQueryOptions, UseMutationOptions, UseInfiniteQueryOptions, InfiniteData } from '@tanstack/react-query';
+import { UseQueryOptions, UseMutationOptions } from '@tanstack/react-query';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 
+declare global {
+    interface Window {
+        __LIBERFI_VERSION__?: {
+            [key: string]: string;
+        };
+    }
+}
+
+/**
+ * Default prefix prepended to every TanStack Query key produced by hooks in
+ * this package. Can be overridden via
+ * `<DexClientProvider queryKeyPrefix="...">`.
+ */
+declare const DEFAULT_QUERY_KEY_PREFIX = "liberfi";
+/**
+ * Shape of the context value provided by `DexClientProvider` and consumed by
+ * `useDexClient`.
+ */
 interface DexClientContextValue {
+    /** REST / HTTP client implementing `API.IClient`. */
     client: API.IClient;
+    /** WebSocket subscription client implementing `API.ISubscribeClient`. */
     subscribeClient: API.ISubscribeClient;
-}
-declare const DexClientContext: react.Context<DexClientContextValue>;
-
+    /** Prefix used in all query keys produced by hooks. */
+    queryKeyPrefix: string;
+}
+/**
+ * Internal React context. Use `DexClientProvider` to supply the value and
+ * `useDexClient()` to consume it.
+ */
+declare const DexClientContext: react.Context<DexClientContextValue | null>;
+
+/**
+ * Returns the `DexClientContextValue` provided by `DexClientProvider`.
+ *
+ * @throws If called outside a `DexClientProvider`.
+ */
 declare function useDexClient(): DexClientContextValue;
 
+interface SubscriptionOptions {
+    /** Set to `false` to pause the subscription. Defaults to `true`. */
+    enabled?: boolean;
+    /** Called when the subscription encounters an error. */
+    onError?: (error: Error) => void;
+}
+
+/**
+ * Serialises a primitive value (or Date) into a stable string for use in query
+ * keys. `undefined` and `null` map to `""`.
+ */
+declare function toKeySegment(value: string | number | boolean | Date | undefined | null): string;
+/**
+ * Serialises an array value into a stable, sorted JSON string for use in
+ * query keys.
+ */
+declare function toSortedKeySegment(value: unknown[] | undefined | null): string;
+
+/** Parameters for {@link useFinalStretchTokensQuery}. */
 interface UseFinalStretchTokensQueryParams extends API.GetTokenListOptions {
     chain: Chain;
 }
-declare function finalStretchTokensQueryKey(params: UseFinalStretchTokensQueryParams): string[];
-declare function fetchFinalStretchTokens(client: API.IClient, { chain, ...options }: UseFinalStretchTokensQueryParams): Promise<Token[]>;
-declare function useFinalStretchTokensQuery(params: UseFinalStretchTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+declare const finalStretchTokensQueryKey: (params: UseFinalStretchTokensQueryParams, prefix?: string) => string[];
+declare const fetchFinalStretchTokens: (client: API.IClient, params: UseFinalStretchTokensQueryParams) => Promise<Token[]>;
+declare const useFinalStretchTokensQuery: (params: UseFinalStretchTokensQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<Token[], Error, Token[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<Token[], Error>;
 
+/** Parameters for {@link useMigratedTokensQuery}. */
 interface UseMigratedTokensQueryParams extends API.GetTokenListOptions {
     chain: Chain;
 }
-declare function migratedTokensQueryKey(params: UseMigratedTokensQueryParams): string[];
-declare function fetchMigratedTokens(client: API.IClient, { chain, ...options }: UseMigratedTokensQueryParams): Promise<Token[]>;
-declare function useMigratedTokensQuery(params: UseMigratedTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+declare const migratedTokensQueryKey: (params: UseMigratedTokensQueryParams, prefix?: string) => string[];
+declare const fetchMigratedTokens: (client: API.IClient, params: UseMigratedTokensQueryParams) => Promise<Token[]>;
+declare const useMigratedTokensQuery: (params: UseMigratedTokensQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<Token[], Error, Token[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<Token[], Error>;
 
+/** Parameters for {@link useNewTokensQuery}. */
 interface UseNewTokensQueryParams extends API.GetTokenListOptions {
     chain: Chain;
 }
-declare function newTokensQueryKey(params: UseNewTokensQueryParams): string[];
-declare function fetchNewTokens(client: API.IClient, { chain, ...options }: UseNewTokensQueryParams): Promise<Token[]>;
-declare function useNewTokensQuery(params: UseNewTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+declare const newTokensQueryKey: (params: UseNewTokensQueryParams, prefix?: string) => string[];
+declare const fetchNewTokens: (client: API.IClient, params: UseNewTokensQueryParams) => Promise<Token[]>;
+declare const useNewTokensQuery: (params: UseNewTokensQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<Token[], Error, Token[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<Token[], Error>;
 
+/**
+ * Builds the query key for `usePresignedUploadUrlQuery`.
+ *
+ * @param prefix - Override the default query key prefix.
+ */
+declare function presignedUploadUrlQueryKey(prefix?: string): string[];
+/** Fetches a presigned upload URL (for use outside React). */
 declare function fetchPresignedUploadUrl(client: API.IClient): Promise<string>;
+/** Fetches a one-time presigned upload URL. `staleTime` defaults to `0`. */
 declare function usePresignedUploadUrlQuery(options?: Omit<UseQueryOptions<string, Error, string, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<string, Error>;
 
 type UseSearchTokensQueryParams = API.SearchTokensOptions;
-declare function searchTokensQueryKey(params: UseSearchTokensQueryParams): string[];
-declare function fetchSearchTokens(client: API.IClient, params: UseSearchTokensQueryParams): Promise<_liberfi_io_types.SearchTokenCursorList>;
-declare function useSearchTokensQuery(params: UseSearchTokensQueryParams, options?: Omit<UseQueryOptions<API.SearchTokenCursorList, Error, API.SearchTokenCursorList, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<_liberfi_io_types.SearchTokenCursorList, Error>;
+declare const searchTokensQueryKey: (params: _liberfi_io_types.SearchTokensOptions, prefix?: string) => string[];
+declare const fetchSearchTokens: (client: API.IClient, params: _liberfi_io_types.SearchTokensOptions) => Promise<_liberfi_io_types.SearchTokenCursorList>;
+declare const useSearchTokensQuery: (params: _liberfi_io_types.SearchTokensOptions, options?: Omit<_tanstack_react_query.UseQueryOptions<_liberfi_io_types.SearchTokenCursorList, Error, _liberfi_io_types.SearchTokenCursorList, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<_liberfi_io_types.SearchTokenCursorList, Error>;
 
 type UseSendTxMutationParams = API.SendTxParams;
+/** Sends a transaction via the API client (for use outside React). */
 declare function sendTx(client: API.IClient, params: UseSendTxMutationParams): Promise<_liberfi_io_types.SendTxResult>;
+/** Mutation hook that sends a transaction. */
 declare function useSendTxMutation(options?: Omit<UseMutationOptions<API.SendTxResult, Error, UseSendTxMutationParams>, "mutationFn">): _tanstack_react_query.UseMutationResult<_liberfi_io_types.SendTxResult, Error, _liberfi_io_types.SendTxParams, unknown>;
 
+/** Parameters for {@link useStockTokensQuery}. */
 interface UseStockTokensQueryParams extends API.GetTokenListOptions {
     chain: Chain;
 }
-declare function stockTokensQueryKey(params: UseStockTokensQueryParams): string[];
-declare function fetchStockTokens(client: API.IClient, { chain, ...options }: UseStockTokensQueryParams): Promise<Token[]>;
-declare function useStockTokensQuery(params: UseStockTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+declare const stockTokensQueryKey: (params: UseStockTokensQueryParams, prefix?: string) => string[];
+declare const fetchStockTokens: (client: API.IClient, params: UseStockTokensQueryParams) => Promise<Token[]>;
+declare const useStockTokensQuery: (params: UseStockTokensQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<Token[], Error, Token[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<Token[], Error>;
 
 type UseSwapRouteQueryParams = API.SwapParams;
-declare function swapRouteQueryKey(params: UseSwapRouteQueryParams): string[];
-declare function fetchSwapRoute(client: API.IClient, params: UseSwapRouteQueryParams): Promise<_liberfi_io_types.SwapRoute>;
-declare function useSwapRouteQuery(params: UseSwapRouteQueryParams, options?: Omit<UseQueryOptions<API.SwapRoute, Error, API.SwapRoute, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<_liberfi_io_types.SwapRoute, Error>;
+declare const swapRouteQueryKey: (params: _liberfi_io_types.SwapParams, prefix?: string) => string[];
+declare const fetchSwapRoute: (client: API.IClient, params: _liberfi_io_types.SwapParams) => Promise<_liberfi_io_types.SwapRoute>;
+declare const useSwapRouteQuery: (params: _liberfi_io_types.SwapParams, options?: Omit<_tanstack_react_query.UseQueryOptions<_liberfi_io_types.SwapRoute, Error, _liberfi_io_types.SwapRoute, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<_liberfi_io_types.SwapRoute, Error>;
 
+/** Parameters for {@link useTokenCandlesQuery}. */
 interface UseTokenCandlesQueryParams extends API.GetTokenCandlesOptions {
     chain: Chain;
     address: string;
     resolution: TokenResolution;
 }
-declare function tokenCandlesQueryKey(params: UseTokenCandlesQueryParams): string[];
-declare function fetchTokenCandles(client: API.IClient, { chain, address, resolution, ...options }: UseTokenCandlesQueryParams): Promise<TokenCandle[]>;
-declare function useTokenCandlesQuery(params: UseTokenCandlesQueryParams, options?: Omit<UseQueryOptions<Array<TokenCandle>, Error, Array<TokenCandle>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenCandle[], Error>;
+declare const tokenCandlesQueryKey: (params: UseTokenCandlesQueryParams, prefix?: string) => string[];
+declare const fetchTokenCandles: (client: API.IClient, params: UseTokenCandlesQueryParams) => Promise<TokenCandle[]>;
+declare const useTokenCandlesQuery: (params: UseTokenCandlesQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<TokenCandle[], Error, TokenCandle[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<TokenCandle[], Error>;
 
+/** Parameters for {@link useTokenHoldersQuery}. */
 interface UseTokenHoldersQueryParams extends API.CursorListOptions {
     chain: Chain;
     address: string;
 }
-declare function tokenHoldersQueryKey(params: UseTokenHoldersQueryParams): string[];
-declare function fetchTokenHolders(client: API.IClient, { chain, address, ...options }: UseTokenHoldersQueryParams): Promise<_liberfi_io_types.CursorList<TokenHolder>>;
-declare function useTokenHoldersQuery(params: UseTokenHoldersQueryParams, options?: Omit<UseQueryOptions<API.CursorList<TokenHolder>, Error, API.CursorList<TokenHolder>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<API.CursorList<TokenHolder>, Error>;
+declare const tokenHoldersQueryKey: (params: UseTokenHoldersQueryParams, prefix?: string) => string[];
+declare const fetchTokenHolders: (client: API.IClient, params: UseTokenHoldersQueryParams) => Promise<API.CursorList<TokenHolder>>;
+declare const useTokenHoldersQuery: (params: UseTokenHoldersQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<API.CursorList<TokenHolder>, Error, API.CursorList<TokenHolder>, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<API.CursorList<TokenHolder>, Error>;
 
+/** Parameters for {@link useTokenMarketDataQuery}. */
 interface UseTokenMarketDataQueryParams {
     chain: Chain;
     address: string;
 }
-declare function tokenMarketDataQueryKey(params: UseTokenMarketDataQueryParams): string[];
-declare function fetchTokenMarketData(client: API.IClient, { chain, address }: UseTokenMarketDataQueryParams): Promise<TokenMarketData>;
-declare function useTokenMarketDataQuery(params: UseTokenMarketDataQueryParams, options?: Omit<UseQueryOptions<TokenMarketData, Error, TokenMarketData, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenMarketData, Error>;
+declare const tokenMarketDataQueryKey: (params: UseTokenMarketDataQueryParams, prefix?: string) => string[];
+declare const fetchTokenMarketData: (client: _liberfi_io_types.IClient, params: UseTokenMarketDataQueryParams) => Promise<TokenMarketData>;
+declare const useTokenMarketDataQuery: (params: UseTokenMarketDataQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<TokenMarketData, Error, TokenMarketData, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<TokenMarketData, Error>;
 
+/** Parameters for {@link useTokenQuery}. */
 interface UseTokenQueryParams {
     chain: Chain;
     address: string;
 }
-declare function tokenQueryKey(params: UseTokenQueryParams): string[];
-declare function fetchToken(client: API.IClient, { chain, address }: UseTokenQueryParams): Promise<Token>;
-declare function useTokenQuery(params: UseTokenQueryParams, options?: Omit<UseQueryOptions<Token, Error, Token, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token, Error>;
+declare const tokenQueryKey: (params: UseTokenQueryParams, prefix?: string) => string[];
+declare const fetchToken: (client: _liberfi_io_types.IClient, params: UseTokenQueryParams) => Promise<Token>;
+declare const useTokenQuery: (params: UseTokenQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<Token, Error, Token, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<Token, Error>;
 
+/** Parameters for {@link useTokenSecurityQuery}. */
 interface UseTokenSecurityQueryParams {
     chain: Chain;
     address: string;
 }
-declare function tokenSecurityQueryKey(params: UseTokenSecurityQueryParams): string[];
-declare function fetchTokenSecurity(client: API.IClient, { chain, address }: UseTokenSecurityQueryParams): Promise<TokenSecurity>;
-declare function useTokenSecurityQuery(params: UseTokenSecurityQueryParams, options?: Omit<UseQueryOptions<TokenSecurity, Error, TokenSecurity, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenSecurity, Error>;
+declare const tokenSecurityQueryKey: (params: UseTokenSecurityQueryParams, prefix?: string) => string[];
+declare const fetchTokenSecurity: (client: _liberfi_io_types.IClient, params: UseTokenSecurityQueryParams) => Promise<TokenSecurity>;
+declare const useTokenSecurityQuery: (params: UseTokenSecurityQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<TokenSecurity, Error, TokenSecurity, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<TokenSecurity, Error>;
 
+/** Parameters for {@link useTokensQuery}. */
 interface UseTokensQueryParams {
     chain: Chain;
     addresses: Array<string>;
 }
-declare function tokensQueryKey(params: UseTokensQueryParams): string[];
-declare function fetchTokens(client: API.IClient, { chain, addresses }: UseTokensQueryParams): Promise<Token[]>;
-declare function useTokensQuery(params: UseTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+declare const tokensQueryKey: (params: UseTokensQueryParams, prefix?: string) => string[];
+declare const fetchTokens: (client: _liberfi_io_types.IClient, params: UseTokensQueryParams) => Promise<Token[]>;
+declare const useTokensQuery: (params: UseTokensQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<Token[], Error, Token[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<Token[], Error>;
 
+/** Parameters for {@link useTokenStatsQuery}. */
 interface UseTokenStatsQueryParams {
     chain: Chain;
     address: string;
 }
-declare function tokenStatsQueryKey(params: UseTokenStatsQueryParams): string[];
-declare function fetchTokenStats(client: API.IClient, { chain, address }: UseTokenStatsQueryParams): Promise<TokenStats>;
-declare function useTokenStatsQuery(params: UseTokenStatsQueryParams, options?: Omit<UseQueryOptions<TokenStats, Error, TokenStats, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<TokenStats, Error>;
+declare const tokenStatsQueryKey: (params: UseTokenStatsQueryParams, prefix?: string) => string[];
+declare const fetchTokenStats: (client: _liberfi_io_types.IClient, params: UseTokenStatsQueryParams) => Promise<TokenStats>;
+declare const useTokenStatsQuery: (params: UseTokenStatsQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<TokenStats, Error, TokenStats, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<TokenStats, Error>;
 
-interface UseTokenTradeActivitiesQueryParams extends API.GetTradeActivitiesOptions {
+/** Parameters for {@link useTokenTradesQuery}. */
+interface UseTokenTradesQueryParams extends API.GetTradesOptions {
     chain: Chain;
     address: string;
 }
-declare function tokenTradeActivitiesQueryKey(params: UseTokenTradeActivitiesQueryParams): string[];
-declare function fetchTokenTradeActivities(client: API.IClient, { chain, address, ...options }: UseTokenTradeActivitiesQueryParams): Promise<_liberfi_io_types.CursorList<TradeActivity>>;
-declare function useTokenTradeActivitiesQuery(params: UseTokenTradeActivitiesQueryParams, options?: Omit<UseQueryOptions<API.CursorList<TradeActivity>, Error, API.CursorList<TradeActivity>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<API.CursorList<TradeActivity>, Error>;
+declare const tokenTradesQueryKey: (params: UseTokenTradesQueryParams, prefix?: string) => string[];
+declare const fetchTokenTrades: (client: API.IClient, params: UseTokenTradesQueryParams) => Promise<API.CursorList<Trade>>;
+declare const useTokenTradesQuery: (params: UseTokenTradesQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<API.CursorList<Trade>, Error, API.CursorList<Trade>, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<API.CursorList<Trade>, Error>;
 
+/** Parameters for {@link useTrendingTokensQuery}. */
 interface UseTrendingTokensQueryParams extends API.GetTokenListOptions {
     chain: Chain;
     resolution: "1m" | "5m" | "1h" | "4h" | "24h";
 }
-declare function trendingTokensQueryKey(params: UseTrendingTokensQueryParams): string[];
-declare function fetchTrendingTokens(client: API.IClient, { chain, resolution, ...options }: UseTrendingTokensQueryParams): Promise<Token[]>;
-declare function useTrendingTokensQuery(params: UseTrendingTokensQueryParams, options?: Omit<UseQueryOptions<Array<Token>, Error, Array<Token>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Token[], Error>;
+declare const trendingTokensQueryKey: (params: UseTrendingTokensQueryParams, prefix?: string) => string[];
+declare const fetchTrendingTokens: (client: API.IClient, params: UseTrendingTokensQueryParams) => Promise<Token[]>;
+declare const useTrendingTokensQuery: (params: UseTrendingTokensQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<Token[], Error, Token[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<Token[], Error>;
 
+/** Parameters for {@link useTxSuccessQuery}. */
 interface UseTxSuccessQueryParams {
     chain: Chain;
     txHash: string;
     timeout?: number;
 }
-declare function txSuccessQueryKey(params: UseTxSuccessQueryParams): string[];
-declare function fetchTxSuccess(client: API.IClient, { chain, txHash, timeout }: UseTxSuccessQueryParams): Promise<boolean>;
-declare function useTxSuccessQuery(params: UseTxSuccessQueryParams, options?: Omit<UseQueryOptions<boolean, Error, boolean, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<boolean, Error>;
+declare const txSuccessQueryKey: (params: UseTxSuccessQueryParams, prefix?: string) => string[];
+declare const fetchTxSuccess: (client: _liberfi_io_types.IClient, params: UseTxSuccessQueryParams) => Promise<boolean>;
+declare const useTxSuccessQuery: (params: UseTxSuccessQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<boolean, Error, boolean, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<boolean, Error>;
 
+/** Parameters for {@link useWalletPnlQuery}. */
 interface UseWalletPnlQueryParams {
     chain: Chain;
     address: string;
     resolution?: string;
 }
-declare function walletPnlQueryKey(params: UseWalletPnlQueryParams): string[];
-declare function fetchWalletPnl(client: API.IClient, { chain, address, resolution }: UseWalletPnlQueryParams): Promise<WalletPnl>;
-declare function useWalletPnlQuery(params: UseWalletPnlQueryParams, options?: Omit<UseQueryOptions<WalletPnl, Error, WalletPnl, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<WalletPnl, Error>;
+declare const walletPnlQueryKey: (params: UseWalletPnlQueryParams, prefix?: string) => string[];
+declare const fetchWalletPnl: (client: _liberfi_io_types.IClient, params: UseWalletPnlQueryParams) => Promise<WalletPnl>;
+declare const useWalletPnlQuery: (params: UseWalletPnlQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<WalletPnl, Error, WalletPnl, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<WalletPnl, Error>;
 
+/** Parameters for {@link useWalletPortfolioPnlsQuery}. */
 interface UseWalletPortfolioPnlsQueryParams {
     chain: Chain;
     address: string;
     cursor?: string;
     limit?: number;
 }
-declare function walletPortfolioPnlsQueryKey(params: UseWalletPortfolioPnlsQueryParams): string[];
-declare function fetchWalletPortfolioPnls(client: API.IClient, { chain, address, cursor, limit }: UseWalletPortfolioPnlsQueryParams): Promise<WalletPortfolioPnls>;
-declare function useWalletPortfolioPnlsQuery(params: UseWalletPortfolioPnlsQueryParams, options?: Omit<UseQueryOptions<WalletPortfolioPnls, Error, WalletPortfolioPnls, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<WalletPortfolioPnls, Error>;
+declare const walletPortfolioPnlsQueryKey: (params: UseWalletPortfolioPnlsQueryParams, prefix?: string) => string[];
+declare const fetchWalletPortfolioPnls: (client: _liberfi_io_types.IClient, params: UseWalletPortfolioPnlsQueryParams) => Promise<WalletPortfolioPnls>;
+declare const useWalletPortfolioPnlsQuery: (params: UseWalletPortfolioPnlsQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<WalletPortfolioPnls, Error, WalletPortfolioPnls, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<WalletPortfolioPnls, Error>;
 
+/** Parameters for {@link useWalletPortfolioPnlsInfiniteQuery}. */
 interface UseWalletPortfolioPnlsInfiniteQueryParams {
     chain: Chain;
     address: string;
     limit?: number;
 }
-declare function walletPortfolioPnlsInfiniteQueryKey(params: UseWalletPortfolioPnlsInfiniteQueryParams): string[];
-declare function useWalletPortfolioPnlsInfiniteQuery(params: UseWalletPortfolioPnlsInfiniteQueryParams, options?: Omit<UseInfiniteQueryOptions<WalletPortfolioPnls, Error, InfiniteData<WalletPortfolioPnls>, string[], string | undefined>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">): _tanstack_react_query.UseInfiniteQueryResult<InfiniteData<WalletPortfolioPnls, unknown>, Error>;
+declare const walletPortfolioPnlsInfiniteQueryKey: (params: UseWalletPortfolioPnlsInfiniteQueryParams, prefix?: string) => string[];
+declare const useWalletPortfolioPnlsInfiniteQuery: (params: UseWalletPortfolioPnlsInfiniteQueryParams, options?: Omit<_tanstack_react_query.UseInfiniteQueryOptions<WalletPortfolioPnls, Error, _tanstack_react_query.InfiniteData<WalletPortfolioPnls, unknown>, string[], string | undefined>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam"> | undefined) => _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<WalletPortfolioPnls, unknown>, Error>;
 
+/** Parameters for {@link useWalletPortfoliosQuery}. */
 interface UseWalletPortfoliosQueryParams {
     chain: Chain;
     address: string;
     cursor?: string;
     limit?: number;
 }
-declare function walletPortfoliosQueryKey(params: UseWalletPortfoliosQueryParams): string[];
-declare function fetchWalletPortfolios(client: API.IClient, { chain, address, cursor, limit }: UseWalletPortfoliosQueryParams): Promise<WalletPortfolios>;
-declare function useWalletPortfoliosQuery(params: UseWalletPortfoliosQueryParams, options?: Omit<UseQueryOptions<WalletPortfolios, Error, WalletPortfolios, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<WalletPortfolios, Error>;
+declare const walletPortfoliosQueryKey: (params: UseWalletPortfoliosQueryParams, prefix?: string) => string[];
+declare const fetchWalletPortfolios: (client: _liberfi_io_types.IClient, params: UseWalletPortfoliosQueryParams) => Promise<WalletPortfolios>;
+declare const useWalletPortfoliosQuery: (params: UseWalletPortfoliosQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<WalletPortfolios, Error, WalletPortfolios, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<WalletPortfolios, Error>;
 
+/** Parameters for {@link useWalletPortfoliosByTokensQuery}. */
 interface UseWalletPortfoliosByTokensQueryParams {
     chain: Chain;
     address: string;
     tokenAddresses: Array<string>;
 }
-declare function walletPortfoliosByTokensQueryKey(params: UseWalletPortfoliosByTokensQueryParams): string[];
-declare function fetchWalletPortfoliosByTokens(client: API.IClient, { chain, address, tokenAddresses }: UseWalletPortfoliosByTokensQueryParams): Promise<Portfolio[]>;
-declare function useWalletPortfoliosByTokensQuery(params: UseWalletPortfoliosByTokensQueryParams, options?: Omit<UseQueryOptions<Array<Portfolio>, Error, Array<Portfolio>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<Portfolio[], Error>;
+declare const walletPortfoliosByTokensQueryKey: (params: UseWalletPortfoliosByTokensQueryParams, prefix?: string) => string[];
+declare const fetchWalletPortfoliosByTokens: (client: _liberfi_io_types.IClient, params: UseWalletPortfoliosByTokensQueryParams) => Promise<Portfolio[]>;
+declare const useWalletPortfoliosByTokensQuery: (params: UseWalletPortfoliosByTokensQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<Portfolio[], Error, Portfolio[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<Portfolio[], Error>;
 
+/** Parameters for {@link useWalletPortfoliosInfiniteQuery}. */
 interface UseWalletPortfoliosInfiniteQueryParams {
     chain: Chain;
     address: string;
     limit?: number;
 }
-declare function walletPortfoliosInfiniteQueryKey(params: UseWalletPortfoliosInfiniteQueryParams): string[];
-declare function useWalletPortfoliosInfiniteQuery(params: UseWalletPortfoliosInfiniteQueryParams, options?: Omit<UseInfiniteQueryOptions<WalletPortfolios, Error, InfiniteData<WalletPortfolios>, string[], string | undefined>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">): _tanstack_react_query.UseInfiniteQueryResult<InfiniteData<WalletPortfolios, unknown>, Error>;
+declare const walletPortfoliosInfiniteQueryKey: (params: UseWalletPortfoliosInfiniteQueryParams, prefix?: string) => string[];
+declare const useWalletPortfoliosInfiniteQuery: (params: UseWalletPortfoliosInfiniteQueryParams, options?: Omit<_tanstack_react_query.UseInfiniteQueryOptions<WalletPortfolios, Error, _tanstack_react_query.InfiniteData<WalletPortfolios, unknown>, string[], string | undefined>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam"> | undefined) => _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<WalletPortfolios, unknown>, Error>;
 
+/** Parameters for {@link useWalletPortfolioPnlsByTokensQuery}. */
 interface UseWalletPortfolioPnlsByTokensQueryParams {
     chain: Chain;
     address: string;
     tokenAddresses: Array<string>;
 }
-declare function walletPortfolioPnlsByTokensQueryKey(params: UseWalletPortfolioPnlsByTokensQueryParams): string[];
-declare function fetchWalletPortfolioPnlsByTokens(client: API.IClient, { chain, address, tokenAddresses }: UseWalletPortfolioPnlsByTokensQueryParams): Promise<PortfolioPnl[]>;
-declare function useWalletPortfolioPnlsByTokensQuery(params: UseWalletPortfolioPnlsByTokensQueryParams, options?: Omit<UseQueryOptions<Array<PortfolioPnl>, Error, Array<PortfolioPnl>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<PortfolioPnl[], Error>;
+declare const walletPortfolioPnlsByTokensQueryKey: (params: UseWalletPortfolioPnlsByTokensQueryParams, prefix?: string) => string[];
+declare const fetchWalletPortfolioPnlsByTokens: (client: _liberfi_io_types.IClient, params: UseWalletPortfolioPnlsByTokensQueryParams) => Promise<PortfolioPnl[]>;
+declare const useWalletPortfolioPnlsByTokensQuery: (params: UseWalletPortfolioPnlsByTokensQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<PortfolioPnl[], Error, PortfolioPnl[], string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<PortfolioPnl[], Error>;
 
-interface UseWalletTradeActivitiesQueryParams extends API.GetTradeActivitiesOptions {
+/** Parameters for {@link useWalletTradesQuery}. */
+interface UseWalletTradesQueryParams extends API.GetTradesOptions {
     chain: Chain;
     address: string;
 }
-declare function walletTradeActivitiesQueryKey(params: UseWalletTradeActivitiesQueryParams): string[];
-declare function fetchWalletTradeActivities(client: API.IClient, { chain, address, ...options }: UseWalletTradeActivitiesQueryParams): Promise<_liberfi_io_types.CursorList<TradeActivity>>;
-declare function useWalletTradeActivitiesQuery(params: UseWalletTradeActivitiesQueryParams, options?: Omit<UseQueryOptions<API.CursorList<TradeActivity>, Error, API.CursorList<TradeActivity>, string[]>, "queryKey" | "queryFn">): _tanstack_react_query.UseQueryResult<API.CursorList<TradeActivity>, Error>;
+declare const walletTradesQueryKey: (params: UseWalletTradesQueryParams, prefix?: string) => string[];
+declare const fetchWalletTrades: (client: API.IClient, params: UseWalletTradesQueryParams) => Promise<API.CursorList<Trade>>;
+declare const useWalletTradesQuery: (params: UseWalletTradesQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<API.CursorList<Trade>, Error, API.CursorList<Trade>, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<API.CursorList<Trade>, Error>;
 
+/** Parameters for {@link useTokenActivitiesQuery}. */
+interface UseTokenActivitiesQueryParams extends API.GetActivitiesOptions {
+    chain: Chain;
+    address: string;
+}
+declare const tokenActivitiesQueryKey: (params: UseTokenActivitiesQueryParams, prefix?: string) => string[];
+declare const fetchTokenActivities: (client: API.IClient, params: UseTokenActivitiesQueryParams) => Promise<API.CursorList<Activity>>;
+declare const useTokenActivitiesQuery: (params: UseTokenActivitiesQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<API.CursorList<Activity>, Error, API.CursorList<Activity>, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<API.CursorList<Activity>, Error>;
+
+/** Parameters for {@link useWalletActivitiesQuery}. */
+interface UseWalletActivitiesQueryParams extends API.GetActivitiesOptions {
+    chain: Chain;
+    address: string;
+}
+declare const walletActivitiesQueryKey: (params: UseWalletActivitiesQueryParams, prefix?: string) => string[];
+declare const fetchWalletActivities: (client: API.IClient, params: UseWalletActivitiesQueryParams) => Promise<API.CursorList<Activity>>;
+declare const useWalletActivitiesQuery: (params: UseWalletActivitiesQueryParams, options?: Omit<_tanstack_react_query.UseQueryOptions<API.CursorList<Activity>, Error, API.CursorList<Activity>, string[]>, "queryKey" | "queryFn"> | undefined) => _tanstack_react_query.UseQueryResult<API.CursorList<Activity>, Error>;
+
+/** Parameters for {@link useTokenSubscription}. */
 interface UseTokenSubscriptionParams {
     chain: Chain;
     address: string;
 }
-declare function useTokenSubscription(params: UseTokenSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time updates for a single token. */
+declare function useTokenSubscription(params: UseTokenSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useTokenCandlesSubscription}. */
 interface UseTokenCandlesSubscriptionParams {
     chain: Chain;
     address: string;
     resolution: TokenResolution;
 }
-declare function useTokenCandlesSubscription(params: UseTokenCandlesSubscriptionParams, callback: (candles: Array<TokenCandle>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time candle updates for a token. */
+declare function useTokenCandlesSubscription(params: UseTokenCandlesSubscriptionParams, callback: (candles: Array<TokenCandle>) => void, options?: SubscriptionOptions): void;
 
-interface UseTokenTradeActivitiesSubscriptionParams {
+/** Parameters for {@link useTokenTradesSubscription}. */
+interface UseTokenTradesSubscriptionParams {
     chain: Chain;
     address: string;
 }
-declare function useTokenTradeActivitiesSubscription(params: UseTokenTradeActivitiesSubscriptionParams, callback: (trades: Array<TradeActivity>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time trade events for a token. */
+declare function useTokenTradesSubscription(params: UseTokenTradesSubscriptionParams, callback: (trades: Array<Trade>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useWalletPnlSubscription}. */
 interface UseWalletPnlSubscriptionParams {
     chain: Chain;
     address: string;
 }
-declare function useWalletPnlSubscription(params: UseWalletPnlSubscriptionParams, callback: (pnls: Array<API.WalletPnlSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time wallet PnL updates. */
+declare function useWalletPnlSubscription(params: UseWalletPnlSubscriptionParams, callback: (pnls: Array<API.WalletPnlSubscribed>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useWalletPortfoliosSubscription}. */
 interface UseWalletPortfoliosSubscriptionParams {
     chain: Chain;
     address: string;
 }
-declare function useWalletPortfoliosSubscription(params: UseWalletPortfoliosSubscriptionParams, callback: (portfolios: Array<API.PortfolioSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time wallet portfolio updates. */
+declare function useWalletPortfoliosSubscription(params: UseWalletPortfoliosSubscriptionParams, callback: (portfolios: Array<API.PortfolioSubscribed>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useWalletPortfolioPnlsSubscription}. */
 interface UseWalletPortfolioPnlsSubscriptionParams {
     chain: Chain;
     address: string;
 }
-declare function useWalletPortfolioPnlsSubscription(params: UseWalletPortfolioPnlsSubscriptionParams, callback: (portfolioPnls: Array<API.PortfolioPnlSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time wallet portfolio PnL updates. */
+declare function useWalletPortfolioPnlsSubscription(params: UseWalletPortfolioPnlsSubscriptionParams, callback: (portfolioPnls: Array<API.PortfolioPnlSubscribed>) => void, options?: SubscriptionOptions): void;
 
-interface UseWalletTradeActivitiesSubscriptionParams {
+/** Parameters for {@link useWalletTradesSubscription}. */
+interface UseWalletTradesSubscriptionParams {
     chain: Chain;
     address: string;
 }
-declare function useWalletTradeActivitiesSubscription(params: UseWalletTradeActivitiesSubscriptionParams, callback: (trades: Array<TradeActivity>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time wallet trade events. */
+declare function useWalletTradesSubscription(params: UseWalletTradesSubscriptionParams, callback: (trades: Array<Trade>) => void, options?: SubscriptionOptions): void;
+
+/** Parameters for {@link useTokenActivitiesSubscription}. */
+interface UseTokenActivitiesSubscriptionParams {
+    chain: Chain;
+    address: string;
+}
+/** Subscribes to real-time activity events for a token. */
+declare function useTokenActivitiesSubscription(params: UseTokenActivitiesSubscriptionParams, callback: (activities: Array<Activity>) => void, options?: SubscriptionOptions): void;
+
+/** Parameters for {@link useWalletActivitiesSubscription}. */
+interface UseWalletActivitiesSubscriptionParams {
+    chain: Chain;
+    address: string;
+}
+/** Subscribes to real-time wallet activity events. */
+declare function useWalletActivitiesSubscription(params: UseWalletActivitiesSubscriptionParams, callback: (activities: Array<Activity>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useNewTokensSubscription}. */
 interface UseNewTokensSubscriptionParams {
     chain: Chain;
 }
-declare function useNewTokensSubscription(params: UseNewTokensSubscriptionParams, callback: (tokens: Array<API.TokenSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time new token listings. */
+declare function useNewTokensSubscription(params: UseNewTokensSubscriptionParams, callback: (tokens: Array<API.TokenSubscribed>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useTrendingTokensSubscription}. */
 interface UseTrendingTokensSubscriptionParams {
     chain: Chain;
 }
-declare function useTrendingTokensSubscription(params: UseTrendingTokensSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time trending token updates. */
+declare function useTrendingTokensSubscription(params: UseTrendingTokensSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useMigratedTokensSubscription}. */
 interface UseMigratedTokensSubscriptionParams {
     chain: Chain;
 }
-declare function useMigratedTokensSubscription(params: UseMigratedTokensSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time migrated token updates. */
+declare function useMigratedTokensSubscription(params: UseMigratedTokensSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useFinalStretchTokensSubscription}. */
 interface UseFinalStretchTokensSubscriptionParams {
     chain: Chain;
 }
-declare function useFinalStretchTokensSubscription(params: UseFinalStretchTokensSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
+/** Subscribes to real-time final-stretch token updates. */
+declare function useFinalStretchTokensSubscription(params: UseFinalStretchTokensSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: SubscriptionOptions): void;
 
+/** Parameters for {@link useStockTokensSubscription}. */
 interface UseStockTokensSubscriptionParams {
     chain: Chain;
 }
-declare function useStockTokensSubscription(params: UseStockTokensSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: {
-    enabled?: boolean;
-}): void;
-
-type DexClientProviderProps = PropsWithChildren<DexClientContextValue>;
-declare function DexClientProvider({ client, subscribeClient, children, }: DexClientProviderProps): react_jsx_runtime.JSX.Element;
+/** Subscribes to real-time stock token updates. */
+declare function useStockTokensSubscription(params: UseStockTokensSubscriptionParams, callback: (data: Array<API.TokenSubscribed>) => void, options?: SubscriptionOptions): void;
 
-export { DexClientContext, type DexClientContextValue, DexClientProvider, type DexClientProviderProps, type UseFinalStretchTokensQueryParams, type UseFinalStretchTokensSubscriptionParams, type UseMigratedTokensQueryParams, type UseMigratedTokensSubscriptionParams, type UseNewTokensQueryParams, type UseNewTokensSubscriptionParams, type UseSearchTokensQueryParams, type UseSendTxMutationParams, type UseStockTokensQueryParams, type UseStockTokensSubscriptionParams, type UseSwapRouteQueryParams, type UseTokenCandlesQueryParams, type UseTokenCandlesSubscriptionParams, type UseTokenHoldersQueryParams, type UseTokenMarketDataQueryParams, type UseTokenQueryParams, type UseTokenSecurityQueryParams, type UseTokenStatsQueryParams, type UseTokenSubscriptionParams, type UseTokenTradeActivitiesQueryParams, type UseTokenTradeActivitiesSubscriptionParams, type UseTokensQueryParams, type UseTrendingTokensQueryParams, type UseTrendingTokensSubscriptionParams, type UseTxSuccessQueryParams, type UseWalletPnlQueryParams, type UseWalletPnlSubscriptionParams, type UseWalletPortfolioPnlsByTokensQueryParams, type UseWalletPortfolioPnlsInfiniteQueryParams, type UseWalletPortfolioPnlsQueryParams, type UseWalletPortfolioPnlsSubscriptionParams, type UseWalletPortfoliosByTokensQueryParams, type UseWalletPortfoliosInfiniteQueryParams, type UseWalletPortfoliosQueryParams, type UseWalletPortfoliosSubscriptionParams, type UseWalletTradeActivitiesQueryParams, type UseWalletTradeActivitiesSubscriptionParams, fetchFinalStretchTokens, fetchMigratedTokens, fetchNewTokens, fetchPresignedUploadUrl, fetchSearchTokens, fetchStockTokens, fetchSwapRoute, fetchToken, fetchTokenCandles, fetchTokenHolders, fetchTokenMarketData, fetchTokenSecurity, fetchTokenStats, fetchTokenTradeActivities, fetchTokens, fetchTrendingTokens, fetchTxSuccess, fetchWalletPnl, fetchWalletPortfolioPnls, fetchWalletPortfolioPnlsByTokens, fetchWalletPortfolios, fetchWalletPortfoliosByTokens, fetchWalletTradeActivities, finalStretchTokensQueryKey, migratedTokensQueryKey, newTokensQueryKey, searchTokensQueryKey, sendTx, stockTokensQueryKey, swapRouteQueryKey, tokenCandlesQueryKey, tokenHoldersQueryKey, tokenMarketDataQueryKey, tokenQueryKey, tokenSecurityQueryKey, tokenStatsQueryKey, tokenTradeActivitiesQueryKey, tokensQueryKey, trendingTokensQueryKey, txSuccessQueryKey, useDexClient, useFinalStretchTokensQuery, useFinalStretchTokensSubscription, useMigratedTokensQuery, useMigratedTokensSubscription, useNewTokensQuery, useNewTokensSubscription, usePresignedUploadUrlQuery, useSearchTokensQuery, useSendTxMutation, useStockTokensQuery, useStockTokensSubscription, useSwapRouteQuery, useTokenCandlesQuery, useTokenCandlesSubscription, useTokenHoldersQuery, useTokenMarketDataQuery, useTokenQuery, useTokenSecurityQuery, useTokenStatsQuery, useTokenSubscription, useTokenTradeActivitiesQuery, useTokenTradeActivitiesSubscription, useTokensQuery, useTrendingTokensQuery, useTrendingTokensSubscription, useTxSuccessQuery, useWalletPnlQuery, useWalletPnlSubscription, useWalletPortfolioPnlsByTokensQuery, useWalletPortfolioPnlsInfiniteQuery, useWalletPortfolioPnlsQuery, useWalletPortfolioPnlsSubscription, useWalletPortfoliosByTokensQuery, useWalletPortfoliosInfiniteQuery, useWalletPortfoliosQuery, useWalletPortfoliosSubscription, useWalletTradeActivitiesQuery, useWalletTradeActivitiesSubscription, walletPnlQueryKey, walletPortfolioPnlsByTokensQueryKey, walletPortfolioPnlsInfiniteQueryKey, walletPortfolioPnlsQueryKey, walletPortfoliosByTokensQueryKey, walletPortfoliosInfiniteQueryKey, walletPortfoliosQueryKey, walletTradeActivitiesQueryKey };
+type DexClientProviderProps = PropsWithChildren<{
+    client: API.IClient;
+    subscribeClient: API.ISubscribeClient;
+    /**
+     * Prefix prepended to every TanStack Query key produced by hooks in this
+     * package. Useful for avoiding collisions with other libraries.
+     *
+     * @default "liberfi"
+     */
+    queryKeyPrefix?: string;
+}>;
+/**
+ * Provides the Dex client instances and configuration to all descendant hooks.
+ *
+ * Both `client` and `subscribeClient` should be referentially stable (e.g.
+ * created with `useMemo` or stored in a `useRef`) to avoid unnecessary
+ * re-renders of consumers.
+ */
+declare function DexClientProvider({ client, subscribeClient, queryKeyPrefix, children, }: DexClientProviderProps): react_jsx_runtime.JSX.Element;
+
+export { DEFAULT_QUERY_KEY_PREFIX, DexClientContext, type DexClientContextValue, DexClientProvider, type DexClientProviderProps, type SubscriptionOptions, type UseFinalStretchTokensQueryParams, type UseFinalStretchTokensSubscriptionParams, type UseMigratedTokensQueryParams, type UseMigratedTokensSubscriptionParams, type UseNewTokensQueryParams, type UseNewTokensSubscriptionParams, type UseSearchTokensQueryParams, type UseSendTxMutationParams, type UseStockTokensQueryParams, type UseStockTokensSubscriptionParams, type UseSwapRouteQueryParams, type UseTokenActivitiesQueryParams, type UseTokenActivitiesSubscriptionParams, type UseTokenCandlesQueryParams, type UseTokenCandlesSubscriptionParams, type UseTokenHoldersQueryParams, type UseTokenMarketDataQueryParams, type UseTokenQueryParams, type UseTokenSecurityQueryParams, type UseTokenStatsQueryParams, type UseTokenSubscriptionParams, type UseTokenTradesQueryParams, type UseTokenTradesSubscriptionParams, type UseTokensQueryParams, type UseTrendingTokensQueryParams, type UseTrendingTokensSubscriptionParams, type UseTxSuccessQueryParams, type UseWalletActivitiesQueryParams, type UseWalletActivitiesSubscriptionParams, type UseWalletPnlQueryParams, type UseWalletPnlSubscriptionParams, type UseWalletPortfolioPnlsByTokensQueryParams, type UseWalletPortfolioPnlsInfiniteQueryParams, type UseWalletPortfolioPnlsQueryParams, type UseWalletPortfolioPnlsSubscriptionParams, type UseWalletPortfoliosByTokensQueryParams, type UseWalletPortfoliosInfiniteQueryParams, type UseWalletPortfoliosQueryParams, type UseWalletPortfoliosSubscriptionParams, type UseWalletTradesQueryParams, type UseWalletTradesSubscriptionParams, fetchFinalStretchTokens, fetchMigratedTokens, fetchNewTokens, fetchPresignedUploadUrl, fetchSearchTokens, fetchStockTokens, fetchSwapRoute, fetchToken, fetchTokenActivities, fetchTokenCandles, fetchTokenHolders, fetchTokenMarketData, fetchTokenSecurity, fetchTokenStats, fetchTokenTrades, fetchTokens, fetchTrendingTokens, fetchTxSuccess, fetchWalletActivities, fetchWalletPnl, fetchWalletPortfolioPnls, fetchWalletPortfolioPnlsByTokens, fetchWalletPortfolios, fetchWalletPortfoliosByTokens, fetchWalletTrades, finalStretchTokensQueryKey, migratedTokensQueryKey, newTokensQueryKey, presignedUploadUrlQueryKey, searchTokensQueryKey, sendTx, stockTokensQueryKey, swapRouteQueryKey, toKeySegment, toSortedKeySegment, tokenActivitiesQueryKey, tokenCandlesQueryKey, tokenHoldersQueryKey, tokenMarketDataQueryKey, tokenQueryKey, tokenSecurityQueryKey, tokenStatsQueryKey, tokenTradesQueryKey, tokensQueryKey, trendingTokensQueryKey, txSuccessQueryKey, useDexClient, useFinalStretchTokensQuery, useFinalStretchTokensSubscription, useMigratedTokensQuery, useMigratedTokensSubscription, useNewTokensQuery, useNewTokensSubscription, usePresignedUploadUrlQuery, useSearchTokensQuery, useSendTxMutation, useStockTokensQuery, useStockTokensSubscription, useSwapRouteQuery, useTokenActivitiesQuery, useTokenActivitiesSubscription, useTokenCandlesQuery, useTokenCandlesSubscription, useTokenHoldersQuery, useTokenMarketDataQuery, useTokenQuery, useTokenSecurityQuery, useTokenStatsQuery, useTokenSubscription, useTokenTradesQuery, useTokenTradesSubscription, useTokensQuery, useTrendingTokensQuery, useTrendingTokensSubscription, useTxSuccessQuery, useWalletActivitiesQuery, useWalletActivitiesSubscription, useWalletPnlQuery, useWalletPnlSubscription, useWalletPortfolioPnlsByTokensQuery, useWalletPortfolioPnlsInfiniteQuery, useWalletPortfolioPnlsQuery, useWalletPortfolioPnlsSubscription, useWalletPortfoliosByTokensQuery, useWalletPortfoliosInfiniteQuery, useWalletPortfoliosQuery, useWalletPortfoliosSubscription, useWalletTradesQuery, useWalletTradesSubscription, walletActivitiesQueryKey, walletPnlQueryKey, walletPortfolioPnlsByTokensQueryKey, walletPortfolioPnlsInfiniteQueryKey, walletPortfolioPnlsQueryKey, walletPortfoliosByTokensQueryKey, walletPortfoliosInfiniteQueryKey, walletPortfoliosQueryKey, walletTradesQueryKey };