@aave/react 0.7.0 → 4.0.0-next.0

package/dist/index.d.ts

@@ -1,52 +1,14 @@
-import { AaveClient, UnexpectedError } from '@aave/client';
+import { AaveClient, CurrencyQueryOptions, UnexpectedError, TimeWindowQueryOptions, ValidationError, ActivitiesRequest, PaginatedActivitiesResult } from '@aave/client';
 export * from '@aave/client';
 import React, { ReactNode } from 'react';
-import { SavingsGhoBalanceRequest, TokenAmount, SavingsGhoWithdrawRequest, ExecutionPlan, SavingsGhoDepositRequest, UserMeritRewardsRequest, UserMeritRewards, Market, ChainsFilter, Chain, UsdExchangeRatesRequest, UsdExchangeRate, HealthFactorPreviewRequest, HealthFactorPreviewResponse, ReserveRequest, Reserve, BorrowAPYHistoryRequest, APYSample, SupplyAPYHistoryRequest, CreditDelegateeAmountRequest, SupplyRequest, BorrowRequest, RepayRequest, WithdrawRequest, UserSetEmodeRequest, TransactionRequest, CollateralToggleRequest, LiquidateRequest, VaultDepositRequest, VaultMintSharesRequest, VaultRedeemSharesRequest, VaultWithdrawRequest, VaultDeployRequest, VaultSetFeeRequest, VaultWithdrawFeesRequest, VaultTransferOwnershipRequest, ApproveBorrowCreditDelegatorRequest, UserSuppliesRequest, MarketUserReserveSupplyPosition, UserBorrowsRequest, MarketUserReserveBorrowPosition, UserMarketStateRequest, MarketUserState, UserTransactionHistoryRequest, PaginatedUserTransactionHistoryResult, VaultRequest, Vault, VaultsRequest, PaginatedVaultsResult, UserVaultsRequest, VaultPreviewDepositRequest, VaultPreviewMintRequest, VaultPreviewWithdrawRequest, VaultPreviewRedeemRequest, VaultUserTransactionHistoryRequest, PaginatedVaultUserTransactionHistoryResult, VaultUserActivityRequest, VaultUserActivityResult } from '@aave/graphql';
-import { U as UseAsyncTask } from './tasks-DUn7x8pK.js';
-import { MarketRequest, MarketsRequest } from '@aave/client/actions';
-import '@aave/types';
-
-/**
- * A read hook result.
- *
- * It's a discriminated union of the possible results of a read operation:
- * - Rely on the `loading` value to determine if the `data` or `error` can be evaluated.
- * - If `error` is `undefined`, then `data` value will be available.
- */
-type ReadResult<T, E = never> = {
-    data: undefined;
-    error: undefined;
-    loading: true;
-} | {
-    data: T;
-    error: undefined;
-    loading: false;
-} | {
-    data: undefined;
-    error: E;
-    loading: false;
-};
-/**
- * @internal
- */
-declare const ReadResult: {
-    Initial: <T, E = never>() => ReadResult<T, E>;
-    Success: <T, E = never>(data: T) => ReadResult<T, E>;
-    Failure: <T, E = never>(error: E) => ReadResult<T, E>;
-};
-/**
- * A read hook result that supports React Suspense
- */
-type SuspenseResult<T> = {
-    data: T;
-};
-
-/**
- * @internal
- */
-type Suspendable = {
-    suspense: true;
-};
+import { a as UseAsyncTask, C as CancelOperation, S as SendTransactionError, P as PendingTransactionError, b as PendingTransaction, T as TransactionHandler } from './writes-BXnwYgAQ.js';
+export { A as AsyncTaskError, c as AsyncTaskIdle, d as AsyncTaskLoading, e as AsyncTaskState, f as AsyncTaskSuccess, g as TransactionHandlerOptions, U as UseSendTransactionResult } from './writes-BXnwYgAQ.js';
+import { HubRequest, Hub, HubsRequest, HubAssetsRequest, HubAsset, PermitRequest, PermitTypedDataResponse, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, ReserveRequest, Reserve, ReservesRequest, BorrowAPYHistoryRequest, APYSample, SupplyAPYHistoryRequest, SpokeRequest, Spoke, SpokesRequest, SpokePositionManagersRequest, PaginatedSpokePositionManagerResult, SpokeUserPositionManagersRequest, PaginatedSpokeUserPositionManagerResult, SwapQuoteRequest, SwapQuote, SwappableTokensRequest, Token, UserSwapsRequest, PaginatedUserSwapsResult, PrepareSwapRequest, SwapByIntentTypedData, SwapByIntentWithApprovalRequired, SwapTransactionRequest, SwapApprovalRequired, ERC20PermitSignature, SwapReceipt, InsufficientBalanceError, CancelSwapTypedData, TransactionRequest, PrepareSwapCancelRequest, SwapCancelled, SupplyRequest, BorrowRequest, RepayRequest, WithdrawRequest, RenounceSpokeUserPositionManagerRequest, UpdateUserRiskPremiumRequest, UpdateUserDynamicConfigRequest, SetUserSupplyAsCollateralRequest, LiquidatePositionRequest, SetSpokeUserPositionManagerRequest, PreviewRequest, PreviewUserPosition, UserSuppliesRequest, UserSupplyItem, UserBorrowsRequest, UserBorrowItem, UserSummaryRequest, UserSummary, UserPositionsRequest, UserPosition, UserPositionRequest, UserBalancesRequest, UserBalance, UserSummaryHistoryRequest, UserSummaryHistoryItem } from '@aave/graphql';
+import { Prettify, ResultAsync, ResultAwareError, TxHash } from '@aave/types';
+import { S as Suspendable, a as SuspenseResult, P as Pausable, b as PausableSuspenseResult, R as ReadResult, c as PausableReadResult, d as Selector } from './misc-gmAnSdm5.js';
+export { e as UseChainArgs, f as UseChainsArgs, i as UseExchangeRateArgs, U as UseNetworkFee, l as UseNetworkFeeArgs, k as UseNetworkFeeRequestQuery, u as useChain, g as useChains, j as useExchangeRate, h as useExchangeRateAction } from './misc-gmAnSdm5.js';
+import { UnexpectedError as UnexpectedError$1, SigningError, CancelError, TimeoutError, TransactionError, ValidationError as ValidationError$1 } from '@aave/core';
+import { UserPositionQueryOptions } from '@aave/client/actions';
 
 /**
  * <AaveProvider> props
@@ -83,1267 +45,2626 @@ type AaveProviderProps = {
 declare function AaveProvider({ children, client }: AaveProviderProps): React.JSX.Element;
 
 /**
- * Retrieve the injected {@link AaveClient} from the context.
+ * @internal
  */
 declare function useAaveClient(): AaveClient;
 
-type SavingsGhoBalanceArgs = SavingsGhoBalanceRequest;
+type UseHubArgs = Prettify<HubRequest & CurrencyQueryOptions>;
 /**
- * Fetches the current sGHO balance for a user.
+ * Fetch a specific hub by ID or by address and chain ID.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useSavingsGhoBalance({
- *   user: evmAddress('0x742d35cc…'),
+ * const { data } = useHub({
+ *   query: { hubId: hubId('SGVsbG8h') },
  *   suspense: true,
  * });
+ * // data will be Hub | null
  * ```
  */
-declare function useSavingsGhoBalance(args: SavingsGhoBalanceArgs & Suspendable): SuspenseResult<TokenAmount>;
+declare function useHub(args: UseHubArgs & Suspendable): SuspenseResult<Hub | null>;
 /**
- * Fetches the current sGHO balance for a user.
+ * Fetch a specific hub by ID or by address and chain ID.
+ *
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data, error, loading } = useSavingsGhoBalance({
- *   user: evmAddress('0x742d35cc…'),
+ * const { data } = useHub({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useSavingsGhoBalance(args: SavingsGhoBalanceArgs): ReadResult<TokenAmount>;
+declare function useHub(args: Pausable<UseHubArgs> & Suspendable): PausableSuspenseResult<Hub | null>;
 /**
- * A hook that provides a way to withdraw sGHO.
- *
- * ```ts
- * const [withdraw, withdrawing] = useSavingsGhoWithdraw();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- *
- * const loading = withdrawing.loading && sending.loading;
- * const error = withdrawing.error || sending.error;
- *
- * // …
- *
- * const result = await withdraw({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
- *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
- *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance to withdraw: ${plan.required.value} is the maximum withdrawal allowed.`)
- *         );
- *     }
- *   });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
+ * Fetch a specific hub by ID or by address and chain ID.
  *
- * console.log('Transaction sent with hash:', result.value);
+ * ```tsx
+ * const { data, error, loading } = useHub({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ * });
+ * // data will be Hub | null
  * ```
  */
-declare function useSavingsGhoWithdraw(): UseAsyncTask<SavingsGhoWithdrawRequest, ExecutionPlan, UnexpectedError>;
+declare function useHub(args: UseHubArgs): ReadResult<Hub | null>;
 /**
- * A hook that provides a way to deposit GHO into sGHO.
- *
- * ```ts
- * const [deposit, depositing] = useSavingsGhoDeposit();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * Fetch a specific hub by ID or by address and chain ID.
  *
- * const loading = depositing.loading && sending.loading;
- * const error = depositing.error || sending.error;
+ * Pausable loading state mode.
  *
- * // …
+ * ```tsx
+ * const { data, error, loading, paused } = useHub({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHub(args: Pausable<UseHubArgs>): PausableReadResult<Hub | null>;
+type UseHubsArgs = Prettify<HubsRequest & CurrencyQueryOptions>;
+/**
+ * Fetch multiple hubs based on specified criteria.
  *
- * const result = await deposit({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
+ * This signature supports React Suspense:
  *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
+ * ```tsx
+ * const { data } = useHubs({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useHubs(args: UseHubsArgs & Suspendable): SuspenseResult<Hub[]>;
+/**
+ * Fetch multiple hubs based on specified criteria.
  *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance: ${plan.required.value} required.`)
- *         );
- *     }
- *   });
+ * Pausable suspense mode.
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
+ * ```tsx
+ * const { data } = useHubs({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubs(args: Pausable<UseHubsArgs> & Suspendable): PausableSuspenseResult<Hub[]>;
+/**
+ * Fetch multiple hubs based on specified criteria.
  *
- * console.log('Transaction sent with hash:', result.value);
+ * ```tsx
+ * const { data, error, loading } = useHubs({
+ *   query: { chainIds: [chainId(1)] },
+ * });
  * ```
  */
