@aave/react 4.0.0-next.5 → 4.0.0-next.51

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, ActivitiesRequest, PaginatedActivitiesResult, TransactionReceipt } 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, c as cancel, E as ExecutionPlanHandler } from './writes-sBt0thuG.cjs';
+export { A as AsyncTaskError, d as AsyncTaskIdle, e as AsyncTaskLoading, f as AsyncTaskState, g as AsyncTaskSuccess, T as TransactionHandlerOptions, U as UseSendTransactionResult } from './writes-sBt0thuG.cjs';
+import { HubRequest, Hub, HubsRequest, HubAssetsRequest, HubAsset, HubSummaryHistoryRequest, HubSummarySample, HubAssetInterestRateModelRequest, HubAssetInterestRateModelPoint, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, ProtocolHistoryRequest, ProtocolHistorySample, ReserveRequest, Reserve, ReservesRequest, BorrowApyHistoryRequest, ApySample, SupplyApyHistoryRequest, UserClaimableRewardsRequest, UserClaimableReward, SpokeRequest, Spoke, SpokesRequest, SpokePositionManagersRequest, PaginatedSpokePositionManagerResult, SpokeUserPositionManagersRequest, PaginatedSpokeUserPositionManagerResult, PositionSwapApproval, SwapTypedData, SwapQuote, BorrowSwapQuoteRequest, SwapReceipt, InsufficientBalanceError, InsufficientLiquidityError, TransactionRequest, PrepareSwapCancelRequest, SwapCancelledResult, RepayWithSupplyQuoteRequest, SupplySwapQuoteRequest, SwappableTokensRequest, Token, SwapStatusRequest, SwapStatus, Erc20Approval, SwapTransactionRequest, TokenSwapQuoteRequest, UserSwapsRequest, PaginatedUserSwapsResult, WithdrawSwapQuoteRequest, PreContractActionRequired, BorrowRequest, ClaimRewardsRequest, LiquidatePositionRequest, PreviewRequest, PreviewUserPosition, RenounceSpokeUserPositionManagerRequest, RepayRequest, SetSpokeUserPositionManagerRequest, SetUserSuppliesAsCollateralRequest, SupplyRequest, UpdateUserPositionConditionsRequest, WithdrawRequest, UserSuppliesRequest, UserSupplyItem, UserBorrowsRequest, UserBorrowItem, UserSummaryRequest, UserSummary, UserPositionsRequest, UserPosition, UserPositionRequest, UserBalancesRequest, UserBalance, UserRiskPremiumBreakdownRequest, UserRiskPremiumBreakdownItem, UserSummaryHistoryRequest, UserSummaryHistoryItem } from '@aave/graphql';
+import { Prettify, ResultAsync, Signature, ResultAwareError } from '@aave/types';
+import { S as Suspendable, a as SuspenseResult, P as Pausable, b as PausableSuspenseResult, R as ReadResult, c as PausableReadResult } from './misc-CLtLR-vZ.cjs';
+export { d as UseChainArgs, f as UseChainsArgs, i as UseExchangeRateArgs, U as UseNetworkFee, l as UseNetworkFeeArgs, k as UseNetworkFeeRequestQuery, u as useChain, e as useChainAction, g as useChains, j as useExchangeRate, h as useExchangeRateAction } from './misc-CLtLR-vZ.cjs';
+import { CancelError, SigningError, UnexpectedError as UnexpectedError$1, ValidationError, TimeoutError, TransactionError } 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,137 @@ 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[]>;
+type UseHubAssetInterestRateModelArgs = Prettify<HubAssetInterestRateModelRequest & CurrencyQueryOptions>;
+/**
+ * Fetch the interest rate model for a specific hub asset.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useHubAssetInterestRateModel({
+ *   query: { hubAssetId: hubAssetId('...') },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useHubAssetInterestRateModel(args: UseHubAssetInterestRateModelArgs & Suspendable): SuspenseResult<HubAssetInterestRateModelPoint[]>;
+/**
+ * Fetch the interest rate model for a specific hub asset.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useHubAssetInterestRateModel({
+ *   query: { hubAssetId: hubAssetId('...') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubAssetInterestRateModel(args: Pausable<UseHubAssetInterestRateModelArgs> & Suspendable): PausableSuspenseResult<HubAssetInterestRateModelPoint[]>;
+/**
+ * Fetch the interest rate model for a specific hub asset.
+ *
+ * ```tsx
+ * const { data, error, loading } = useHubAssetInterestRateModel({
+ *   query: { hubAssetId: hubAssetId('...') },
+ * });
+ * ```
+ */
+declare function useHubAssetInterestRateModel(args: UseHubAssetInterestRateModelArgs): ReadResult<HubAssetInterestRateModelPoint[]>;
+/**
+ * Fetch the interest rate model for a specific hub asset.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useHubAssetInterestRateModel({
+ *   query: { hubAssetId: hubAssetId('...') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubAssetInterestRateModel(args: Pausable<UseHubAssetInterestRateModelArgs>): PausableReadResult<HubAssetInterestRateModelPoint[]>;
+/**
+ * Low-level hook to execute a {@link hubAssetInterestRateModel} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data.
+ * Use this hook to retrieve data on demand as part of a larger workflow.
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useHubAssetInterestRateModelAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   query: { hubAssetId: hubAssetId('...') },
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // HubAssetInterestRateModelPoint[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useHubAssetInterestRateModelAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<HubAssetInterestRateModelRequest, HubAssetInterestRateModelPoint[], UnexpectedError>;
 /**
  * Low-level hook to execute a {@link hubs} action directly.
  *
@@ -237,11 +368,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 +476,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 +529,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 +582,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,18 +718,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 & {
-    /**
-     * 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>;
-}>;
+declare function useReserveAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ReserveRequest, Reserve | null, UnexpectedError>;
+type UseReservesArgs = Prettify<ReservesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch reserves based on specified criteria.
  *
@@ -567,36 +738,8 @@ type UseReservesArgs<T = Reserve[]> = Prettify<ReservesRequest & CurrencyQueryOp
  *   suspense: true,
  * });
  * ```
- *
- * **Reserves with Highest Supply APY**
- * ```tsx
- * const { data } = useReserves({
- *   query: {
- *     spoke: {
- *       address: evmAddress('0x123...'),
- *       chainId: chainId(1)
- *     }
- *   },
- *   suspense: true,
- *   selector: pickHighestSupplyApyReserve,
- * });
- * ```
- *
- * **Reserves with Lowest Borrow APY**
- * ```tsx
- * const { data } = useReserves({
- *   query: {
- *     spoke: {
- *       address: evmAddress('0x123...'),
- *       chainId: chainId(1)
- *     }
- *   },
- *   suspense: true,
- *   selector: pickLowestBorrowApyReserve,
- * });
- * ```
  */
