@aave/react 4.0.0-next.3 → 4.0.0-next.31

package/dist/index.d.cts

@@ -1,13 +1,13 @@
-import { AaveClient, CurrencyQueryOptions, UnexpectedError, TimeWindowQueryOptions, ValidationError, ActivitiesRequest, PaginatedActivitiesResult } from '@aave/client';
+import { AaveClient, CurrencyQueryOptions, TimeWindowQueryOptions, UnexpectedError, ValidationError, ActivitiesRequest, PaginatedActivitiesResult } from '@aave/client';
 export * from '@aave/client';
 import React, { ReactNode } from 'react';
-import { a as UseAsyncTask, C as CancelOperation, S as SendTransactionError, P as PendingTransactionError, b as PendingTransaction, T as TransactionHandler } from './writes-BXnwYgAQ.cjs';
-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.cjs';
-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-BkG5G4yl.cjs';
-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-BkG5G4yl.cjs';
-import { UnexpectedError as UnexpectedError$1, SigningError, CancelError, TimeoutError, TransactionError, ValidationError as ValidationError$1 } from '@aave/core';
+import { a as UseAsyncTask, C as CancelOperation, P as PendingTransaction, S as SendTransactionError, b as PendingTransactionError, E as ExecutionPlanHandler } from './writes-XDyuot3t.cjs';
+export { A as AsyncTaskError, c as AsyncTaskIdle, d as AsyncTaskLoading, e as AsyncTaskState, f as AsyncTaskSuccess, T as TransactionHandlerOptions, U as UseSendTransactionResult } from './writes-XDyuot3t.cjs';
+import { HubRequest, Hub, HubsRequest, HubAssetsRequest, HubAsset, HubSummaryHistoryRequest, HubSummarySample, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, ProtocolHistoryRequest, ProtocolHistorySample, ReserveRequest, Reserve, ReservesRequest, BorrowApyHistoryRequest, ApySample, SupplyApyHistoryRequest, SpokeRequest, Spoke, SpokesRequest, SpokePositionManagersRequest, PaginatedSpokePositionManagerResult, SpokeUserPositionManagersRequest, PaginatedSpokeUserPositionManagerResult, TokenSwapQuoteRequest, SwapQuote, SwappableTokensRequest, Token, UserSwapsRequest, PaginatedUserSwapsResult, SwapStatusRequest, SwapStatus, SupplySwapQuoteRequest, BorrowSwapQuoteRequest, TransactionRequest, PositionSwapApproval, SwapTypedData, SwapReceipt, InsufficientBalanceError, RepayWithSupplyQuoteRequest, WithdrawSwapQuoteRequest, Erc20Approval, SwapTransactionRequest, PrepareSwapCancelRequest, SwapCancelled, PreContractActionRequired, SupplyRequest, BorrowRequest, RepayRequest, WithdrawRequest, RenounceSpokeUserPositionManagerRequest, UpdateUserPositionConditionsRequest, SetUserSuppliesAsCollateralRequest, LiquidatePositionRequest, SetSpokeUserPositionManagerRequest, PreviewRequest, PreviewUserPosition, UserSuppliesRequest, UserSupplyItem, UserBorrowsRequest, UserBorrowItem, UserSummaryRequest, UserSummary, UserPositionsRequest, UserPosition, UserPositionRequest, UserBalancesRequest, UserBalance, UserRiskPremiumBreakdownRequest, UserRiskPremiumBreakdownItem, UserSummaryHistoryRequest, UserSummaryHistoryItem } from '@aave/graphql';
+import { Prettify, Signature, 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-Dv6nwSVM.cjs';
+export { e as UseChainArgs, g as UseChainsArgs, j as UseExchangeRateArgs, U as UseNetworkFee, m as UseNetworkFeeArgs, l as UseNetworkFeeRequestQuery, u as useChain, f as useChainAction, h as useChains, k as useExchangeRate, i as useExchangeRateAction } from './misc-Dv6nwSVM.cjs';
+import { UnexpectedError as UnexpectedError$1, CancelError, SigningError, TimeoutError, TransactionError, ValidationError as ValidationError$1 } from '@aave/core';
 import { UserPositionQueryOptions } from '@aave/client/actions';
 
 /**
@@ -49,7 +49,7 @@ declare function AaveProvider({ children, client }: AaveProviderProps): React.JS
  */
 declare function useAaveClient(): AaveClient;
 
-type UseHubArgs = Prettify<HubRequest & CurrencyQueryOptions>;
+type UseHubArgs = Prettify<HubRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch a specific hub by ID or by address and chain ID.
  *
@@ -102,7 +102,7 @@ declare function useHub(args: UseHubArgs): ReadResult<Hub | null>;
  * ```
  */
 declare function useHub(args: Pausable<UseHubArgs>): PausableReadResult<Hub | null>;
-type UseHubsArgs = Prettify<HubsRequest & CurrencyQueryOptions>;
+type UseHubsArgs = Prettify<HubsRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch multiple hubs based on specified criteria.
  *
@@ -153,7 +153,7 @@ declare function useHubs(args: UseHubsArgs): ReadResult<Hub[]>;
  * ```
  */
 declare function useHubs(args: Pausable<UseHubsArgs>): PausableReadResult<Hub[]>;
-type UseHubAssetsArgs = Prettify<HubAssetsRequest & CurrencyQueryOptions>;
+type UseHubAssetsArgs = Prettify<HubAssetsRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch hub assets for a specific hub by ID or by address and chain ID.
  *
@@ -208,6 +208,61 @@ declare function useHubAssets(args: UseHubAssetsArgs): ReadResult<HubAsset[]>;
  * ```
  */
 declare function useHubAssets(args: Pausable<UseHubAssetsArgs>): PausableReadResult<HubAsset[]>;
+type UseHubSummaryHistoryArgs = HubSummaryHistoryRequest;
+/**
+ * Fetch historical summary data for a specific hub.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useHubSummaryHistory({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useHubSummaryHistory(args: UseHubSummaryHistoryArgs & Suspendable): SuspenseResult<HubSummarySample[]>;
+/**
+ * Fetch historical summary data for a specific hub.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useHubSummaryHistory({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubSummaryHistory(args: Pausable<UseHubSummaryHistoryArgs> & Suspendable): PausableSuspenseResult<HubSummarySample[]>;
+/**
+ * Fetch historical summary data for a specific hub.
+ *
+ * ```tsx
+ * const { data, error, loading } = useHubSummaryHistory({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useHubSummaryHistory(args: UseHubSummaryHistoryArgs): ReadResult<HubSummarySample[]>;
+/**
+ * Fetch historical summary data for a specific hub.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useHubSummaryHistory({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubSummaryHistory(args: Pausable<UseHubSummaryHistoryArgs>): PausableReadResult<HubSummarySample[]>;
 /**
  * Low-level hook to execute a {@link hubs} action directly.
  *
@@ -237,11 +292,6 @@ declare function useHubAssets(args: Pausable<UseHubAssetsArgs>): PausableReadRes
  */
 declare function useHubsAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<HubsRequest, Hub[], UnexpectedError>;
 
-/**
- * @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.
@@ -350,7 +400,7 @@ declare function useAssetPriceHistory(args: UseAssetPriceHistoryArgs): ReadResul
  * ```
  */
 declare function useAssetPriceHistory(args: Pausable<UseAssetPriceHistoryArgs>): PausableReadResult<AssetPriceSample[]>;
-type UseAssetSupplyHistoryArgs = AssetSupplyHistoryRequest;
+type UseAssetSupplyHistoryArgs = Prettify<AssetSupplyHistoryRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch historical supply data for a specific asset.
  *
@@ -403,7 +453,7 @@ declare function useAssetSupplyHistory(args: UseAssetSupplyHistoryArgs): ReadRes
  * ```
  */
 declare function useAssetSupplyHistory(args: Pausable<UseAssetSupplyHistoryArgs>): PausableReadResult<AssetSupplySample[]>;
-type UseAssetBorrowHistoryArgs = AssetBorrowHistoryRequest;
+type UseAssetBorrowHistoryArgs = Prettify<AssetBorrowHistoryRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch historical borrow data for a specific asset.
  *
@@ -456,8 +506,63 @@ declare function useAssetBorrowHistory(args: UseAssetBorrowHistoryArgs): ReadRes
  * ```
  */
 declare function useAssetBorrowHistory(args: Pausable<UseAssetBorrowHistoryArgs>): PausableReadResult<AssetBorrowSample[]>;
+type UseProtocolHistoryArgs = ProtocolHistoryRequest;
+/**
+ * Fetch historical protocol-wide data (deposits, borrows, earnings).
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useProtocolHistory({
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useProtocolHistory(args: UseProtocolHistoryArgs & Suspendable): SuspenseResult<ProtocolHistorySample[]>;
+/**
+ * Fetch historical protocol-wide data (deposits, borrows, earnings).
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useProtocolHistory({
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useProtocolHistory(args: Pausable<UseProtocolHistoryArgs> & Suspendable): PausableSuspenseResult<ProtocolHistorySample[]>;
+/**
+ * Fetch historical protocol-wide data (deposits, borrows, earnings).
+ *
+ * ```tsx
+ * const { data, error, loading } = useProtocolHistory({
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useProtocolHistory(args: UseProtocolHistoryArgs): ReadResult<ProtocolHistorySample[]>;
+/**
+ * Fetch historical protocol-wide data (deposits, borrows, earnings).
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useProtocolHistory({
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useProtocolHistory(args: Pausable<UseProtocolHistoryArgs>): PausableReadResult<ProtocolHistorySample[]>;
 
-type UseReserveArgs = Prettify<ReserveRequest & CurrencyQueryOptions>;
+type UseReserveArgs = Prettify<ReserveRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch a specific reserve by reserve ID, spoke, and chain.
  *
@@ -537,8 +642,8 @@ declare function useReserve(args: Pausable<UseReserveArgs>): PausableReadResult<
  * }
  * ```
  */
-declare function useReserveAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ReserveRequest, Reserve | null, UnexpectedError>;
-type UseReservesArgs<T = Reserve[]> = Prettify<ReservesRequest & CurrencyQueryOptions & {
+declare function useReserveAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ReserveRequest, Reserve | null, UnexpectedError>;
+type UseReservesArgs<T = Reserve[]> = Prettify<ReservesRequest & CurrencyQueryOptions & TimeWindowQueryOptions & {
     /**
      * A function that maps the full list of reserves
      * into a derived or narrowed value.
@@ -737,8 +842,8 @@ declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>>):
  * }
  * ```
  */
-declare function useReservesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ReservesRequest, Reserve[], UnexpectedError>;
-type UseBorrowApyHistoryArgs = BorrowAPYHistoryRequest;
+declare function useReservesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ReservesRequest, Reserve[], UnexpectedError>;
+type UseBorrowApyHistoryArgs = BorrowApyHistoryRequest;
 /**
  * Fetch borrow APY history for a specific reserve over time.
  *
@@ -752,7 +857,7 @@ type UseBorrowApyHistoryArgs = BorrowAPYHistoryRequest;
  * });
  * ```
  */
-declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs & Suspendable): SuspenseResult<ApySample[]>;
 /**
  * Fetch borrow APY history for a specific reserve over time.
  *
@@ -767,7 +872,7 @@ declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs & Suspendable
  * });
  * ```
  */
-declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs> & Suspendable): PausableSuspenseResult<APYSample[]>;
+declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs> & Suspendable): PausableSuspenseResult<ApySample[]>;
 /**
  * Fetch borrow APY history for a specific reserve over time.
  *
@@ -778,7 +883,7 @@ declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs> & S
  * });
  * ```
  */
-declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs): ReadResult<APYSample[]>;
+declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs): ReadResult<ApySample[]>;
 /**
  * Fetch borrow APY history for a specific reserve over time.
  *
@@ -792,8 +897,8 @@ declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs): ReadResult<
  * });
  * ```
  */
-declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs>): PausableReadResult<APYSample[]>;
-type UseSupplyApyHistoryArgs = SupplyAPYHistoryRequest;
+declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs>): PausableReadResult<ApySample[]>;
+type UseSupplyApyHistoryArgs = SupplyApyHistoryRequest;
 /**
  * Fetch supply APY history for a specific reserve over time.
  *
@@ -807,7 +912,7 @@ type UseSupplyApyHistoryArgs = SupplyAPYHistoryRequest;
  * });
  * ```
  */
-declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs & Suspendable): SuspenseResult<ApySample[]>;
 /**
  * Fetch supply APY history for a specific reserve over time.
  *
@@ -822,7 +927,7 @@ declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs & Suspendable
  * });
  * ```
  */
-declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs> & Suspendable): PausableSuspenseResult<APYSample[]>;
+declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs> & Suspendable): PausableSuspenseResult<ApySample[]>;
 /**
  * Fetch supply APY history for a specific reserve over time.
  *
@@ -833,7 +938,7 @@ declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs> & S
  * });
  * ```
  */
-declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs): ReadResult<APYSample[]>;
+declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs): ReadResult<ApySample[]>;
 /**
  * Fetch supply APY history for a specific reserve over time.
  *
@@ -847,7 +952,7 @@ declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs): ReadResult<
  * });
  * ```
  */
-declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs>): PausableReadResult<APYSample[]>;
+declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs>): PausableReadResult<ApySample[]>;
 
 type UseSpokeArgs = SpokeRequest;
 /**
@@ -1044,280 +1149,759 @@ declare function useSpokeUserPositionManagers(args: Pausable<UseSpokeUserPositio
  * });
  * ```
  */
-declare function useSpokeUserPositionManagers(args: UseSpokeUserPositionManagersArgs): ReadResult<PaginatedSpokeUserPositionManagerResult>;
+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 UseTokenSwapQuoteArgs = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useTokenSwapQuote({
+ *   market: {
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useTokenSwapQuote({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useTokenSwapQuote({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useTokenSwapQuote({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * Low-level hook to execute a swap quote action directly.
+ *
+ * @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 }] = useTokenSwapQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   market: {
+ *     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 useTokenSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<TokenSwapQuoteRequest, SwapQuote, UnexpectedError$1>;
+type UseSwappableTokensArgs = SwappableTokensRequest;
+/**
+ * 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[]>;
+/**
+ * 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[]>;
+/**
+ * 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[]>;
+/**
+ * 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 & TimeWindowQueryOptions>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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>;
+/**
+ * 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 UseSwapStatusArgs = Prettify<SwapStatusRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
+/**
+ * Monitor the status of a single swap operation in real-time.
+ *
+ * Polls automatically until the swap reaches a terminal state (fulfilled, cancelled, or expired).
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSwapStatus(args: UseSwapStatusArgs & Suspendable): SuspenseResult<SwapStatus>;
+/**
+ * Monitor the status of a single swap operation in real-time.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   suspense: true,
+ *   pause: shouldPause,
+ * });
+ * ```
+ */
+declare function useSwapStatus(args: Pausable<UseSwapStatusArgs> & Suspendable): PausableSuspenseResult<SwapStatus>;
+/**
+ * Monitor the status of a single swap operation in real-time.
+ *
+ * Polls automatically until the swap reaches a terminal state (fulfilled, cancelled, or expired).
+ *
+ * ```tsx
+ * const { data, error, loading } = useSwapStatus({
+ *   id: swapReceipt.id,
+ * });
+ * ```
+ */
+declare function useSwapStatus(args: UseSwapStatusArgs): ReadResult<SwapStatus>;
+/**
+ * Monitor the status of a single swap operation in real-time.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   pause: shouldPause,
+ * });
+ * ```
+ */
+declare function useSwapStatus(args: Pausable<UseSwapStatusArgs>): PausableReadResult<SwapStatus>;
+type UseSupplySwapQuoteArgs = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a quote for a supply swap operation with the specified parameters.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSupplySwapQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSupplySwapQuote(args: UseSupplySwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a supply swap operation with the specified parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSupplySwapQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSupplySwapQuote(args: Pausable<UseSupplySwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a supply swap operation with the specified parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSupplySwapQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useSupplySwapQuote(args: UseSupplySwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a quote for a supply swap operation with the specified parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSupplySwapQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSupplySwapQuote(args: Pausable<UseSupplySwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * Low-level hook to execute a supply swap quote action directly.
+ *
+ * @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.
+ *
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useSupplySwapQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   sellPosition: userSupplyItem.id,
+ *   buyReserve: reserve.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Supply swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useSupplySwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<SupplySwapQuoteRequest, SwapQuote, UnexpectedError$1>;
+type UseBorrowSwapQuoteArgs = Prettify<BorrowSwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a quote for a borrow swap operation with the specified parameters.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a borrow swap operation with the specified parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a borrow swap operation with the specified parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a quote for a borrow swap operation with the specified parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * Low-level hook to execute a borrow swap quote action directly.
+ *
+ * @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.
+ *
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useBorrowSwapQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   debtPosition: userBorrowItem.id,
+ *   buyReserve: reserve.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Borrow swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useBorrowSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<BorrowSwapQuoteRequest, SwapQuote, UnexpectedError$1>;
+type SwapHandlerOptions = {
+    cancel: CancelOperation;
+};
+/**
+ */
+type UseSwapSignerRequest = TransactionRequest;
+/**
+ */
+type SwapSignerError = CancelError | SigningError | UnexpectedError$1;
+/**
+ */
+type UseSwapSignerResult = UseAsyncTask<UseSwapSignerRequest, PendingTransaction | Signature, SwapSignerError>;
+type PositionSwapPlan = PositionSwapApproval | SwapTypedData;
+type PositionSwapHandler = (plan: PositionSwapPlan, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
+type PositionSwapValue = {
+    quote?: SwapQuote;
+};
+/**
+ */
+type UseSupplySwapRequest = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * 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>;
+declare function useSupplySwap(handler: PositionSwapHandler): UseAsyncTask<SupplySwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ */
+type UseBorrowSwapRequest = Prettify<BorrowSwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ */
+declare function useBorrowSwap(handler: PositionSwapHandler): UseAsyncTask<BorrowSwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+type UseRepayWithSupplyQuoteArgs = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a quote for a repay with supply operation with the specified 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,
+ * const { data } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  * });
  * ```
  */
-declare function useSwapQuote(args: UseSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a repay with supply operation with the specified 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...'),
+ * const { data } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  *   pause: true,
  * });
  * ```
  */
-declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * ```tsx
- * const { data, error, loading } = useSwapQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
- *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
+ * const { data, error, loading } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  * });
  * ```
  */
-declare function useSwapQuote(args: UseSwapQuoteArgs): ReadResult<SwapQuote>;
+declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs): ReadResult<SwapQuote>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a repay with supply operation with the specified 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...'),
+ * const { data, error, loading, paused } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   pause: true,
  * });
  * ```
  */
-declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs>): PausableReadResult<SwapQuote>;
 /**
- * @internal
- * Low-level hook to execute a swap quote action directly.
+ * Low-level hook to execute a repay with supply 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).
+ * Use this hook to retrieve quotes on demand as part of a larger workflow.
  *
  * ```ts
- * const [getQuote, { called, data, error, loading }] = useSwapQuoteAction();
+ * const [getQuote, { called, data, error, loading }] = useRepayWithSupplyQuoteAction();
  *
  * // …
  *
  * const result = await getQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   repayWithReserve: reserve.id,
+ *   debtPosition: userBorrowItem.id,
  *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
+ *   user: evmAddress('0x742d35cc…'),
  * });
  *
  * if (result.isOk()) {
- *   console.log('Swap quote:', result.value);
+ *   console.log('Repay with supply quote:', result.value);
  * } else {
  *   console.error(result.error);
  * }
  * ```
  */
-declare function useSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<SwapQuoteRequest, SwapQuote, UnexpectedError$1>;
-type UseSwappableTokensArgs = SwappableTokensRequest;
+declare function useRepayWithSupplyQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapQuote, UnexpectedError$1>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
+ */
+type UseRepayWithSupplyRequest = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
+/**
+ */
+declare function useRepayWithSupply(handler: PositionSwapHandler): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+type UseWithdrawSwapQuoteArgs = Prettify<WithdrawSwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a quote for a withdraw swap operation with the specified parameters.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * const { data } = useWithdrawSwapQuote({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  * });
  * ```
  */
-declare function useSwappableTokens(args: UseSwappableTokensArgs & Suspendable): SuspenseResult<Token[]>;
+declare function useWithdrawSwapQuote(args: UseWithdrawSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
+ * Fetch a quote for a withdraw swap operation with the specified parameters.
  *
  * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * const { data } = useWithdrawSwapQuote({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  *   pause: true,
  * });
  * ```
  */
-declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs> & Suspendable): PausableSuspenseResult<Token[]>;
+declare function useWithdrawSwapQuote(args: Pausable<UseWithdrawSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
+ * Fetch a quote for a withdraw swap operation with the specified parameters.
  *
  * ```tsx
- * const { data, error, loading } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * const { data, error, loading } = useWithdrawSwapQuote({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  * });
  * ```
  */
-declare function useSwappableTokens(args: UseSwappableTokensArgs): ReadResult<Token[]>;
+declare function useWithdrawSwapQuote(args: UseWithdrawSwapQuoteArgs): ReadResult<SwapQuote>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
+ * Fetch a quote for a withdraw swap operation with the specified parameters.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * const { data, error, loading, paused } = useWithdrawSwapQuote({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   pause: true,
  * });
  * ```
  */
-declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs>): PausableReadResult<Token[]>;
-type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions>;
+declare function useWithdrawSwapQuote(args: Pausable<UseWithdrawSwapQuoteArgs>): PausableReadResult<SwapQuote>;
 /**
- * @internal
- * Fetch the user's swap history for a specific chain.
+ * Low-level hook to execute a withdraw swap quote action directly.
  *
- * This signature supports React Suspense:
+ * @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.
  *
- * ```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.
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useWithdrawSwapQuoteAction();
  *
- * Pausable suspense mode.
+ * // …
  *
- * ```tsx
- * const { data } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
- *   suspense: true,
- *   pause: true,
+ * const result = await getQuote({
+ *   position: userSupplyItem.id,
+ *   buyReserve: reserve.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
  * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Withdraw swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
  * ```
  */
-declare function useUserSwaps(args: Pausable<UseUserSwapsArgs> & Suspendable): PausableSuspenseResult<PaginatedUserSwapsResult>;
+declare function useWithdrawSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<WithdrawSwapQuoteRequest, SwapQuote, UnexpectedError$1>;
 /**
- * @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>;
+type UseWithdrawSwapRequest = Prettify<WithdrawSwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * @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>;
+declare function useWithdrawSwap(handler: PositionSwapHandler): UseAsyncTask<WithdrawSwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+type UseTokenSwapRequest = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
+type TokenSwapPlan = SwapTypedData | Erc20Approval | SwapTransactionRequest;
+type TokenSwapHandler = (plan: TokenSwapPlan, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
 /**
- * @internal
  * Orchestrate the swap execution plan.
  *
  * ```tsx
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- * const [signSwapByIntentWith, signing] = useSignSwapByIntentWith(wallet);
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * const [swap, swapping] = useSwapTokens((plan) => {
+ * const [swap, { loading, error }] = useTokenSwap((plan) => {
  *   switch (plan.__typename) {
- *     case 'SwapByIntentTypedData':
- *       return signSwapByIntentWith(plan);
- *
- *     case 'SwapApprovalRequired':
- *     case 'SwapByIntentWithApprovalRequired':
- *       return sendTransaction(plan.transaction);
+ *     case 'Erc20Approval':
+ *       if (plan.bySignature) {
+ *         return signTypedData(plan.bySignature);
+ *       }
+ *       return sendTransaction(plan.byTransaction);
  *
  *     case 'SwapTransactionRequest':
  *       return sendTransaction(plan.transaction);
+ *
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
  *   }
  * });
  *
  * 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...'),
+ *   fromQuote: {
+ *     quoteId: quote.quoteId,
  *   },
  * });
  *
@@ -1329,32 +1913,31 @@ type SwapHandler = (intent: SwapIntent, options: SwapHandlerOptions) => ResultAs
  * // 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 function useTokenSwap(handler: TokenSwapHandler): UseAsyncTask<UseTokenSwapRequest, SwapReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+type CancelSwapHandler = (data: SwapTypedData | TransactionRequest, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
 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 [signTypedData] = useSignTypedData(wallet);
  *
- * const [cancelSwap, {loading, error}] = useCancelSwap((plan: CancelSwapTypedData | TransactionRequest) => {
+ * const [cancelSwap, { loading, error }] = useCancelSwap((plan) => {
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
  *
- *     case 'CancelSwapTypedData':
- *       return signSwapCancelWith(plan);
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
  *   }
  * });
  *
  * const result = await cancelSwap({
- *   id: swapId('123...'),
+ *   id: swapId('123…'),
  * });
  *
  * if (result.isErr()) {
@@ -1377,7 +1960,10 @@ declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<Prepare
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1421,7 +2007,7 @@ declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<Prepare
  *
  * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+declare function useSupply(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<SupplyRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
  * A hook that provides a way to borrow assets from an Aave reserve.
  *
@@ -1431,7 +2017,7 @@ declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequ
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1475,7 +2061,7 @@ declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequ
  *
  * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+declare function useBorrow(handler: ExecutionPlanHandler<TransactionRequest | PreContractActionRequired, PendingTransaction>): UseAsyncTask<BorrowRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
  * A hook that provides a way to repay borrowed assets to an Aave reserve.
  *
@@ -1485,7 +2071,10 @@ declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequ
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1529,7 +2118,7 @@ declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequ
  *
  * @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>>;
+declare function useRepay(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<RepayRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
  * A hook that provides a way to withdraw supplied assets from an Aave reserve.
  *
@@ -1539,7 +2128,7 @@ declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayReques
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1583,7 +2172,7 @@ declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayReques
  *
  * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useWithdraw(handler: TransactionHandler): UseAsyncTask<WithdrawRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+declare function useWithdraw(handler: ExecutionPlanHandler<TransactionRequest | PreContractActionRequired, PendingTransaction>): UseAsyncTask<WithdrawRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
  * A hook that provides a way to renounce a position manager of a user for a specific spoke.
  *
@@ -1625,64 +2214,23 @@ declare function useWithdraw(handler: TransactionHandler): UseAsyncTask<Withdraw
  *
  * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useRenounceSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function useRenounceSpokeUserPositionManager(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
 /**
- * A hook that provides a way to update the user risk premium for a spoke.
+ * Hook for updating user position conditions (dynamic config and/or risk premium).
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [updateUserRiskPremium, { loading, error }] = useUpdateUserRiskPremium((transaction, { cancel }) => {
+ * const [update, { loading, error }] = useUpdateUserPositionConditions((transaction, { cancel }) => {
  *   return sendTransaction(transaction);
  * });
  *
  * // …
  *
- * 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;
- * }
- *
- * console.log('Transaction sent with hash:', result.value);
- * ```
- *
- * @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 update({
+ *   userPositionId: userPosition.id,
+ *   update: UserPositionConditionsUpdate.AllDynamicConfig,
  * });
  *
- * // …
- *
- * const result = await updateUserDynamicConfig({ ... });
- *
  * if (result.isErr()) {
  *   switch (result.error.name) {
  *     case 'CancelError':
@@ -1713,20 +2261,24 @@ declare function useUpdateUserRiskPremium(handler: TransactionHandler): UseAsync
  *
  * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useUpdateUserDynamicConfig(handler: TransactionHandler): UseAsyncTask<UpdateUserDynamicConfigRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function useUpdateUserPositionConditions(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<UpdateUserPositionConditionsRequest, TxHash, SendTransactionError | PendingTransactionError>;
 /**
- * Hook for setting whether a user's supply should be used as collateral.
+ * Hook for updating the collateral status of user's supplies.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [setUserSupplyAsCollateral, { loading, error }] = useSetUserSupplyAsCollateral((transaction, { cancel }) => {
+ * const [setUserSuppliesAsCollateral, { loading, error }] = useSetUserSuppliesAsCollateral((transaction, { cancel }) => {
  *   return sendTransaction(transaction);
  * });
  *
- * const result = await setUserSupplyAsCollateral({
- *   reserve: reserveId('SGVsbG8h'),
- *   sender: evmAddress('0x456...'),
- *   enableCollateral: true,
+ * const result = await setUserSuppliesAsCollateral({
+ *   changes: [
+ *     {
+ *       reserve: reserve.id,
+ *       enableCollateral: true
+ *     }
+ *   ],
+ *   sender: evmAddress('0x456...')
  * });
  *
  * if (result.isErr()) {
@@ -1759,7 +2311,7 @@ declare function useUpdateUserDynamicConfig(handler: TransactionHandler): UseAsy
  *
  * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useSetUserSupplyAsCollateral(handler: TransactionHandler): UseAsyncTask<SetUserSupplyAsCollateralRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function useSetUserSuppliesAsCollateral(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetUserSuppliesAsCollateralRequest, TxHash, SendTransactionError | PendingTransactionError>;
 /**
  * A hook that provides a way to liquidate a user's position.
  *
@@ -1769,7 +2321,10 @@ declare function useSetUserSupplyAsCollateral(handler: TransactionHandler): UseA
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1819,7 +2374,7 @@ declare function useSetUserSupplyAsCollateral(handler: TransactionHandler): UseA
  *
  * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useLiquidatePosition(handler: TransactionHandler): UseAsyncTask<LiquidatePositionRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+declare function useLiquidatePosition(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, PendingTransaction>): UseAsyncTask<LiquidatePositionRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
 /**
  * A hook that provides a way to set or remove a position manager for a user on a specific spoke.
  *
@@ -1881,7 +2436,7 @@ declare function useLiquidatePosition(handler: TransactionHandler): UseAsyncTask
  *
  * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useSetSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<SetSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function useSetSpokeUserPositionManager(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
 /**
  * Preview the impact of a potential action on a user's position.
  *
@@ -2011,7 +2566,7 @@ declare function usePreview(args: UsePreviewArgs): ReadResult<PreviewUserPositio
  * ```
  */
 declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
-type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions>;
+type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch paginated list of activities.
  *
@@ -2093,9 +2648,9 @@ declare function useActivities(args: Pausable<UseActivitiesArgs>): PausableReadR
  * @param options - The query options.
  * @returns The user history.
  */
-declare function useActivitiesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
+declare function useActivitiesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
 
-type UseUserSuppliesArgs = Prettify<UserSuppliesRequest & CurrencyQueryOptions>;
+type UseUserSuppliesArgs = Prettify<UserSuppliesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch all user supply positions.
  *
@@ -2208,8 +2763,8 @@ declare function useUserSupplies(args: Pausable<UseUserSuppliesArgs>): PausableR
  * }
  * ```
  */
-declare function useUserSuppliesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<UserSuppliesRequest, UserSupplyItem[], UnexpectedError>;
-type UseUserBorrowsArgs = Prettify<UserBorrowsRequest & CurrencyQueryOptions>;
+declare function useUserSuppliesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<UserSuppliesRequest, UserSupplyItem[], UnexpectedError>;
+type UseUserBorrowsArgs = Prettify<UserBorrowsRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch all user borrow positions.
  *
@@ -2315,7 +2870,7 @@ declare function useUserBorrows(args: Pausable<UseUserBorrowsArgs>): PausableRea
  * }
  * ```
  */
-declare function useUserBorrowsAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<UserBorrowsRequest, UserBorrowItem[], UnexpectedError>;
+declare function useUserBorrowsAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<UserBorrowsRequest, UserBorrowItem[], UnexpectedError>;
 type UseUserSummaryArgs = Prettify<UserSummaryRequest & TimeWindowQueryOptions & CurrencyQueryOptions>;
 /**
  * Fetch a user's financial summary.
@@ -2578,6 +3133,69 @@ declare function useUserBalances(args: UseUserBalancesArgs): ReadResult<UserBala
  * ```
  */
 declare function useUserBalances(args: Pausable<UseUserBalancesArgs>): PausableReadResult<UserBalance[]>;
+type UseUserRiskPremiumBreakdownArgs = UserRiskPremiumBreakdownRequest;
+/**
+ * Fetch the risk premium breakdown for a user position or spoke.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserRiskPremiumBreakdown({
+ *   query: {
+ *     userPositionId: userPositionId('SGVsbG8h'),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserRiskPremiumBreakdown(args: UseUserRiskPremiumBreakdownArgs & Suspendable): SuspenseResult<UserRiskPremiumBreakdownItem[]>;
+/**
+ * Fetch the risk premium breakdown for a user position or spoke.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserRiskPremiumBreakdown({
+ *   query: {
+ *     userPositionId: userPositionId('SGVsbG8h'),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserRiskPremiumBreakdown(args: Pausable<UseUserRiskPremiumBreakdownArgs> & Suspendable): PausableSuspenseResult<UserRiskPremiumBreakdownItem[]>;
+/**
+ * Fetch the risk premium breakdown for a user position or spoke.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserRiskPremiumBreakdown({
+ *   query: {
+ *     userPositionId: userPositionId('SGVsbG8h'),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ * ```
+ */
+declare function useUserRiskPremiumBreakdown(args: UseUserRiskPremiumBreakdownArgs): ReadResult<UserRiskPremiumBreakdownItem[]>;
+/**
+ * Fetch the risk premium breakdown for a user position or spoke.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserRiskPremiumBreakdown({
+ *   query: {
+ *     userPositionId: userPositionId('SGVsbG8h'),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserRiskPremiumBreakdown(args: Pausable<UseUserRiskPremiumBreakdownArgs>): PausableReadResult<UserRiskPremiumBreakdownItem[]>;
 /**
  * Low-level hook to execute a {@link userBalances} action directly.
  *
@@ -2667,4 +3285,4 @@ declare function useUserSummaryHistory(args: UseUserSummaryHistoryArgs): ReadRes
  */
 declare function useUserSummaryHistory(args: Pausable<UseUserSummaryHistoryArgs>): PausableReadResult<UserSummaryHistoryItem[]>;
 
-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 };
+export { AaveProvider, type AaveProviderProps, type CancelSwapError, type CancelSwapHandler, CannotCancelSwapError, PendingTransactionError, type PositionSwapHandler, type PositionSwapPlan, type PositionSwapValue, SendTransactionError, type SwapHandlerOptions, type SwapSignerError, type TokenSwapHandler, type TokenSwapPlan, type UseActivitiesArgs, type UseAssetArgs, type UseAssetBorrowHistoryArgs, type UseAssetPriceHistoryArgs, type UseAssetSupplyHistoryArgs, UseAsyncTask, type UseBorrowApyHistoryArgs, type UseBorrowSwapQuoteArgs, type UseBorrowSwapRequest, type UseHubArgs, type UseHubAssetsArgs, type UseHubSummaryHistoryArgs, type UseHubsArgs, type UsePreviewArgs, type UseProtocolHistoryArgs, type UseRepayWithSupplyQuoteArgs, type UseRepayWithSupplyRequest, type UseReserveArgs, type UseReservesArgs, type UseSpokeArgs, type UseSpokePositionManagersArgs, type UseSpokeUserPositionManagersArgs, type UseSpokesArgs, type UseSupplyApyHistoryArgs, type UseSupplySwapQuoteArgs, type UseSupplySwapRequest, type UseSwapSignerRequest, type UseSwapSignerResult, type UseSwapStatusArgs, type UseSwappableTokensArgs, type UseTokenSwapQuoteArgs, type UseTokenSwapRequest, type UseUserBalancesArgs, type UseUserBorrowsArgs, type UseUserPositionArgs, type UseUserPositionsArgs, type UseUserRiskPremiumBreakdownArgs, type UseUserSummaryArgs, type UseUserSummaryHistoryArgs, type UseUserSuppliesArgs, type UseUserSwapsArgs, type UseWithdrawSwapQuoteArgs, type UseWithdrawSwapRequest, useAaveClient, useActivities, useActivitiesAction, useAsset, useAssetBorrowHistory, useAssetPriceHistory, useAssetSupplyHistory, useBorrow, useBorrowApyHistory, useBorrowSwap, useBorrowSwapQuote, useBorrowSwapQuoteAction, useCancelSwap, useHub, useHubAssets, useHubSummaryHistory, useHubs, useHubsAction, useLiquidatePosition, usePreview, usePreviewAction, useProtocolHistory, useRenounceSpokeUserPositionManager, useRepay, useRepayWithSupply, useRepayWithSupplyQuote, useRepayWithSupplyQuoteAction, useReserve, useReserveAction, useReserves, useReservesAction, useSetSpokeUserPositionManager, useSetUserSuppliesAsCollateral, useSpoke, useSpokePositionManagers, useSpokeUserPositionManagers, useSpokes, useSupply, useSupplyApyHistory, useSupplySwap, useSupplySwapQuote, useSupplySwapQuoteAction, useSwapStatus, useSwappableTokens, useTokenSwap, useTokenSwapQuote, useTokenSwapQuoteAction, useUpdateUserPositionConditions, useUserBalances, useUserBalancesAction, useUserBorrows, useUserBorrowsAction, useUserPosition, useUserPositions, useUserPositionsAction, useUserRiskPremiumBreakdown, useUserSummary, useUserSummaryHistory, useUserSupplies, useUserSuppliesAction, useUserSwaps, useWithdraw, useWithdrawSwap, useWithdrawSwapQuote, useWithdrawSwapQuoteAction };