-declare function useSavingsGhoDeposit(): UseAsyncTask<SavingsGhoDepositRequest, ExecutionPlan, UnexpectedError>;
-
-type UserMeritRewardsArgs = UserMeritRewardsRequest;
+declare function useHubs(args: UseHubsArgs): ReadResult<Hub[]>;
 /**
- * Fetches Merit claim rewards for a user with the transaction request to claim them.
+ * Fetch multiple hubs based on specified criteria.
  *
- * This signature supports React Suspense:
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data } = useUserMeritRewards({
- *   user: evmAddress('0x742d35cc…'),
- *   chainId: chainId(1),
- *   suspense: true,
+ * const { data, error, loading, paused } = useHubs({
+ *   query: { chainIds: [chainId(1)] },
+ *   pause: true,
  * });
  * ```
  */
-declare function useUserMeritRewards(args: UserMeritRewardsArgs & Suspendable): SuspenseResult<UserMeritRewards | null>;
+declare function useHubs(args: Pausable<UseHubsArgs>): PausableReadResult<Hub[]>;
+type UseHubAssetsArgs = Prettify<HubAssetsRequest & CurrencyQueryOptions>;
 /**
- * Fetches Merit claim rewards for a user with the transaction request to claim them.
+ * Fetch hub assets for a specific hub by ID or by address and chain ID.
+ *
+ * This signature supports React Suspense:
  *
  * ```tsx
- * const { data, loading } = useUserMeritRewards({
- *   user: evmAddress('0x742d35cc…'),
- *   chainId: chainId(1),
+ * const { data } = useHubAssets({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   user: evmAddress('0x456...'), // optional
+ *   suspense: true,
  * });
  * ```
  */
-declare function useUserMeritRewards(args: UserMeritRewardsArgs): ReadResult<UserMeritRewards | null>;
-
-type UseAaveMarketArgs = MarketRequest;
+declare function useHubAssets(args: UseHubAssetsArgs & Suspendable): SuspenseResult<HubAsset[]>;
 /**
- * Fetch a single Aave Market.
+ * Fetch hub assets for a specific hub by ID or by address and chain ID.
  *
- * This signature supports React Suspense:
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useAaveMarket({
- *   address: evmAddress('0x8787…'),
- *   chainId: chainId(1),
+ * const { data } = useHubAssets({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   user: evmAddress('0x456...'), // optional
  *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useAaveMarket(args: UseAaveMarketArgs & Suspendable): SuspenseResult<Market | null>;
+declare function useHubAssets(args: Pausable<UseHubAssetsArgs> & Suspendable): PausableSuspenseResult<HubAsset[]>;
 /**
- * Fetch a single Aave Market.
+ * Fetch hub assets for a specific hub by ID or by address and chain ID.
  *
  * ```tsx
- * const { data, error, loading } = useAaveMarket({
- *   address: evmAddress('0x8787…'),
- *   chainId: chainId(1),
+ * const { data, error, loading } = useHubAssets({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   user: evmAddress('0x456...'), // optional
  * });
  * ```
  */
-declare function useAaveMarket(args: UseAaveMarketArgs): ReadResult<Market | null>;
-type UseAaveMarketsArgs = MarketsRequest;
+declare function useHubAssets(args: UseHubAssetsArgs): ReadResult<HubAsset[]>;
 /**
- * Fetch all Aave Markets for the specified chains.
+ * Fetch hub assets for a specific hub by ID or by address and chain ID.
  *
- * This signature supports React Suspense:
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data } = useAaveMarkets({
- *   chainIds: [chainId(1), chainId(8453)],
- *   user: evmAddress('0x742d35cc...'),
- *   suspense: true
+ * const { data, error, loading, paused } = useHubAssets({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   user: evmAddress('0x456...'), // optional
+ *   pause: true,
  * });
  * ```
  */
-declare function useAaveMarkets(args: UseAaveMarketsArgs & Suspendable): SuspenseResult<Market[]>;
+declare function useHubAssets(args: Pausable<UseHubAssetsArgs>): PausableReadResult<HubAsset[]>;
 /**
- * Fetch all Aave Markets for the specified chains.
+ * Low-level hook to execute a {@link hubs} action directly.
  *
- * ```tsx
- * const { data, error, loading } = useAaveMarkets({
- *   chainIds: [chainId(1), chainId(8453)],
- *   user: evmAddress('0x742d35cc...'),
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on the hubs.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useHubsAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   query: {
+ *     chainIds: [chainId(1)]
+ *   }
  * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Hub[]
+ * } else {
+ *   console.error(result.error);
+ * }
  * ```
  */
-declare function useAaveMarkets(args: UseAaveMarketsArgs): ReadResult<Market[]>;
+declare function useHubsAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<HubsRequest, Hub[], UnexpectedError>;
 
-type UseAaveChainsArgs = {
-    filter?: ChainsFilter;
-};
 /**
- * Fetch all supported Aave chains.
+ * @internal
+ */
+declare function usePermitTypedDataAction(): UseAsyncTask<PermitRequest, PermitTypedDataResponse, UnexpectedError>;
+
+type UseAssetArgs = Prettify<AssetRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
+/**
+ * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useAaveChains({
- *   filter: ChainsFilter.MAINNET_ONLY,
+ * const { data } = useAsset({
+ *   query: { assetId: assetId('SGVsbG8h') },
  *   suspense: true,
  * });
+ * // data will be Asset | null
  * ```
  */
-declare function useAaveChains(args: UseAaveChainsArgs & Suspendable): SuspenseResult<Chain[]>;
+declare function useAsset(args: UseAssetArgs & Suspendable): SuspenseResult<Asset | null>;
 /**
- * Fetch all supported Aave chains.
+ * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
+ *
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data, error, loading } = useAaveChains({
- *   filter: ChainsFilter.MAINNET_ONLY,
+ * const { data } = useAsset({
+ *   query: { assetId: assetId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useAaveChains(args: UseAaveChainsArgs): ReadResult<Chain[]>;
+declare function useAsset(args: Pausable<UseAssetArgs> & Suspendable): PausableSuspenseResult<Asset | null>;
 /**
- * Health check query.
- *
- * This signature supports React Suspense:
+ * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
  *
  * ```tsx
- * const { data } = useAaveHealth({
- *   suspense: true,
+ * const { data, error, loading } = useAsset({
+ *   query: { assetId: assetId('SGVsbG8h') },
  * });
+ * // data will be Asset | null
  * ```
  */
-declare function useAaveHealth(args: Suspendable): SuspenseResult<boolean>;
+declare function useAsset(args: UseAssetArgs): ReadResult<Asset | null>;
 /**
- * Health check query.
+ * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
+ *
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading } = useAaveHealth();
+ * const { data, error, loading, paused } = useAsset({
+ *   query: { assetId: assetId('SGVsbG8h') },
+ *   pause: true,
+ * });
  * ```
  */
-declare function useAaveHealth(): ReadResult<boolean>;
-type UseUsdExchangeRatesArgs = UsdExchangeRatesRequest;
+declare function useAsset(args: Pausable<UseAssetArgs>): PausableReadResult<Asset | null>;
+type UseAssetPriceHistoryArgs = AssetPriceHistoryRequest;
 /**
- * Fetch USD exchange rates for different tokens on a given market.
+ * Fetch historical price data for a specific asset.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useUsdExchangeRates({
- *   market: evmAddress('0x1234…'),
- *   underlyingTokens: [evmAddress('0x5678…'), evmAddress('0x90ab…')],
- *   chainId: chainId(1),
+ * const { data } = useAssetPriceHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
  *   suspense: true,
  * });
  * ```
  */
-declare function useUsdExchangeRates(args: UseUsdExchangeRatesArgs & Suspendable): SuspenseResult<UsdExchangeRate[]>;
+declare function useAssetPriceHistory(args: UseAssetPriceHistoryArgs & Suspendable): SuspenseResult<AssetPriceSample[]>;
 /**
- * Fetch USD exchange rates for different tokens on a given market.
+ * Fetch historical price data for a specific asset.
+ *
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data, error, loading } = useUsdExchangeRates({
- *   market: evmAddress('0x1234…'),
- *   underlyingTokens: [evmAddress('0x5678…'), evmAddress('0x90ab…')],
- *   chainId: chainId(1),
+ * const { data } = useAssetPriceHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useUsdExchangeRates(args: UseUsdExchangeRatesArgs): ReadResult<UsdExchangeRate[]>;
+declare function useAssetPriceHistory(args: Pausable<UseAssetPriceHistoryArgs> & Suspendable): PausableSuspenseResult<AssetPriceSample[]>;
 /**
- * Determines the health factor after a given action.
+ * Fetch historical price data for a specific asset.
  *
- * ```ts
- * const [preview, { loading, error }] = useAaveHealthFactorPreview();
+ * ```tsx
+ * const { data, error, loading } = useAssetPriceHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useAssetPriceHistory(args: UseAssetPriceHistoryArgs): ReadResult<AssetPriceSample[]>;
+/**
+ * Fetch historical price data for a specific asset.
  *
- * // …
+ * Pausable loading state mode.
  *
- * const result = await preview({
- *   action: {
- *     borrow: {
- *       market: market.address,
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       borrower: evmAddress('0x9abc…'),
- *       chainId: market.chain.chainId,
- *     },
- *   },
+ * ```tsx
+ * const { data, error, loading, paused } = useAssetPriceHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   pause: true,
  * });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- * } else {
- *   console.log(result.value);
- * }
  * ```
  */