-declare function useReserves<T = Reserve[]>(args: UseReservesArgs<T> & Suspendable): SuspenseResult<T>;
+declare function useReserves(args: UseReservesArgs & Suspendable): SuspenseResult<Reserve[]>;
 /**
  * Fetch reserves based on specified criteria.
  *
@@ -615,7 +758,7 @@ declare function useReserves<T = Reserve[]>(args: UseReservesArgs<T> & Suspendab
  * });
  * ```
  */
-declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>> & Suspendable): PausableSuspenseResult<T>;
+declare function useReserves(args: Pausable<UseReservesArgs> & Suspendable): PausableSuspenseResult<Reserve[]>;
 /**
  * Fetch reserves based on specified criteria.
  *
@@ -631,34 +774,8 @@ declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>> &
  *   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>;
+declare function useReserves(args: UseReservesArgs): ReadResult<Reserve[], UnexpectedError>;
 /**
  * Fetch reserves based on specified criteria.
  *
@@ -676,7 +793,7 @@ declare function useReserves<T = Reserve[]>(args: UseReservesArgs<T>): ReadResul
  * });
  * ```
  */
-declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>>): PausableReadResult<T>;
+declare function useReserves(args: Pausable<UseReservesArgs>): PausableReadResult<Reserve[], UnexpectedError>;
 /**
  * Low-level hook to execute a {@link reserves} action directly.
  *
@@ -706,39 +823,9 @@ declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>>):
  *   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;
+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 +839,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 +854,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 +865,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 +879,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 +894,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 +909,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 +920,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,79 +934,157 @@ 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;
+type UseUserClaimableRewardsArgs = Prettify<UserClaimableRewardsRequest>;
 /**
- * Fetch a specific spoke.
+ * Fetch all claimable rewards for a user.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useSpoke({
- *   query: { spokeId: spokeId('SGVsbG8h') },
+ * const { data } = useUserClaimableRewards({
+ *   user: evmAddress('0x742d35cc…'),
  *   suspense: true,
  * });
- * // data will be Spoke | null
  * ```
  */