-declare function useAaveHealthFactorPreview(): UseAsyncTask<HealthFactorPreviewRequest, HealthFactorPreviewResponse, UnexpectedError>;
-
-type UseAaveReserveArgs = ReserveRequest;
+declare function useAssetPriceHistory(args: Pausable<UseAssetPriceHistoryArgs>): PausableReadResult<AssetPriceSample[]>;
+type UseAssetSupplyHistoryArgs = AssetSupplyHistoryRequest;
 /**
- * Fetch a single Aave Reserve.
+ * Fetch historical supply data for a specific asset.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useAaveReserve({
- *   market: evmAddress('0x87870bca...'),
- *   underlyingToken: evmAddress('0xa0b86a33...'),
- *   chainId: chainId(1),
+ * const { data } = useAssetSupplyHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   window: TimeWindow.LastWeek,
  *   suspense: true,
  * });
  * ```
  */
-declare function useAaveReserve(args: UseAaveReserveArgs & Suspendable): SuspenseResult<Reserve | null>;
+declare function useAssetSupplyHistory(args: UseAssetSupplyHistoryArgs & Suspendable): SuspenseResult<AssetSupplySample[]>;
 /**
- * Fetch a single Aave Reserve.
+ * Fetch historical supply data for a specific asset.
+ *
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data, error, loading } = useAaveReserve({
- *   market: evmAddress('0x87870bca...'),
- *   underlyingToken: evmAddress('0xa0b86a33...'),
- *   chainId: chainId(1),
+ * const { data } = useAssetSupplyHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useAaveReserve(args: UseAaveReserveArgs): ReadResult<Reserve | null>;
-type UseBorrowAPYHistoryArgs = BorrowAPYHistoryRequest;
+declare function useAssetSupplyHistory(args: Pausable<UseAssetSupplyHistoryArgs> & Suspendable): PausableSuspenseResult<AssetSupplySample[]>;
 /**
- * Fetches historical borrow APY data for a given underlying asset on a specific market
- * within a defined time window.
- *
- * This signature supports React Suspense:
+ * Fetch historical supply data for a specific asset.
  *
  * ```tsx
- * const { data } = useBorrowAPYHistory({
- *   chainId: chainId(1),
- *   underlyingToken: evmAddress('0x742d35cc…'),
- *   market: evmAddress('0x24dc35d3c…'),
- *   window: TimeWindow.LastWeek
- *   suspense: true
+ * const { data, error, loading } = useAssetSupplyHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   window: TimeWindow.LastWeek,
  * });
  * ```
  */
-declare function useBorrowAPYHistory(args: UseBorrowAPYHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+declare function useAssetSupplyHistory(args: UseAssetSupplyHistoryArgs): ReadResult<AssetSupplySample[]>;
 /**
- * Fetches historical borrow APY data for a given underlying asset on a specific market
- * within a defined time window.
+ * Fetch historical supply data for a specific asset.
+ *
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data } = useBorrowAPYHistory({
- *   chainId: chainId(1),
- *   underlyingToken: evmAddress('0x742d35cc…'),
- *   market: evmAddress('0x24dc35d3c…'),
- *   window: TimeWindow.LastWeek
+ * const { data, error, loading, paused } = useAssetSupplyHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   pause: true,
  * });
  * ```
  */
-declare function useBorrowAPYHistory(args: UseBorrowAPYHistoryArgs): ReadResult<APYSample[]>;
-type UseSupplyAPYHistoryArgs = SupplyAPYHistoryRequest;
+declare function useAssetSupplyHistory(args: Pausable<UseAssetSupplyHistoryArgs>): PausableReadResult<AssetSupplySample[]>;
+type UseAssetBorrowHistoryArgs = AssetBorrowHistoryRequest;
 /**
- * Fetches historical supply APY data for a given underlying asset on a specific market
- * within a defined time window.
+ * Fetch historical borrow data for a specific asset.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useSupplyAPYHistory({
- *   chainId: chainId(1),
- *   underlyingToken: evmAddress('0x742d35cc…'),
- *   market: evmAddress('0x24dc35d3c…'),
+ * const { data } = useAssetBorrowHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
  *   window: TimeWindow.LastWeek,
- *   suspense: true
+ *   suspense: true,
  * });
  * ```
  */
-declare function useSupplyAPYHistory(args: UseSupplyAPYHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+declare function useAssetBorrowHistory(args: UseAssetBorrowHistoryArgs & Suspendable): SuspenseResult<AssetBorrowSample[]>;
 /**
- * Fetches historical supply APY data for a given underlying asset on a specific market
- * within a defined time window.
+ * Fetch historical borrow data for a specific asset.
+ *
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useSupplyAPYHistory({
- *   chainId: chainId(1),
- *   underlyingToken: evmAddress('0x742d35cc…'),
- *   market: evmAddress('0x24dc35d3c…'),
- *   window: TimeWindow.LastWeek
+ * const { data } = useAssetBorrowHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useSupplyAPYHistory(args: UseSupplyAPYHistoryArgs): ReadResult<APYSample[]>;
-type UseCreditDelegateeAllowanceArgs = CreditDelegateeAmountRequest;
+declare function useAssetBorrowHistory(args: Pausable<UseAssetBorrowHistoryArgs> & Suspendable): PausableSuspenseResult<AssetBorrowSample[]>;
 /**
- * Get the amount delegated to the credit delegatee that can borrow on your behalf.
- *
- * This signature supports React Suspense:
+ * Fetch historical borrow data for a specific asset.
  *
  * ```tsx
- * const { data } = useCreditDelegateeAllowance({
- *   market: evmAddress('0x87870bca...'),
- *   underlyingToken: evmAddress('0xa0b86a33...'),
- *   user: evmAddress('0x742d35cc...'),
- *   delegatee: evmAddress('0x5678...'),
- *   chainId: chainId(1),
- *   suspense: true,
+ * const { data, error, loading } = useAssetBorrowHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   window: TimeWindow.LastWeek,
  * });
  * ```
  */
-declare function useCreditDelegateeAllowance(args: UseCreditDelegateeAllowanceArgs & Suspendable): SuspenseResult<TokenAmount>;
+declare function useAssetBorrowHistory(args: UseAssetBorrowHistoryArgs): ReadResult<AssetBorrowSample[]>;
 /**
- * Get the amount delegated to the credit delegatee that can borrow on your behalf.
+ * Fetch historical borrow data for a specific asset.
+ *
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading } = useCreditDelegateeAllowance({
- *   market: evmAddress('0x87870bca...'),
- *   underlyingToken: evmAddress('0xa0b86a33...'),
- *   user: evmAddress('0x742d35cc...'),
- *   delegatee: evmAddress('0x5678...'),
- *   chainId: chainId(1),
+ * const { data, error, loading, paused } = useAssetBorrowHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   pause: true,
  * });
  * ```
  */
-declare function useCreditDelegateeAllowance(args: UseCreditDelegateeAllowanceArgs): ReadResult<TokenAmount>;
+declare function useAssetBorrowHistory(args: Pausable<UseAssetBorrowHistoryArgs>): PausableReadResult<AssetBorrowSample[]>;
 
+type UseReserveArgs = Prettify<ReserveRequest & CurrencyQueryOptions>;
 /**
- * A hook that provides a way to supply assets to an Aave market.
- *
- * ```ts
- * const [supply, supplying] = useSupply();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * Fetch a specific reserve by reserve ID, spoke, and chain.
  *
- * const loading = supplying.loading && sending.loading;
- * const error = supplying.error || sending.error;
+ * This signature supports React Suspense:
  *
- * // …
+ * ```tsx
+ * const { data } = useReserve({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   user: evmAddress('0xabc...'),
+ *   suspense: true,
+ * });
+ * // data will be Reserve | null
+ * ```
+ */
+declare function useReserve(args: UseReserveArgs & Suspendable): SuspenseResult<Reserve | null>;
+/**
+ * Fetch a specific reserve by reserve ID, spoke, and chain.
  *
- * const result = await supply({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
+ * Pausable suspense mode.
  *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
+ * ```tsx
+ * const { data } = useReserve({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useReserve(args: Pausable<UseReserveArgs> & Suspendable): PausableSuspenseResult<Reserve | null>;
+/**
+ * Fetch a specific reserve by reserve ID, spoke, and chain.
  *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance: ${plan.required.value} required.`)
- *         );
- *     }
- *   });
+ * ```tsx
+ * const { data, error, loading } = useReserve({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   user: evmAddress('0xabc...'),
+ * });
+ * // data will be Reserve | null
+ * ```
+ */
+declare function useReserve(args: UseReserveArgs): ReadResult<Reserve | null>;
+/**
+ * Fetch a specific reserve by reserve ID, spoke, and chain.
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
+ * Pausable loading state mode.
  *
- * console.log('Transaction sent with hash:', result.value);
+ * ```tsx
+ * const { data, error, loading, paused } = useReserve({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   pause: true,
+ * });
  * ```
  */
-declare function useSupply(): UseAsyncTask<SupplyRequest, ExecutionPlan, UnexpectedError>;
+declare function useReserve(args: Pausable<UseReserveArgs>): PausableReadResult<Reserve | null>;
 /**
- * A hook that provides a way to borrow assets from an Aave market.
+ * Low-level hook to execute a {@link reserve} action directly.
  *
- * ```ts
- * const [borrow, borrowing] = useBorrow();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on the reserve.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
  *
- * const loading = borrowing.loading && sending.loading;
- * const error = borrowing.error || sending.error;
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useReserveAction();
  *
  * // …
  *
- * const result = await borrow({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
- *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
- *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance: ${plan.required.value} required.`)
- *         );
- *     }
- *   });
+ * const result = await execute({
+ *   reserve: reserveId('SGVsbG8h'),
+ * });
  *
- * if (result.isErr()) {
+ * if (result.isOk()) {
+ *   console.log(result.value); // Reserve | null
+ * } else {
  *   console.error(result.error);
- *   return;
  * }
- *
- * console.log('Transaction sent with hash:', result.value);
  * ```
  */
-declare function useBorrow(): UseAsyncTask<BorrowRequest, ExecutionPlan, UnexpectedError>;
+declare function useReserveAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ReserveRequest, Reserve | null, UnexpectedError>;
+type UseReservesArgs<T = Reserve[]> = Prettify<ReservesRequest & CurrencyQueryOptions & {
+    /**
+     * A function that maps the full list of reserves
+     * into a derived or narrowed value.
+     *
+     * Example: pick a single reserve based on a criteria.
+     *
+     * @experimental This is experimental and may be subject to breaking changes.
+     */
+    selector?: Selector<Reserve[], T>;
+}>;
 /**
- * A hook that provides a way to repay borrowed assets to an Aave market.
- *
- * ```ts
- * const [repay, repaying] = useRepay();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * Fetch reserves based on specified criteria.
  *
- * const loading = repaying.loading && sending.loading;
- * const error = repaying.error || sending.error;
- *
- * // …
- *
- * const result = await repay({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
- *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
+ * This signature supports React Suspense:
  *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance: ${plan.required.value} required.`)
- *         );
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
  *     }
- *   });
+ *   },
+ *   filter: ReservesRequestFilter.All,
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ * });
+ * ```
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
+ * **Reserves with Highest Supply APY**
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   suspense: true,
+ *   selector: pickHighestSupplyApyReserve,
+ * });
+ * ```
  *
- * console.log('Transaction sent with hash:', result.value);
+ * **Reserves with Lowest Borrow APY**
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   suspense: true,
+ *   selector: pickLowestBorrowApyReserve,
+ * });
  * ```
  */
-declare function useRepay(): UseAsyncTask<RepayRequest, ExecutionPlan, UnexpectedError>;
+declare function useReserves<T = Reserve[]>(args: UseReservesArgs<T> & Suspendable): SuspenseResult<T>;
 /**
- * A hook that provides a way to withdraw supplied assets from an Aave market.
- *
- * ```ts
- * const [withdraw, withdrawing] = useWithdraw();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- *
- * const loading = withdrawing.loading && sending.loading;
- * const error = withdrawing.error || sending.error;
- *
- * // …
+ * Fetch reserves based on specified criteria.
  *
- * const result = await withdraw({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
+ * Pausable suspense mode.
  *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
- *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance: ${plan.required.value} required.`)
- *         );
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
  *     }
- *   });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
- *
- * console.log('Transaction sent with hash:', result.value);
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
  * ```
  */
-declare function useWithdraw(): UseAsyncTask<WithdrawRequest, ExecutionPlan, UnexpectedError>;
+declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>> & Suspendable): PausableSuspenseResult<T>;
 /**
- * A hook that provides a way to set eMode for a user.
- *
- * ```ts
- * const [setUserEMode, setting] = useUserEMode();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- *
- * const loading = setting.loading && sending.loading;
- * const error = setting.error || sending.error;
+ * Fetch reserves based on specified criteria.
+ *
+ * ```tsx
+ * const { data, error, loading } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   filter: ReservesRequestFilter.All,
+ *   orderBy: { name: 'ASC' },
+ * });
+ * ```
+ *
+ * **Reserves with Highest Supply APY**
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   selector: pickHighestSupplyApyReserve,
+ * });
+ * ```
+ *
+ * **Reserves with Lowest Borrow APY**
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   selector: pickLowestBorrowApyReserve,
+ * });
+ * ```
+ */
+declare function useReserves<T = Reserve[]>(args: UseReservesArgs<T>): ReadResult<T>;
+/**
+ * Fetch reserves based on specified criteria.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>>): PausableReadResult<T>;
+/**
+ * Low-level hook to execute a {@link reserves} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on the reserves.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useReservesAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x1234…'),
+ *       chainId: chainId(1)
+ *     }
+ *   }
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Reserve[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * **Reserves with Highest Supply APY**
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useReservesAction();
+ *
+ * // …
+ *
+ * const result = await execute(…).map(pickHighestSupplyApyReserve);
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Reserve | null
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * **Reserves with Lowest Borrow APY**
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useReservesAction();
+ *
+ * // …
+ *
+ * const result = await execute(…).map(pickLowestBorrowApyReserve);
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Reserve | null
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useReservesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ReservesRequest, Reserve[], UnexpectedError>;
+type UseBorrowApyHistoryArgs = BorrowAPYHistoryRequest;
+/**
+ * Fetch borrow APY history for a specific reserve over time.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useBorrowApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+/**
+ * Fetch borrow APY history for a specific reserve over time.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useBorrowApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs> & Suspendable): PausableSuspenseResult<APYSample[]>;
+/**
+ * Fetch borrow APY history for a specific reserve over time.
+ *
+ * ```tsx
+ * const { data, error, loading } = useBorrowApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs): ReadResult<APYSample[]>;
+/**
+ * Fetch borrow APY history for a specific reserve over time.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useBorrowApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs>): PausableReadResult<APYSample[]>;
+type UseSupplyApyHistoryArgs = SupplyAPYHistoryRequest;
+/**
+ * Fetch supply APY history for a specific reserve over time.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSupplyApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+/**
+ * Fetch supply APY history for a specific reserve over time.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSupplyApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs> & Suspendable): PausableSuspenseResult<APYSample[]>;
+/**
+ * Fetch supply APY history for a specific reserve over time.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSupplyApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs): ReadResult<APYSample[]>;
+/**
+ * Fetch supply APY history for a specific reserve over time.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSupplyApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs>): PausableReadResult<APYSample[]>;
+
+type UseSpokeArgs = SpokeRequest;
+/**
+ * Fetch a specific spoke.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   suspense: true,
+ * });
+ * // data will be Spoke | null
+ * ```
+ */
+declare function useSpoke(args: UseSpokeArgs & Suspendable): SuspenseResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpoke(args: Pausable<UseSpokeArgs> & Suspendable): PausableSuspenseResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ * });
+ * // data will be Spoke | null
+ * ```
+ */
+declare function useSpoke(args: UseSpokeArgs): ReadResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpoke(args: Pausable<UseSpokeArgs>): PausableReadResult<Spoke | null>;
+type UseSpokesArgs = SpokesRequest;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSpokes(args: UseSpokesArgs & Suspendable): SuspenseResult<Spoke[]>;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokes(args: Pausable<UseSpokesArgs> & Suspendable): PausableSuspenseResult<Spoke[]>;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ * });
+ * ```
+ */
+declare function useSpokes(args: UseSpokesArgs): ReadResult<Spoke[]>;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokes(args: Pausable<UseSpokesArgs>): PausableReadResult<Spoke[]>;
+type UseSpokePositionManagersArgs = SpokePositionManagersRequest;
+/**
+ * Fetches all the positions manager for a specific spoke.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpokePositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSpokePositionManagers(args: UseSpokePositionManagersArgs & Suspendable): SuspenseResult<PaginatedSpokePositionManagerResult>;
+/**
+ * Fetches all the positions manager for a specific spoke.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpokePositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokePositionManagers(args: Pausable<UseSpokePositionManagersArgs> & Suspendable): PausableSuspenseResult<PaginatedSpokePositionManagerResult>;
+/**
+ * Fetches all the positions manager for a specific spoke.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpokePositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ * });
+ * ```
+ */
+declare function useSpokePositionManagers(args: UseSpokePositionManagersArgs): ReadResult<PaginatedSpokePositionManagerResult>;
+/**
+ * Fetches all the positions manager for a specific spoke.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpokePositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokePositionManagers(args: Pausable<UseSpokePositionManagersArgs>): PausableReadResult<PaginatedSpokePositionManagerResult>;
+type UseSpokeUserPositionManagersArgs = SpokeUserPositionManagersRequest;
+/**
+ * Fetches all the position managers of a user for a specific spoke
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpokeUserPositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSpokeUserPositionManagers(args: UseSpokeUserPositionManagersArgs & Suspendable): SuspenseResult<PaginatedSpokeUserPositionManagerResult>;
+/**
+ * Fetches all the position managers of a user for a specific spoke
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpokeUserPositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokeUserPositionManagers(args: Pausable<UseSpokeUserPositionManagersArgs> & Suspendable): PausableSuspenseResult<PaginatedSpokeUserPositionManagerResult>;
+/**
+ * Fetches all the position managers of a user for a specific spoke
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpokeUserPositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
+ * });
+ * ```
+ */
+declare function useSpokeUserPositionManagers(args: UseSpokeUserPositionManagersArgs): ReadResult<PaginatedSpokeUserPositionManagerResult>;
+/**
+ * Fetches all the position managers of a user for a specific spoke
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpokeUserPositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokeUserPositionManagers(args: Pausable<UseSpokeUserPositionManagersArgs>): PausableReadResult<PaginatedSpokeUserPositionManagerResult>;
+
+type UseSwapQuoteArgs = Prettify<SwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * @internal
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSwapQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSwapQuote(args: UseSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * @internal
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSwapQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ *   from: evmAddress('0x742d35cc...'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * @internal
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSwapQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ * });
+ * ```
+ */
+declare function useSwapQuote(args: UseSwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * @internal
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSwapQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ *   from: evmAddress('0x742d35cc...'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * @internal
+ * Low-level hook to execute a swap quote action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on the swap quote.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow
+ * (e.g., in an event handler to get a fresh quote before executing a swap).
+ *
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useSwapQuoteAction();
  *
  * // …
  *
- * const result = await setUserEMode({ ... })
- *   .andThen(sendTransaction);
+ * const result = await getQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<SwapQuoteRequest, SwapQuote, UnexpectedError$1>;
+type UseSwappableTokensArgs = SwappableTokensRequest;
+/**
+ * @internal
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: UseSwappableTokensArgs & Suspendable): SuspenseResult<Token[]>;
+/**
+ * @internal
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs> & Suspendable): PausableSuspenseResult<Token[]>;
+/**
+ * @internal
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: UseSwappableTokensArgs): ReadResult<Token[]>;
+/**
+ * @internal
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs>): PausableReadResult<Token[]>;
+type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions>;
+/**
+ * @internal
+ * Fetch the user's swap history for a specific chain.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: UseUserSwapsArgs & Suspendable): SuspenseResult<PaginatedUserSwapsResult>;
+/**
+ * @internal
+ * Fetch the user's swap history for a specific chain.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: Pausable<UseUserSwapsArgs> & Suspendable): PausableSuspenseResult<PaginatedUserSwapsResult>;
+/**
+ * @internal
+ * Fetch the user's swap history for a specific chain.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: UseUserSwapsArgs): ReadResult<PaginatedUserSwapsResult>;
+/**
+ * @internal
+ * Fetch the user's swap history for a specific chain.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: Pausable<UseUserSwapsArgs>): PausableReadResult<PaginatedUserSwapsResult>;
+type UseSwapTokensRequest = Prettify<PrepareSwapRequest & CurrencyQueryOptions>;
+type SwapIntent = SwapByIntentTypedData | SwapByIntentWithApprovalRequired | SwapTransactionRequest | SwapApprovalRequired;
+type SwapHandlerOptions = {
+    cancel: CancelOperation;
+};
+type SwapHandler = (intent: SwapIntent, options: SwapHandlerOptions) => ResultAsync<ERC20PermitSignature | SwapReceipt, SendTransactionError | PendingTransactionError>;
+/**
+ * @internal
+ * Orchestrate the swap execution plan.
+ *
+ * ```tsx
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * const [signSwapByIntentWith, signing] = useSignSwapByIntentWith(wallet);
+ *
+ * const [swap, swapping] = useSwapTokens((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'SwapByIntentTypedData':
+ *       return signSwapByIntentWith(plan);
+ *
+ *     case 'SwapApprovalRequired':
+ *     case 'SwapByIntentWithApprovalRequired':
+ *       return sendTransaction(plan.transaction);
+ *
+ *     case 'SwapTransactionRequest':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * const result = await swap({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *     sell: { erc20: evmAddress('0x6B175474E...') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.SELL,
+ *     user: evmAddress('0x742d35cc...'),
+ *   },
+ * });
  *
  * if (result.isErr()) {
  *   console.error(result.error);
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * // result.value: SwapReceipt
+ * ```
+ */
+declare function useSwapTokens(handler: SwapHandler): UseAsyncTask<PrepareSwapRequest, SwapReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+type CancelSwapHandler = (data: CancelSwapTypedData | TransactionRequest) => ResultAsync<ERC20PermitSignature | PendingTransaction, SigningError | UnexpectedError$1>;
+declare class CannotCancelSwapError extends ResultAwareError {
+    name: "CannotCancelSwapError";
+}
+type CancelSwapError = CancelError | CannotCancelSwapError | SigningError | TimeoutError | TransactionError | UnexpectedError$1;
+/**
+ * @internal
+ * Executes the complete swap cancellation workflow combining preparation and execution.
+ *
+ * ```tsx
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signSwapCancelWith] = useSignSwapCancelWith(wallet);
+ *
+ * const [cancelSwap, {loading, error}] = useCancelSwap((plan: CancelSwapTypedData | TransactionRequest) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *
+ *     case 'CancelSwapTypedData':
+ *       return signSwapCancelWith(plan);
+ *   }
+ * });
+ *
+ * const result = await cancelSwap({
+ *   id: swapId('123...'),
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapCancelled
+ * console.log('Swap cancelled:', result.value);
  * ```
  */
-declare function useUserEMode(): UseAsyncTask<UserSetEmodeRequest, TransactionRequest, UnexpectedError>;
+declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelled, CancelSwapError>;
+
 /**
- * A hook that provides a way to enable/disable a specific supplied asset as collateral.
+ * A hook that provides a way to supply assets to an Aave reserve.
  *
  * ```ts
- * const [toggle, toggling] = useCollateralToggle();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- *
- * const loading = toggling.loading && sending.loading;
- * const error = toggling.error || sending.error;
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [supply, { loading, error }] = useSupply((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
  *
  * // …
  *
- * const result = await toggle({ ... })
- *   .andThen(sendTransaction);
+ * const result = await supply({ ... });
  *
  * if (result.isErr()) {
- *   console.error(result.error);
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
  *   return;
  * }
  *
  * console.log('Transaction sent with hash:', result.value);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useCollateralToggle(): UseAsyncTask<CollateralToggleRequest, TransactionRequest, UnexpectedError>;
+declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
- * A hook that provides a way to liquidate a non-healthy position with Health Factor below 1.
+ * A hook that provides a way to borrow assets from an Aave reserve.
  *
  * ```ts
- * const [liquidate, liquidating] = useLiquidate();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- *
- * const loading = liquidating.loading && sending.loading;
- * const error = liquidating.error || sending.error;
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [borrow, { loading, error }] = useBorrow((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
  *
  * // …
  *
- * const result = await liquidate({ ... })
- *   .andThen(sendTransaction);
+ * const result = await borrow({ ... });
  *
  * if (result.isErr()) {
- *   console.error(result.error);
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
  *   return;
  * }
  *
  * console.log('Transaction sent with hash:', result.value);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useLiquidate(): UseAsyncTask<LiquidateRequest, TransactionRequest, UnexpectedError>;
+declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
- * A hook that provides a way to deposit assets into a vault.
+ * A hook that provides a way to repay borrowed assets to an Aave reserve.
  *
  * ```ts
- * const [deposit, depositing] = useVaultDeposit();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- *
- * const loading = depositing.loading && sending.loading;
- * const error = depositing.error || sending.error;
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [repay, { loading, error }] = useRepay((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
  *
  * // …
  *
- * const result = await deposit({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
+ * const result = await repay({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
  *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+/**
+ * A hook that provides a way to withdraw supplied assets from an Aave reserve.
  *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance: ${plan.required.value} required.`)
- *         );
- *     }
- *   });
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [withdraw, { loading, error }] = useWithdraw((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * // …
+ *
+ * const result = await withdraw({ ... });
  *
  * if (result.isErr()) {
- *   console.error(result.error);
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
  *   return;
  * }
  *
  * console.log('Transaction sent with hash:', result.value);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useVaultDeposit(): UseAsyncTask<VaultDepositRequest, ExecutionPlan, UnexpectedError>;
+declare function useWithdraw(handler: TransactionHandler): UseAsyncTask<WithdrawRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
- * A hook that provides a way to mint vault shares.
+ * A hook that provides a way to renounce a position manager of a user for a specific spoke.
  *
  * ```ts
- * const [mint, minting] = useVaultMintShares();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
  *
- * const loading = minting.loading && sending.loading;
- * const error = minting.error || sending.error;
+ * // …
+ *
+ * const result = await renounceSpokeUserPositionManager({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useRenounceSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * A hook that provides a way to update the user risk premium for a spoke.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [updateUserRiskPremium, { loading, error }] = useUpdateUserRiskPremium((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
  *
  * // …
  *
- * const result = await mint({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
+ * const result = await updateUserRiskPremium({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
  *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
  *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance: ${plan.required.value} required.`)
- *         );
- *     }
- *   });
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useUpdateUserRiskPremium(handler: TransactionHandler): UseAsyncTask<UpdateUserRiskPremiumRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * A hook that provides a way to update the user dynamic configuration for a spoke.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [updateUserDynamicConfig, { loading, error }] = useUpdateUserDynamicConfig((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
+ *
+ * // …
+ *
+ * const result = await updateUserDynamicConfig({ ... });
  *
  * if (result.isErr()) {
- *   console.error(result.error);
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
  *   return;
  * }
  *
  * console.log('Transaction sent with hash:', result.value);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useVaultMintShares(): UseAsyncTask<VaultMintSharesRequest, ExecutionPlan, UnexpectedError>;
+declare function useUpdateUserDynamicConfig(handler: TransactionHandler): UseAsyncTask<UpdateUserDynamicConfigRequest, TxHash, SendTransactionError | PendingTransactionError>;
 /**
- * A hook that provides a way to redeem vault shares.
+ * Hook for setting whether a user's supply should be used as collateral.
  *
  * ```ts
- * const [redeem, redeeming] = useVaultRedeemShares();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [setUserSupplyAsCollateral, { loading, error }] = useSetUserSupplyAsCollateral((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
+ *
+ * const result = await setUserSupplyAsCollateral({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   sender: evmAddress('0x456...'),
+ *   enableCollateral: true,
+ * });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
  *
- * const loading = redeeming.loading && sending.loading;
- * const error = redeeming.error || sending.error;
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useSetUserSupplyAsCollateral(handler: TransactionHandler): UseAsyncTask<SetUserSupplyAsCollateralRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * A hook that provides a way to liquidate a user's position.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [liquidatePosition, { loading, error }] = useLiquidatePosition((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
  *
  * // …
  *
- * const result = await redeem({ ... })
- *   .andThen(sendTransaction);
+ * const result = await liquidatePosition({
+ *   collateral: reserveId('SGVsbG8h'),
+ *   debt: reserveId('Q2lhbyE= '),
+ *   amount: amount,
+ *   liquidator: liquidator,
+ *   borrower: borrower,
+ * });
  *
  * if (result.isErr()) {
- *   console.error(result.error);
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
  *   return;
  * }
  *
  * console.log('Transaction sent with hash:', result.value);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useVaultRedeemShares(): UseAsyncTask<VaultRedeemSharesRequest, TransactionRequest, UnexpectedError>;
+declare function useLiquidatePosition(handler: TransactionHandler): UseAsyncTask<LiquidatePositionRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
- * A hook that provides a way to withdraw assets from a vault.
+ * A hook that provides a way to set or remove a position manager for a user on a specific spoke.
+ *
+ * **Position managers** can perform transactions on behalf of other users, including:
+ * - Supply assets
+ * - Borrow assets
+ * - Withdraw assets
+ * - Enable/disable collateral
+ *
+ * The `signature` parameter is an **ERC712 signature** that must be signed by the **user**
+ * (the account granting permissions) to authorize the position manager. The signature contains:
+ * - `value`: The actual cryptographic signature
+ * - `deadline`: Unix timestamp when the authorization expires
  *
  * ```ts
- * const [withdraw, withdrawing] = useVaultWithdraw();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [setSpokeUserPositionManager, { loading, error }] = useSetSpokeUserPositionManager((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
+ *
+ * const result = await setSpokeUserPositionManager({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   manager: evmAddress('0x9abc…'), // Address that will become the position manager
+ *   approve: true, // true to approve, false to remove the manager
+ *   user: evmAddress('0xdef0…'), // User granting the permission (must sign the signature)
+ *   signature: {
+ *     value: '0x1234...', // ERC712 signature signed by the user
+ *     deadline: 1735689600, // Unix timestamp when signature expires
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useSetSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<SetSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * Preview the impact of a potential action on a user's position.
  *
- * const loading = withdrawing.loading && sending.loading;
- * const error = withdrawing.error || sending.error;
+ * ```tsx
+ * const [getPreview, previewing] = usePreviewAction();
+ *
+ * const loading = previewing.loading;
+ * const error = previewing.error;
  *
  * // …
  *
- * const result = await withdraw({ ... })
- *   .andThen(sendTransaction);
+ * const result = await getPreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           value: '1000',
+ *         },
+ *       },
+ *       sender: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
  *
  * if (result.isErr()) {
  *   console.error(result.error);
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * console.log('Preview result:', result.value);
+ * ```
+ */
+declare function usePreviewAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<PreviewRequest, PreviewUserPosition, UnexpectedError>;
+type UsePreviewArgs = Prettify<PreviewRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: UsePreviewArgs & Suspendable): SuspenseResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: Pausable<UsePreviewArgs> & Suspendable): PausableSuspenseResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * ```tsx
+ * const { data, error, loading } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function usePreview(args: UsePreviewArgs): ReadResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
+type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
+ *
+ * // data.items: ActivityItem[]
+ * ```
+ */
+declare function useActivities(args: UseActivitiesArgs & Suspendable): SuspenseResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ *
+ * // data?.items: ActivityItem[] | undefined
+ * ```
+ */
+declare function useActivities(args: Pausable<UseActivitiesArgs> & Suspendable): PausableSuspenseResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ * });
  * ```
  */