-declare function useSpoke(args: UseSpokeArgs & Suspendable): SuspenseResult<Spoke | null>;
+declare function useUserClaimableRewards(args: UseUserClaimableRewardsArgs & Suspendable): SuspenseResult<UserClaimableReward[]>;
 /**
- * Fetch a specific spoke.
+ * Fetch all claimable rewards for a user.
  *
  * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useSpoke({
- *   query: { spokeId: spokeId('SGVsbG8h') },
+ * const { data } = useUserClaimableRewards({
+ *   user: evmAddress('0x742d35cc…'),
  *   suspense: true,
  *   pause: true,
  * });
  * ```
  */
-declare function useSpoke(args: Pausable<UseSpokeArgs> & Suspendable): PausableSuspenseResult<Spoke | null>;
+declare function useUserClaimableRewards(args: Pausable<UseUserClaimableRewardsArgs> & Suspendable): PausableSuspenseResult<UserClaimableReward[]>;
 /**
- * Fetch a specific spoke.
+ * Fetch all claimable rewards for a user.
  *
  * ```tsx
- * const { data, error, loading } = useSpoke({
- *   query: { spokeId: spokeId('SGVsbG8h') },
+ * const { data, error, loading } = useUserClaimableRewards({
+ *   user: evmAddress('0x742d35cc…'),
  * });
- * // data will be Spoke | null
  * ```
  */
-declare function useSpoke(args: UseSpokeArgs): ReadResult<Spoke | null>;
+declare function useUserClaimableRewards(args: UseUserClaimableRewardsArgs): ReadResult<UserClaimableReward[]>;
 /**
- * Fetch a specific spoke.
+ * Fetch all claimable rewards for a user.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useSpoke({
- *   query: { spokeId: spokeId('SGVsbG8h') },
+ * const { data, error, loading, paused } = useUserClaimableRewards({
+ *   user: evmAddress('0x742d35cc…'),
  *   pause: true,
  * });
  * ```
  */
-declare function useSpoke(args: Pausable<UseSpokeArgs>): PausableReadResult<Spoke | null>;
-type UseSpokesArgs = SpokesRequest;
+declare function useUserClaimableRewards(args: Pausable<UseUserClaimableRewardsArgs>): PausableReadResult<UserClaimableReward[]>;
 /**
- * Fetch spokes based on specified criteria.
+ * Low-level hook to execute a {@link userClaimableRewards} 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 claimable rewards.
+ * 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 } = useSpokes({
- *   query: { chainIds: [chainId(1)] },
- *   suspense: true,
- * });
- * ```
- */
-declare function useSpokes(args: UseSpokesArgs & Suspendable): SuspenseResult<Spoke[]>;
-/**
- * Fetch spokes based on specified criteria.
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserClaimableRewardsAction();
  *
- * Pausable suspense mode.
+ * // …
+ *
+ * const result = await execute({
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserClaimableReward[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useUserClaimableRewardsAction(): UseAsyncTask<UserClaimableRewardsRequest, UserClaimableReward[], UnexpectedError>;
+
+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({
@@ -1060,264 +1225,809 @@ declare function useSpokeUserPositionManagers(args: UseSpokeUserPositionManagers
  */
 declare function useSpokeUserPositionManagers(args: Pausable<UseSpokeUserPositionManagersArgs>): PausableReadResult<PaginatedSpokeUserPositionManagerResult>;
 
-type UseSwapQuoteArgs = Prettify<SwapQuoteRequest & CurrencyQueryOptions>;
+type SwapHandlerOptions = {
+    cancel: CancelOperation;
+};
+type SwapSignerError = CancelError | SigningError | UnexpectedError$1;
+type PositionSwapPlan = PositionSwapApproval | SwapTypedData;
+type PositionSwapHandler = (plan: PositionSwapPlan, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
+type PositionSwapValue = {
+    quote?: SwapQuote;
+};
+
+type UseBorrowSwapRequest = Prettify<BorrowSwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * Orchestrate the borrow swap execution plan.
+ *
+ * ```tsx
+ * const [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [swapBorrow, { loading, error }] = useBorrowSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
+ *
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
+ * });
+ *
+ * const result = await swapBorrow({
+ *   market: {
+ *     debtPosition: userBorrowItem.id,
+ *     buyReserve: targetReserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
+ * ```
+ */
+declare function useBorrowSwap(handler: PositionSwapHandler): UseAsyncTask<BorrowSwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+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 } = useSwapQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
- *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
+ * const { data } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  * });
  * ```
  */
-declare function useSwapQuote(args: UseSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a borrow swap 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 } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  *   pause: true,
  * });
  * ```
  */
-declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a borrow swap 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 } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  * });
  * ```
  */
-declare function useSwapQuote(args: UseSwapQuoteArgs): ReadResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs): ReadResult<SwapQuote>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * Fetch a quote for a borrow swap 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 } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   pause: true,
  * });
  * ```
  */
-declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs>): PausableReadResult<SwapQuote>;
 /**
- * @internal
- * Low-level hook to execute a swap quote action directly.
+ * Low-level hook to execute a borrow 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).
+ * 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 }] = useBorrowSwapQuoteAction();
  *
  * // …
  *
  * const result = await getQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   debtPosition: userBorrowItem.id,
+ *   buyReserve: reserve.id,
  *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
+ *   user: evmAddress('0x742d35cc…'),
  * });
  *
  * if (result.isOk()) {
- *   console.log('Swap quote:', result.value);
+ *   console.log('Borrow swap quote:', result.value);
  * } else {
  *   console.error(result.error);
  * }
  * ```
  */
-declare function useSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<SwapQuoteRequest, SwapQuote, UnexpectedError$1>;
-type UseSwappableTokensArgs = SwappableTokensRequest;
+declare function useBorrowSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<BorrowSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type CancelSwapHandler = (data: SwapTypedData | TransactionRequest, options: {
+    cancel: typeof cancel;
+}) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
+declare class CannotCancelSwapError extends ResultAwareError {
+    name: "CannotCancelSwapError";
+}
+type CancelSwapError = CancelError | CannotCancelSwapError | SigningError | TimeoutError | TransactionError | UnexpectedError$1;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
- *
- * This signature supports React Suspense:
+ * Executes the complete swap cancellation workflow combining preparation and execution.
  *
  * ```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.
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * Pausable suspense mode.
+ * const [cancelSwap, { loading, error }] = useCancelSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
  *
- * ```tsx
- * const { data } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
- *   suspense: true,
- *   pause: true,
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
  * });
- * ```
- */
-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)] },
+ * const result = await cancelSwap({
+ *   id: swapId('123…'),
  * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapCancelledResult
+ * console.log('Swap cancelled:', result.value);
  * ```
  */
-declare function useSwappableTokens(args: UseSwappableTokensArgs): ReadResult<Token[]>;
+declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelledResult, CancelSwapError>;
+
+type UseRepayWithSupplyRequest = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
- *
- * Pausable loading state mode.
+ * Orchestrate the repay with supply execution plan.
  *
  * ```tsx
- * const { data, error, loading, paused } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
- *   pause: true,
+ * const [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [repayWithSupply, { loading, error }] = useRepayWithSupply((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
+ *
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
+ * });
+ *
+ * const result = await repayWithSupply({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
  * ```
  */
-declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs>): PausableReadResult<Token[]>;
-type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions>;
+declare function useRepayWithSupply(handler: PositionSwapHandler): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+type UseRepayWithSupplyQuoteArgs = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
 /**
- * @internal
- * Fetch the user's swap history for a specific chain.
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * const { data } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  * });
  * ```
  */