-declare function useVaultWithdraw(): UseAsyncTask<VaultWithdrawRequest, TransactionRequest, UnexpectedError>;
+declare function useActivities(args: UseActivitiesArgs): ReadResult<PaginatedActivitiesResult>;
 /**
- * A hook that provides a way to deploy a vault.
- *
- * ```ts
- * const [deploy, deploying] = useVaultDeploy();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * Fetch paginated list of activities.
  *
- * const loading = deploying.loading && sending.loading;
- * const error = deploying.error || sending.error;
+ * Pausable loading state mode.
  *
- * // …
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
+ * });
  *
- * const result = await deploy({ ... })
- *   .andThen((plan) => {
- *     switch (plan.__typename) {
- *       case 'TransactionRequest':
- *         return sendTransaction(plan);
+ * // data?.items: ActivityItem[] | undefined
+ * // error: UnexpectedError | undefined
+ * // loading: boolean | undefined
+ * ```
+ */
+declare function useActivities(args: Pausable<UseActivitiesArgs>): PausableReadResult<PaginatedActivitiesResult>;
+/**
+ * Low-level hook to execute a {@link activities} action directly.
  *
- *       case 'ApprovalRequired':
- *         return sendTransaction(plan.approval)
- *           .andThen(() => sendTransaction(plan.originalTransaction));
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook does not actively watch for updates. Use it to fetch activities on demand
+ * (e.g., in an event handler when paginating or refining filters).
  *
- *       case 'InsufficientBalanceError':
- *         return errAsync(
- *           new Error(`Insufficient balance: ${plan.required.value} required.`)
- *         );
- *     }
- *   });
+ * @param options - The query options.
+ * @returns The user history.
+ */
+declare function useActivitiesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
+
+type UseUserSuppliesArgs = Prettify<UserSuppliesRequest & CurrencyQueryOptions>;
+/**
+ * Fetch all user supply positions.
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
+ * This signature supports React Suspense:
  *
- * console.log('Transaction sent with hash:', result.value);
+ * ```tsx
+ * const { data } = useUserSupplies({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ * });
  * ```
  */
-declare function useVaultDeploy(): UseAsyncTask<VaultDeployRequest, ExecutionPlan, UnexpectedError>;
+declare function useUserSupplies(args: UseUserSuppliesArgs & Suspendable): SuspenseResult<UserSupplyItem[]>;
 /**
- * A hook that provides a way to set vault fee.
+ * Fetch all user supply positions.
  *
- * ```ts
- * const [setFee, setting] = useVaultSetFee();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * Pausable suspense mode.
  *
- * const loading = setting.loading && sending.loading;
- * const error = setting.error || sending.error;
+ * ```tsx
+ * const { data } = useUserSupplies({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ *   pause: true,
+ * });
  *
- * // …
+ * // data?.length: number | undefined
+ * ```
+ */
+declare function useUserSupplies(args: Pausable<UseUserSuppliesArgs> & Suspendable): PausableSuspenseResult<UserSupplyItem[]>;
+/**
+ * Fetch all user supply positions.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserSupplies({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ * });
+ * ```
+ */
+declare function useUserSupplies(args: UseUserSuppliesArgs): ReadResult<UserSupplyItem[]>;
+/**
+ * Fetch all user supply positions.
  *
- * const result = await setFee({ ... })
- *   .andThen(sendTransaction);
+ * Pausable loading state mode.
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
+ * ```tsx
+ * const { data, error, loading, paused } = useUserSupplies({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   pause: true,
+ * });
  *
- * console.log('Transaction sent with hash:', result.value);
+ * // data?.length: number | undefined
+ * // error: UnexpectedError | undefined
+ * // loading: boolean | undefined
+ * // paused: boolean
  * ```
  */
-declare function useVaultSetFee(): UseAsyncTask<VaultSetFeeRequest, TransactionRequest, UnexpectedError>;
+declare function useUserSupplies(args: Pausable<UseUserSuppliesArgs>): PausableReadResult<UserSupplyItem[]>;
 /**
- * A hook that provides a way to withdraw vault fees.
+ * Low-level hook to execute a {@link userSupplies} action directly.
  *
- * ```ts
- * const [withdraw, withdrawing] = useVaultWithdrawFees();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on user supplies.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
  *
- * const loading = withdrawing.loading && sending.loading;
- * const error = withdrawing.error || sending.error;
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserSuppliesAction();
  *
  * // …
  *
- * const result = await withdraw({ ... })
- *   .andThen(sendTransaction);
+ * const result = await execute({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ * });
  *
- * if (result.isErr()) {
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserSupplyItem[]
+ * } else {
  *   console.error(result.error);
- *   return;
  * }
- *
- * console.log('Transaction sent with hash:', result.value);
  * ```
  */
-declare function useVaultWithdrawFees(): UseAsyncTask<VaultWithdrawFeesRequest, TransactionRequest, UnexpectedError>;
+declare function useUserSuppliesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<UserSuppliesRequest, UserSupplyItem[], UnexpectedError>;
+type UseUserBorrowsArgs = Prettify<UserBorrowsRequest & CurrencyQueryOptions>;
 /**
- * A hook that provides a way to transfer ownership of a vault.
+ * Fetch all user borrow positions.
  *
- * ```ts
- * const [transferOwnership, transferring] = useVaultTransferOwnership();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserBorrows({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: UseUserBorrowsArgs & Suspendable): SuspenseResult<UserBorrowItem[]>;
+/**
+ * Fetch all user borrow positions.
  *
- * const loading = transferring.loading && sending.loading;
- * const error = transferring.error || sending.error;
+ * Pausable suspense mode.
  *
- * // …
+ * ```tsx
+ * const { data } = useUserBorrows({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: Pausable<UseUserBorrowsArgs> & Suspendable): PausableSuspenseResult<UserBorrowItem[]>;
+/**
+ * Fetch all user borrow positions.
  *
- * const result = await transferOwnership({ ... })
- *   .andThen(sendTransaction);
+ * ```tsx
+ * const { data, error, loading } = useUserBorrows({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: UseUserBorrowsArgs): ReadResult<UserBorrowItem[]>;
+/**
+ * Fetch all user borrow positions.
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
+ * Pausable loading state mode.
  *
- * console.log('Transaction sent with hash:', result.value);
+ * ```tsx
+ * const { data, error, loading, paused } = useUserBorrows({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   pause: true,
+ * });
  * ```
  */
-declare function useVaultTransferOwnership(): UseAsyncTask<VaultTransferOwnershipRequest, TransactionRequest, UnexpectedError>;
+declare function useUserBorrows(args: Pausable<UseUserBorrowsArgs>): PausableReadResult<UserBorrowItem[]>;
 /**
- * A hook that provides a way to approve a credit borrow delegator to be able to borrow on your behalf.
+ * Low-level hook to execute a {@link userBorrows} action directly.
  *
- * ```ts
- * const [approve, approving] = useApproveBorrowCreditDelegation();
- * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on user borrows.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
  *
- * const loading = approving.loading && sending.loading;
- * const error = approving.error || sending.error;
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserBorrowsAction();
  *
  * // …
  *
- * const result = await approve({
- *   market: evmAddress('0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2'),
- *   underlyingToken: evmAddress('0xa0b86a33e6441c8c5f0bb9b7e5e1f8bbf5b78b5c'),
- *   amount: '1000',
- *   user: evmAddress('0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234'),
- *   delegatee: evmAddress('0x5678…'),
- *   chainId: chainId(1),
- * }).andThen(sendTransaction);
+ * const result = await execute({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ * });
  *
- * if (result.isErr()) {
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserBorrowItem[]
+ * } else {
  *   console.error(result.error);
- *   return;
  * }
- *
- * console.log('Transaction sent with hash:', result.value);
  * ```
  */
-declare function useApproveBorrowCreditDelegation(): UseAsyncTask<ApproveBorrowCreditDelegatorRequest, TransactionRequest, UnexpectedError>;
-
-type UseUserSuppliesArgs = UserSuppliesRequest;
+declare function useUserBorrowsAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<UserBorrowsRequest, UserBorrowItem[], UnexpectedError>;
+type UseUserSummaryArgs = Prettify<UserSummaryRequest & TimeWindowQueryOptions & CurrencyQueryOptions>;
 /**
- * Fetch all user supply positions.
+ * Fetch a user's financial summary.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useUserSupplies({
- *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
+ * const { data } = useUserSummary({
  *   user: evmAddress('0x742d35cc…'),
- *   orderBy: { name: OrderDirection.ASC },
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *   },
  *   suspense: true,
  * });
  * ```
  */