-declare function useUserSwaps(args: UseUserSwapsArgs & Suspendable): SuspenseResult<PaginatedUserSwapsResult>;
+declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch the user's swap history for a specific chain.
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * const { data } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   suspense: true,
  *   pause: true,
  * });
  * ```
  */
-declare function useUserSwaps(args: Pausable<UseUserSwapsArgs> & Suspendable): PausableSuspenseResult<PaginatedUserSwapsResult>;
+declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch the user's swap history for a specific chain.
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * ```tsx
- * const { data, error, loading } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * const { data, error, loading } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  * });
  * ```
  */
-declare function useUserSwaps(args: UseUserSwapsArgs): ReadResult<PaginatedUserSwapsResult>;
+declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs): ReadResult<SwapQuote>;
 /**
- * @internal
- * Fetch the user's swap history for a specific chain.
+ * Fetch a quote for a repay with supply operation with the specified parameters.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useUserSwaps({
- *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
- *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * const { data, error, loading, paused } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   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 useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs>): PausableReadResult<SwapQuote>;
 /**
- * @internal
- * Orchestrate the swap execution plan.
+ * Low-level hook to execute a repay with supply 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 }] = useRepayWithSupplyQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   repayWithReserve: reserve.id,
+ *   debtPosition: userBorrowItem.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Repay with supply quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useRepayWithSupplyQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type UseSupplySwapRequest = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Orchestrate the supply swap execution plan.
  *
  * ```tsx
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- * const [signSwapByIntentWith, signing] = useSignSwapByIntentWith(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * const [swap, swapping] = useSwapTokens((plan) => {
+ * const [swapSupply, { loading, error }] = useSupplySwap((plan) => {
  *   switch (plan.__typename) {
- *     case 'SwapByIntentTypedData':
- *       return signSwapByIntentWith(plan);
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
  *
- *     case 'SwapApprovalRequired':
- *     case 'SwapByIntentWithApprovalRequired':
- *       return sendTransaction(plan.transaction);
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
+ * });
+ *
+ * const result = await swapSupply({
+ *   market: {
+ *     sellPosition: supplyPosition.id,
+ *     buyReserve: targetReserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *     enableCollateral: true,
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
+ * ```
+ */
+declare function useSupplySwap(handler: PositionSwapHandler): UseAsyncTask<SupplySwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+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 | ValidationError<InsufficientLiquidityError>>;
+
+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 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 UseTokenSwapRequest = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
+type TokenSwapPlan = SwapTypedData | Erc20Approval | SwapTransactionRequest;
+type TokenSwapHandler = (plan: TokenSwapPlan, options: SwapHandlerOptions) => ResultAsync<PendingTransaction | Signature, SwapSignerError>;
+/**
+ * Orchestrate the token swap execution plan.
+ *
+ * ```tsx
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [swap, { loading, error }] = useTokenSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     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({
+ *   fromQuote: {
+ *     quoteId: quote.quoteId,
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
+ * ```
+ */
+declare function useTokenSwap(handler: TokenSwapHandler): UseAsyncTask<UseTokenSwapRequest, SwapReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+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...') },
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
  *     amount: bigDecimal('1000'),
- *     kind: SwapKind.SELL,
- *     user: evmAddress('0x742d35cc...'),
+ *     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 | ValidationError<InsufficientLiquidityError>>;
+
+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 UseWithdrawSwapRequest = Prettify<WithdrawSwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Orchestrate the withdraw swap execution plan.
+ *
+ * ```tsx
+ * const [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [withdrawSwap, { loading, error }] = useWithdrawSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
+ *
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
+ * });
+ *
+ * const result = await withdrawSwap({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyToken: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
  *   },
  * });
  *
@@ -1329,99 +2039,191 @@ 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 class CannotCancelSwapError extends ResultAwareError {
-    name: "CannotCancelSwapError";
-}
-type CancelSwapError = CancelError | CannotCancelSwapError | SigningError | TimeoutError | TransactionError | UnexpectedError$1;
+declare function useWithdrawSwap(handler: PositionSwapHandler): UseAsyncTask<WithdrawSwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+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 } = useWithdrawSwapQuote({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useWithdrawSwapQuote(args: UseWithdrawSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a withdraw swap operation with the specified parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useWithdrawSwapQuote({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useWithdrawSwapQuote(args: Pausable<UseWithdrawSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a withdraw swap operation with the specified parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useWithdrawSwapQuote({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useWithdrawSwapQuote(args: UseWithdrawSwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a quote for a withdraw swap operation with the specified parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useWithdrawSwapQuote({
+ *   market: {
+ *     position: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useWithdrawSwapQuote(args: Pausable<UseWithdrawSwapQuoteArgs>): PausableReadResult<SwapQuote>;
 /**
- * @internal
- * Executes the complete swap cancellation workflow combining preparation and execution.
+ * Low-level hook to execute a withdraw swap quote action directly.
  *
- * ```tsx
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [signSwapCancelWith] = useSignSwapCancelWith(wallet);
+ * @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.
  *
- * const [cancelSwap, {loading, error}] = useCancelSwap((plan: CancelSwapTypedData | TransactionRequest) => {
- *   switch (plan.__typename) {
- *     case 'TransactionRequest':
- *       return sendTransaction(plan);
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useWithdrawSwapQuoteAction();
  *
- *     case 'CancelSwapTypedData':
- *       return signSwapCancelWith(plan);
- *   }
- * });
+ * // …
  *
- * const result = await cancelSwap({
- *   id: swapId('123...'),
+ * const result = await getQuote({
+ *   position: userSupplyItem.id,
+ *   buyReserve: reserve.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
  * });
  *
- * if (result.isErr()) {
+ * if (result.isOk()) {
+ *   console.log('Withdraw swap quote:', result.value);
+ * } else {
  *   console.error(result.error);
- *   return;
  * }
- *
- * // result.value: SwapCancelled
- * console.log('Swap cancelled:', result.value);
  * ```
  */
-declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelled, CancelSwapError>;
+declare function useWithdrawSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<WithdrawSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
 
+type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
- * A hook that provides a way to supply assets to an Aave reserve.
+ * Fetch paginated list of activities.
  *
- * ```ts
- * 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);
- *   }
- * });
+ * This signature supports React Suspense:
  *
- * // …
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
  *
- * const result = await supply({ ... });
+ * // data.items: ActivityItem[]
+ * ```
+ */
+declare function useActivities(args: UseActivitiesArgs & Suspendable): SuspenseResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
  *
- * if (result.isErr()) {
- *   switch (result.error.name) {
- *     case 'CancelError':
- *       // The user cancelled the operation
- *       return;
+ * Pausable suspense mode.
  *
- *     case 'SigningError':
- *       console.error(`Failed to sign the transaction: ${result.error.message}`);
- *       break;
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
+ * });
  *
- *     case 'TimeoutError':
- *       console.error(`Transaction timed out: ${result.error.message}`);
- *       break;
+ * // data?.items: ActivityItem[] | undefined
+ * ```
+ */
+declare function useActivities(args: Pausable<UseActivitiesArgs> & Suspendable): PausableSuspenseResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
  *
- *     case 'TransactionError':
- *       console.error(`Transaction failed: ${result.error.message}`);
- *       break;
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ * ```
+ */
+declare function useActivities(args: UseActivitiesArgs): ReadResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
  *
- *     case 'ValidationError':
- *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
- *       break;
+ * Pausable loading state mode.
  *
- *     case 'UnexpectedError':
- *       console.error(result.error.message);
- *       break;
- *   }
- *   return;
- * }
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
+ * });
  *
- * console.log('Transaction sent with hash:', result.value);
+ * // 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.
  *
- * @param handler - The handler that will be used to handle the transactions.
+ * @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).
+ *
+ * @param options - The query options.
+ * @returns The user history.
  */
-declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+declare function useActivitiesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
+
 /**
  * A hook that provides a way to borrow assets from an Aave reserve.
  *
@@ -1431,7 +2233,7 @@ declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequ
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1470,30 +2272,27 @@ declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequ
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
  *
  * @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, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
- * A hook that provides a way to repay borrowed assets to an Aave reserve.
+ * A hook that provides a way to claim rewards.
  *
  * ```ts
  * 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 [claim, { loading, error }] = useClaimRewards((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
  * });
  *
  * // …
  *
- * const result = await repay({ ... });
+ * const result = await claim({
+ *   ids: [rewardId('abc123')],
+ * });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1513,10 +2312,6 @@ declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequ
  *       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;
@@ -1524,22 +2319,26 @@ declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequ
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
  *
- * @param handler - The handler that will be used to handle the transactions.
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+declare function useClaimRewards(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<ClaimRewardsRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * A hook that provides a way to withdraw supplied assets from an Aave reserve.
+ * A hook that provides a way to liquidate a user's position.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [withdraw, { loading, error }] = useWithdraw((plan, { cancel }) => {
+ * const [liquidatePosition, { loading, error }] = useLiquidatePosition((plan, { cancel }) => {
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1547,7 +2346,13 @@ declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayReques
  *
  * // …
  *
- * const result = await withdraw({ ... });
+ * const result = await liquidatePosition({
+ *   collateral: reserveId('SGVsbG8h'),
+ *   debt: reserveId('Q2lhbyE= '),
+ *   amount: amount,
+ *   liquidator: liquidator,
+ *   borrower: borrower,
+ * });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1578,156 +2383,153 @@ declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayReques
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
  *
  * @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 useLiquidatePosition(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, PendingTransaction | Signature>): UseAsyncTask<LiquidatePositionRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
- * A hook that provides a way to renounce a position manager of a user for a specific spoke.
+ * Preview the impact of a potential action on a user's position.
  *
- * ```ts
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
+ * ```tsx
+ * const [getPreview, previewing] = usePreviewAction();
+ *
+ * const loading = previewing.loading;
+ * const error = previewing.error;
  *
  * // …
  *
- * const result = await renounceSpokeUserPositionManager({ ... });
+ * const result = await getPreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           value: '1000',
+ *         },
+ *       },
+ *       sender: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
  *
  * if (result.isErr()) {
- *   switch (result.error.name) {
- *     case 'CancelError':
- *       // The user cancelled the operation
- *       return;
+ *   console.error(result.error);
+ *   return;
+ * }
  *
- *     case 'SigningError':
- *       console.error(`Failed to sign the transaction: ${result.error.message}`);
- *       break;
+ * 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.
  *
- *     case 'TimeoutError':
- *       console.error(`Transaction timed out: ${result.error.message}`);
- *       break;
+ * This signature supports React Suspense:
  *
- *     case 'TransactionError':
- *       console.error(`Transaction failed: ${result.error.message}`);
- *       break;
+ * ```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.
  *
- *     case 'UnexpectedError':
- *       console.error(result.error.message);
- *       break;
- *   }
- *   return;
- * }
+ * Pausable suspense mode.
  *
- * console.log('Transaction sent with hash:', result.value);
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
  * ```
- *
- * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useRenounceSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function usePreview(args: Pausable<UsePreviewArgs> & Suspendable): PausableSuspenseResult<PreviewUserPosition>;
 /**
- * A hook that provides a way to update the user risk premium for a spoke.
+ * Fetch a preview of the impact of a potential action on a user's position.
  *
- * ```ts
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [updateUserRiskPremium, { loading, error }] = useUpdateUserRiskPremium((transaction, { cancel }) => {
- *   return sendTransaction(transaction);
+ * ```tsx
+ * const { data, error, loading } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
  * });
- *
- * // …
- *
- * 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>;
+declare function usePreview(args: UsePreviewArgs): ReadResult<PreviewUserPosition>;
 /**
- * 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()) {
- *   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;
+ * Fetch a preview of the impact of a potential action on a user's position.
  *
- *     case 'UnexpectedError':
- *       console.error(result.error.message);
- *       break;
- *   }
- *   return;
- * }
+ * Pausable loading state mode.
  *
- * console.log('Transaction sent with hash:', result.value);
+ * ```tsx
+ * const { data, error, loading, paused } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   pause: true,
+ * });
  * ```
- *
- * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useUpdateUserDynamicConfig(handler: TransactionHandler): UseAsyncTask<UpdateUserDynamicConfigRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
+
 /**
- * Hook for setting whether a user's supply should be used as collateral.
+ * A hook that provides a way to renounce a position manager of a user for a specific spoke.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [setUserSupplyAsCollateral, { loading, error }] = useSetUserSupplyAsCollateral((transaction, { cancel }) => {
- *   return sendTransaction(transaction);
- * });
+ * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
  *
- * const result = await setUserSupplyAsCollateral({
- *   reserve: reserveId('SGVsbG8h'),
- *   sender: evmAddress('0x456...'),
- *   enableCollateral: true,
- * });
+ * // …
+ *
+ * const result = await renounceSpokeUserPositionManager({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1754,22 +2556,26 @@ declare function useUpdateUserDynamicConfig(handler: TransactionHandler): UseAsy
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
  *
  * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useSetUserSupplyAsCollateral(handler: TransactionHandler): UseAsyncTask<SetUserSupplyAsCollateralRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function useRenounceSpokeUserPositionManager(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * A hook that provides a way to liquidate a user's position.
+ * A hook that provides a way to repay borrowed assets to an Aave reserve.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [liquidatePosition, { loading, error }] = useLiquidatePosition((plan, { cancel }) => {
+ * const [repay, { loading, error }] = useRepay((plan, { cancel }) => {
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1777,13 +2583,7 @@ declare function useSetUserSupplyAsCollateral(handler: TransactionHandler): UseA
  *
  * // …
  *
- * const result = await liquidatePosition({
- *   collateral: reserveId('SGVsbG8h'),
- *   debt: reserveId('Q2lhbyE= '),
- *   amount: amount,
- *   liquidator: liquidator,
- *   borrower: borrower,
- * });
+ * const result = await repay({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1814,12 +2614,13 @@ declare function useSetUserSupplyAsCollateral(handler: TransactionHandler): UseA
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
  *
  * @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 useRepay(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<RepayRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
  * A hook that provides a way to set or remove a position manager for a user on a specific spoke.
  *
@@ -1876,226 +2677,226 @@ declare function useLiquidatePosition(handler: TransactionHandler): UseAsyncTask
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
  *
  * @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, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * Preview the impact of a potential action on a user's position.
- *
- * ```tsx
- * const [getPreview, previewing] = usePreviewAction();
- *
- * const loading = previewing.loading;
- * const error = previewing.error;
+ * Hook for updating the collateral status of user's supplies.
  *
- * // …
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [setUserSuppliesAsCollateral, { loading, error }] = useSetUserSuppliesAsCollateral((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
  *
- * const result = await getPreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           value: '1000',
- *         },
- *       },
- *       sender: evmAddress('0x9abc…'),
- *     },
- *   },
+ * const result = await setUserSuppliesAsCollateral({
+ *   changes: [
+ *     {
+ *       reserve: reserve.id,
+ *       enableCollateral: true
+ *     }
+ *   ],
+ *   sender: evmAddress('0x456...')
  * });
  *
  * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
- *
- * 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.
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
  *
- * Pausable suspense mode.
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
  *
- * ```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.
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
  *
- * ```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.
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
  *
- * Pausable loading state mode.
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
  *
- * ```tsx
- * const { data, error, loading, paused } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   pause: true,
- * });
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
-type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions>;
+declare function useSetUserSuppliesAsCollateral(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetUserSuppliesAsCollateralRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * Fetch paginated list of activities.
+ * A hook that provides a way to supply assets to an Aave reserve.
  *
- * This signature supports React Suspense:
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [supply, { loading, error }] = useSupply((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
  *
- * ```tsx
- * const { data } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   suspense: true,
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
  * });
  *
- * // data.items: ActivityItem[]
- * ```
- */
-declare function useActivities(args: UseActivitiesArgs & Suspendable): SuspenseResult<PaginatedActivitiesResult>;
-/**
- * Fetch paginated list of activities.
+ * // …
  *
- * Pausable suspense mode.
+ * const result = await supply({ ... });
  *
- * ```tsx
- * const { data } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   suspense: true,
- *   pause: true,
- * });
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
  *
- * // data?.items: ActivityItem[] | undefined
+ *     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.txHash);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useActivities(args: Pausable<UseActivitiesArgs> & Suspendable): PausableSuspenseResult<PaginatedActivitiesResult>;
+declare function useSupply(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<SupplyRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
- * Fetch paginated list of activities.
+ * Hook for updating user position conditions (dynamic config and/or risk premium).
  *
- * ```tsx
- * const { data, error, loading } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [update, { loading, error }] = useUpdateUserPositionConditions((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
  * });
- * ```
- */
-declare function useActivities(args: UseActivitiesArgs): ReadResult<PaginatedActivitiesResult>;
-/**
- * Fetch paginated list of activities.
  *
- * Pausable loading state mode.
+ * // …
  *
- * ```tsx
- * const { data, error, loading } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   pause: true,
+ * const result = await update({
+ *   userPositionId: userPosition.id,
+ *   update: UserPositionConditionsUpdate.AllDynamicConfig,
  * });
  *
- * // data?.items: ActivityItem[] | undefined
- * // error: UnexpectedError | undefined
- * // loading: boolean | undefined
+ * 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.txHash);
  * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useActivities(args: Pausable<UseActivitiesArgs>): PausableReadResult<PaginatedActivitiesResult>;
+declare function useUpdateUserPositionConditions(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<UpdateUserPositionConditionsRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * Low-level hook to execute a {@link activities} action directly.
+ * A hook that provides a way to withdraw supplied assets from an Aave reserve.
  *
- * @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).
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [withdraw, { loading, error }] = useWithdraw((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
  *
- * @param options - The query options.
- * @returns The user history.
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * // …
+ *
+ * const result = await withdraw({ ... });
+ *
+ * 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.txHash);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useActivitiesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
+declare function useWithdraw(handler: ExecutionPlanHandler<TransactionRequest | PreContractActionRequired, PendingTransaction>): UseAsyncTask<WithdrawRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
 
-type UseUserSuppliesArgs = Prettify<UserSuppliesRequest & CurrencyQueryOptions>;
+type UseUserSuppliesArgs = Prettify<UserSuppliesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch all user supply positions.
  *
@@ -2208,8 +3009,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 +3116,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 +3379,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 +3531,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 UseHubAssetInterestRateModelArgs, 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 UseSwapStatusArgs, type UseSwappableTokensArgs, type UseTokenSwapQuoteArgs, type UseTokenSwapRequest, type UseUserBalancesArgs, type UseUserBorrowsArgs, type UseUserClaimableRewardsArgs, 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, useClaimRewards, useHub, useHubAssetInterestRateModel, useHubAssetInterestRateModelAction, 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, useUserClaimableRewards, useUserClaimableRewardsAction, useUserPosition, useUserPositions, useUserPositionsAction, useUserRiskPremiumBreakdown, useUserSummary, useUserSummaryHistory, useUserSupplies, useUserSuppliesAction, useUserSwaps, useWithdraw, useWithdrawSwap, useWithdrawSwapQuote, useWithdrawSwapQuoteAction };