-declare function useUserSupplies(args: UseUserSuppliesArgs & Suspendable): SuspenseResult<MarketUserReserveSupplyPosition[]>;
+declare function useUserSummary(args: UseUserSummaryArgs & Suspendable): SuspenseResult<UserSummary>;
 /**
- * Fetch all user supply positions.
+ * Fetch a user's financial summary.
+ *
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data, error, loading } = useUserSupplies({
- *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
+ * const { data } = useUserSummary({
  *   user: evmAddress('0x742d35cc…'),
- *   orderBy: { name: OrderDirection.ASC },
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *   },
+ *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useUserSupplies(args: UseUserSuppliesArgs): ReadResult<MarketUserReserveSupplyPosition[]>;
-type UseUserBorrowsArgs = UserBorrowsRequest;
+declare function useUserSummary(args: Pausable<UseUserSummaryArgs> & Suspendable): PausableSuspenseResult<UserSummary>;
 /**
- * Fetch all user borrow positions.
- *
- * This signature supports React Suspense:
+ * Fetch a user's financial summary.
  *
  * ```tsx
- * const { data } = useUserBorrows({
- *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
+ * const { data, error, loading } = useUserSummary({
  *   user: evmAddress('0x742d35cc…'),
- *   orderBy: { name: OrderDirection.ASC },
- *   suspense: true
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *   },
  * });
  * ```
  */
-declare function useUserBorrows(args: UseUserBorrowsArgs & Suspendable): SuspenseResult<MarketUserReserveBorrowPosition[]>;
+declare function useUserSummary(args: UseUserSummaryArgs): ReadResult<UserSummary>;
 /**
- * Fetch all user borrow positions.
+ * Fetch a user's financial summary.
+ *
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading } = useUserBorrows({
- *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
+ * const { data, error, loading, paused } = useUserSummary({
  *   user: evmAddress('0x742d35cc…'),
- *   orderBy: { name: OrderDirection.ASC },
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *   },
+ *   pause: true,
  * });
  * ```
  */
-declare function useUserBorrows(args: UseUserBorrowsArgs): ReadResult<MarketUserReserveBorrowPosition[]>;
-type UseUserStateArgs = UserMarketStateRequest;
+declare function useUserSummary(args: Pausable<UseUserSummaryArgs>): PausableReadResult<UserSummary>;
+type UseUserPositionsArgs = Prettify<UserPositionsRequest & UserPositionQueryOptions>;
 /**
- * Fetch user account market data across all reserves.
+ * Fetch all user positions across specified chains.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useUserMarketState({
- *   market: evmAddress('0x1234…'),
- *   user: evmAddress('0x5678…'),
- *   chainId: chainId(1),
+ * const { data } = useUserPositions({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   orderBy: { balance: 'DESC' },
  *   suspense: true,
  * });
  * ```
  */
-declare function useUserMarketState(args: UseUserStateArgs & Suspendable): SuspenseResult<MarketUserState>;
+declare function useUserPositions(args: UseUserPositionsArgs & Suspendable): SuspenseResult<UserPosition[]>;
 /**
- * Fetch user account market data across all reserves.
+ * Fetch all user positions across specified chains.
+ *
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data, error, loading } = useUserMarketState({
- *   market: evmAddress('0x1234…'),
- *   user: evmAddress('0x5678…'),
- *   chainId: chainId(1),
+ * const { data } = useUserPositions({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   orderBy: { balance: 'DESC' },
+ *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useUserMarketState(args: UseUserStateArgs): ReadResult<MarketUserState>;
-type UseUserTransactionHistoryArgs = UserTransactionHistoryRequest;
+declare function useUserPositions(args: Pausable<UseUserPositionsArgs> & Suspendable): PausableSuspenseResult<UserPosition[]>;
 /**
- * Fetch user transaction history.
- *
- * This signature supports React Suspense:
+ * Fetch all user positions across specified chains.
  *
  * ```tsx
- * const { data } = useUserTransactionHistory({
- *   suspense: true,
+ * const { data, error, loading } = useUserPositions({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   orderBy: { balance: 'DESC' },
  * });
  * ```
  */
-declare function useUserTransactionHistory(args: UseUserTransactionHistoryArgs & Suspendable): SuspenseResult<PaginatedUserTransactionHistoryResult>;
+declare function useUserPositions(args: UseUserPositionsArgs): ReadResult<UserPosition[]>;
 /**
- * Fetch user transaction history.
+ * Fetch all user positions across specified chains.
+ *
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading } = useUserTransactionHistory();
+ * const { data, error, loading, paused } = useUserPositions({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   orderBy: { balance: 'DESC' },
+ *   pause: true,
+ * });
  * ```
  */
-declare function useUserTransactionHistory(args: UseUserTransactionHistoryArgs): ReadResult<PaginatedUserTransactionHistoryResult>;
-
-type UseVaultArgs = VaultRequest;
+declare function useUserPositions(args: Pausable<UseUserPositionsArgs>): PausableReadResult<UserPosition[]>;
 /**
- * Fetch a single vault by address and chain ID.
+ * Low-level hook to execute a {@link userPositions} action directly.
  *
- * This signature supports React Suspense:
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on user positions.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
  *
- * ```tsx
- * const { data } = useVault({
- *   by: {
- *     address: evmAddress('0x1234…'),
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserPositionsAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     chainIds: [chainId(1), chainId(137)]
  *   },
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678…'),
- *   suspense: true,
+ *   orderBy: { balance: 'DESC' },
  * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserPosition[]
+ * } else {
+ *   console.error(result.error);
+ * }
  * ```
  */
-declare function useVault(args: UseVaultArgs & Suspendable): SuspenseResult<Vault | null>;
+declare function useUserPositionsAction(options?: UserPositionQueryOptions): UseAsyncTask<UserPositionsRequest, UserPosition[], UnexpectedError>;
+type UseUserPositionArgs = Prettify<UserPositionRequest & UserPositionQueryOptions>;
 /**
- * Fetch a single vault by address and chain ID.
+ * Fetch a specific user position by ID.
+ *
+ * This signature supports React Suspense:
  *
  * ```tsx
- * const { data, error, loading } = useVault({
- *   address: evmAddress('0x1234…'),
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678…'),
+ * const { data } = useUserPosition({
+ *   id: userPositionId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
  * });
  * ```
  */
-declare function useVault(args: UseVaultArgs): ReadResult<Vault | null>;
-type UseVaultsArgs = VaultsRequest;
+declare function useUserPosition(args: UseUserPositionArgs & Suspendable): SuspenseResult<UserPosition>;
 /**
- * Fetch vaults based on filter criteria.
+ * Fetch a specific user position by ID.
  *
- * This signature supports React Suspense:
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useVaults({
- *   criteria: {
- *     ownedBy: [evmAddress('0x1234…')]
- *   },
- *   pageSize: PageSize.Ten,
- *   user: evmAddress('0x5678…'),
+ * const { data } = useUserPosition({
+ *   id: userPositionId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
  *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useVaults(args: UseVaultsArgs & Suspendable): SuspenseResult<PaginatedVaultsResult>;
+declare function useUserPosition(args: Pausable<UseUserPositionArgs> & Suspendable): PausableSuspenseResult<UserPosition>;
 /**
- * Fetch vaults based on filter criteria.
+ * Fetch a specific user position by ID.
  *
  * ```tsx
- * const { data, error, loading } = useVaults({
- *   criteria: {
- *     ownedBy: [evmAddress('0x1234…')]
- *   },
- *   pageSize: PageSize.Ten,
- *   user: evmAddress('0x5678…'),
+ * const { data, error, loading } = useUserPosition({
+ *   id: userPositionId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
  * });
  * ```
  */
-declare function useVaults(args: UseVaultsArgs): ReadResult<PaginatedVaultsResult>;
-type UseUserVaultsArgs = UserVaultsRequest;
+declare function useUserPosition(args: UseUserPositionArgs): ReadResult<UserPosition>;
 /**
- * Fetch vaults that a user has shares in.
+ * Fetch a specific user position by ID.
  *
- * This signature supports React Suspense:
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data } = useUserVaults({
- *   user: evmAddress('0x1234…'),
- *   filters: {
- *     markets: [evmAddress('0x5678…')]
- *   },
- *   orderBy: { shares: OrderDirection.Desc },
- *   pageSize: PageSize.Fifty,
- *   suspense: true,
+ * const { data, error, loading, paused } = useUserPosition({
+ *   id: userPositionId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
  * });
  * ```
  */
-declare function useUserVaults(args: UseUserVaultsArgs & Suspendable): SuspenseResult<PaginatedVaultsResult>;
+declare function useUserPosition(args: Pausable<UseUserPositionArgs>): PausableReadResult<UserPosition>;
+type UseUserBalancesArgs = Prettify<UserBalancesRequest & CurrencyQueryOptions>;
 /**
- * Fetch vaults that a user has shares in.
+ * Fetch all user balances across specified chains.
+ *
+ * This signature supports React Suspense:
  *
  * ```tsx
- * const { data, error, loading } = useUserVaults({
- *   user: evmAddress('0x1234…'),
- *   filters: {
- *     markets: [evmAddress('0x5678…')]
- *   },
- *   orderBy: { shares: OrderDirection.Desc },
- *   pageSize: PageSize.Fifty,
+ * const { data } = useUserBalances({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   suspense: true,
  * });
  * ```
  */
-declare function useUserVaults(args: UseUserVaultsArgs): ReadResult<PaginatedVaultsResult>;
+declare function useUserBalances(args: UseUserBalancesArgs & Suspendable): SuspenseResult<UserBalance[]>;
 /**
- * Determines the amount of shares that would be received for a deposit.
- *
- * ```ts
- * const [preview, { loading, error }] = useVaultDepositPreview();
+ * Fetch all user balances across specified chains.
  *
- * // …
+ * Pausable suspense mode.
  *
- * const result = await preview({
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   amount: bigDecimal('1000'),
+ * ```tsx
+ * const { data } = useUserBalances({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   suspense: true,
+ *   pause: true,
  * });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- * } else {
- *   console.log(result.value);
- * }
  * ```
  */
-declare function useVaultDepositPreview(): UseAsyncTask<VaultPreviewDepositRequest, TokenAmount, UnexpectedError>;
+declare function useUserBalances(args: Pausable<UseUserBalancesArgs> & Suspendable): PausableSuspenseResult<UserBalance[]>;
 /**
- * Determines the amount of assets that would be required to mint a specific amount of vault shares.
- *
- * ```ts
- * const [preview, { loading, error }] = useVaultMintPreview();
+ * Fetch all user balances across specified chains.
  *
- * // …
- *
- * const result = await preview({
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   amount: bigDecimal('500'),
+ * ```tsx
+ * const { data, error, loading } = useUserBalances({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
  * });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- * } else {
- *   console.log(result.value);
- * }
  * ```
  */
-declare function useVaultMintPreview(): UseAsyncTask<VaultPreviewMintRequest, TokenAmount, UnexpectedError>;
+declare function useUserBalances(args: UseUserBalancesArgs): ReadResult<UserBalance[]>;
 /**
- * Determines the amount of shares that would be burned for a withdrawal.
- *
- * ```ts
- * const [preview, { loading, error }] = useVaultWithdrawPreview();
+ * Fetch all user balances across specified chains.
  *
- * // …
+ * Pausable loading state mode.
  *
- * const result = await preview({
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   amount: bigDecimal('750'),
+ * ```tsx
+ * const { data, error, loading, paused } = useUserBalances({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   pause: true,
  * });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- * } else {
- *   console.log(result.value);
- * }
  * ```
  */
-declare function useVaultWithdrawPreview(): UseAsyncTask<VaultPreviewWithdrawRequest, TokenAmount, UnexpectedError>;
+declare function useUserBalances(args: Pausable<UseUserBalancesArgs>): PausableReadResult<UserBalance[]>;
 /**
- * Determines the amount of assets that would be received for redeeming a specific amount of vault shares.
+ * Low-level hook to execute a {@link userBalances} action directly.
  *
- * This signature supports React Suspense:
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on user balances.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
  *
  * ```ts
- * const [preview, { loading, error }] = useVaultRedeemPreview();
+ * const [execute, { called, data, error, loading }] = useUserBalancesAction();
  *
  * // …
  *
- * const result = await preview({
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   amount: bigDecimal('200'),
+ * const result = await execute({
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     chainIds: [chainId(1), chainId(137)]
+ *   },
  * });
  *
- * if (result.isErr()) {
- *   console.error(result.error);
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserBalance[]
  * } else {
- *   console.log(result.value);
+ *   console.error(result.error);
  * }
  * ```
  */
-declare function useVaultRedeemPreview(): UseAsyncTask<VaultPreviewRedeemRequest, TokenAmount, UnexpectedError>;
-type UseVaultUserTransactionHistoryArgs = VaultUserTransactionHistoryRequest;
+declare function useUserBalancesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<UserBalancesRequest, UserBalance[], UnexpectedError>;
+type UseUserSummaryHistoryArgs = Prettify<UserSummaryHistoryRequest & CurrencyQueryOptions>;
 /**
- * Fetch user transaction history for a vault.
+ * Fetch user summary history over time.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useVaultUserTransactionHistory({
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678901234567890abcdef1234567890abcdef12'),
+ * const { data } = useUserSummaryHistory({
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: { chainIds: [chainId(1)] },
  *   suspense: true,
  * });
  * ```
  */
-declare function useVaultUserTransactionHistory(args: UseVaultUserTransactionHistoryArgs & Suspendable): SuspenseResult<PaginatedVaultUserTransactionHistoryResult>;
+declare function useUserSummaryHistory(args: UseUserSummaryHistoryArgs & Suspendable): SuspenseResult<UserSummaryHistoryItem[]>;
 /**
- * Fetch user transaction history for a vault.
+ * Fetch user summary history over time.
+ *
+ * Pausable suspense mode.
  *
  * ```tsx
- * const { data, error, loading } = useVaultUserTransactionHistory({
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678901234567890abcdef1234567890abcdef12'),
+ * const { data } = useUserSummaryHistory({
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
  * });
  * ```
  */
-declare function useVaultUserTransactionHistory(args: UseVaultUserTransactionHistoryArgs): ReadResult<PaginatedVaultUserTransactionHistoryResult>;
-type UseVaultUserActivityArgs = VaultUserActivityRequest;
+declare function useUserSummaryHistory(args: Pausable<UseUserSummaryHistoryArgs> & Suspendable): PausableSuspenseResult<UserSummaryHistoryItem[]>;
 /**
- * Fetch user activity data for a vault, including earnings breakdown over time.
- *
- * This signature supports React Suspense:
+ * Fetch user summary history over time.
  *
  * ```tsx
- * const { data } = useVaultUserActivity({
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678901234567890abcdef1234567890abcdef12'),
- *   suspense: true,
+ * const { data, error, loading } = useUserSummaryHistory({
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: { chainIds: [chainId(1)] },
  * });
  * ```
  */
-declare function useVaultUserActivity(args: UseVaultUserActivityArgs & Suspendable): SuspenseResult<VaultUserActivityResult>;
+declare function useUserSummaryHistory(args: UseUserSummaryHistoryArgs): ReadResult<UserSummaryHistoryItem[]>;
 /**
- * Fetch user activity data for a vault, including earnings breakdown over time.
+ * Fetch user summary history over time.
+ *
+ * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading } = useVaultUserActivity({
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678901234567890abcdef1234567890abcdef12'),
+ * const { data, error, loading, paused } = useUserSummaryHistory({
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: { chainIds: [chainId(1)] },
+ *   pause: true,
  * });
- *
- * if (data) {
- *   console.log('Total earned:', data.earned.amount.value);
- *   data.breakdown.forEach(activity => {
- *     console.log('Date:', activity.date);
- *     console.log('Balance:', activity.balance.amount.value);
- *   });
- * }
  * ```
  */
-declare function useVaultUserActivity(args: UseVaultUserActivityArgs): ReadResult<VaultUserActivityResult>;
+declare function useUserSummaryHistory(args: Pausable<UseUserSummaryHistoryArgs>): PausableReadResult<UserSummaryHistoryItem[]>;
 
-export { AaveProvider, type AaveProviderProps, type SavingsGhoBalanceArgs, type UseAaveChainsArgs, type UseAaveMarketArgs, type UseAaveMarketsArgs, type UseAaveReserveArgs, type UseBorrowAPYHistoryArgs, type UseCreditDelegateeAllowanceArgs, type UseSupplyAPYHistoryArgs, type UseUsdExchangeRatesArgs, type UseUserBorrowsArgs, type UseUserStateArgs, type UseUserSuppliesArgs, type UseUserTransactionHistoryArgs, type UseUserVaultsArgs, type UseVaultArgs, type UseVaultUserActivityArgs, type UseVaultUserTransactionHistoryArgs, type UseVaultsArgs, type UserMeritRewardsArgs, useAaveChains, useAaveClient, useAaveHealth, useAaveHealthFactorPreview, useAaveMarket, useAaveMarkets, useAaveReserve, useApproveBorrowCreditDelegation, useBorrow, useBorrowAPYHistory, useCollateralToggle, useCreditDelegateeAllowance, useLiquidate, useRepay, useSavingsGhoBalance, useSavingsGhoDeposit, useSavingsGhoWithdraw, useSupply, useSupplyAPYHistory, useUsdExchangeRates, useUserBorrows, useUserEMode, useUserMarketState, useUserMeritRewards, useUserSupplies, useUserTransactionHistory, useUserVaults, useVault, useVaultDeploy, useVaultDeposit, useVaultDepositPreview, useVaultMintPreview, useVaultMintShares, useVaultRedeemPreview, useVaultRedeemShares, useVaultSetFee, useVaultTransferOwnership, useVaultUserActivity, useVaultUserTransactionHistory, useVaultWithdraw, useVaultWithdrawFees, useVaultWithdrawPreview, useVaults, useWithdraw };
+export { AaveProvider, type AaveProviderProps, type CancelSwapError, type CancelSwapHandler, CannotCancelSwapError, SendTransactionError, type SwapHandler, type SwapHandlerOptions, type SwapIntent, type UseActivitiesArgs, type UseAssetArgs, type UseAssetBorrowHistoryArgs, type UseAssetPriceHistoryArgs, type UseAssetSupplyHistoryArgs, UseAsyncTask, type UseBorrowApyHistoryArgs, type UseHubArgs, type UseHubAssetsArgs, type UseHubsArgs, type UsePreviewArgs, type UseReserveArgs, type UseReservesArgs, type UseSpokeArgs, type UseSpokePositionManagersArgs, type UseSpokeUserPositionManagersArgs, type UseSpokesArgs, type UseSupplyApyHistoryArgs, type UseSwapQuoteArgs, type UseSwapTokensRequest, type UseSwappableTokensArgs, type UseUserBalancesArgs, type UseUserBorrowsArgs, type UseUserPositionArgs, type UseUserPositionsArgs, type UseUserSummaryArgs, type UseUserSummaryHistoryArgs, type UseUserSuppliesArgs, type UseUserSwapsArgs, useAaveClient, useActivities, useActivitiesAction, useAsset, useAssetBorrowHistory, useAssetPriceHistory, useAssetSupplyHistory, useBorrow, useBorrowApyHistory, useCancelSwap, useHub, useHubAssets, useHubs, useHubsAction, useLiquidatePosition, usePermitTypedDataAction, usePreview, usePreviewAction, useRenounceSpokeUserPositionManager, useRepay, useReserve, useReserveAction, useReserves, useReservesAction, useSetSpokeUserPositionManager, useSetUserSupplyAsCollateral, useSpoke, useSpokePositionManagers, useSpokeUserPositionManagers, useSpokes, useSupply, useSupplyApyHistory, useSwapQuote, useSwapQuoteAction, useSwapTokens, useSwappableTokens, useUpdateUserDynamicConfig, useUpdateUserRiskPremium, useUserBalances, useUserBalancesAction, useUserBorrows, useUserBorrowsAction, useUserPosition, useUserPositions, useUserPositionsAction, useUserSummary, useUserSummaryHistory, useUserSupplies, useUserSuppliesAction, useUserSwaps, useWithdraw };