@aave/react 4.0.0-next.9 → 4.0.1

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import { AaveClient, CurrencyQueryOptions, TimeWindowQueryOptions, UnexpectedError, 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.js';
-export { A as AsyncTaskError, c as AsyncTaskIdle, d as AsyncTaskLoading, e as AsyncTaskState, f as AsyncTaskSuccess, g as TransactionHandlerOptions, U as UseSendTransactionResult } from './writes-BXnwYgAQ.js';
-import { HubRequest, Hub, HubsRequest, HubAssetsRequest, HubAsset, HubSummaryHistoryRequest, HubSummarySample, PermitRequest, PermitTypedDataResponse, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, AssetCategoryBorrowHistoryRequest, AssetCategoryBorrowSample, AssetCategorySupplyHistoryRequest, AssetCategorySupplySample, ProtocolHistoryRequest, ProtocolHistorySample, 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, UpdateUserPositionConditionsRequest, SetUserSuppliesAsCollateralRequest, LiquidatePositionRequest, SetSpokeUserPositionManagerRequest, PreviewRequest, PreviewUserPosition, UserSuppliesRequest, UserSupplyItem, UserBorrowsRequest, UserBorrowItem, UserSummaryRequest, UserSummary, UserPositionsRequest, UserPosition, UserPositionRequest, UserBalancesRequest, UserBalance, UserRiskPremiumBreakdownRequest, UserRiskPremiumBreakdownItem, UserSummaryHistoryRequest, UserSummaryHistoryItem } from '@aave/graphql';
-import { Prettify, 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-BUJSXsyz.js';
-export { e as UseChainArgs, f as UseChainsArgs, i as UseExchangeRateArgs, U as UseNetworkFee, l as UseNetworkFeeArgs, k as UseNetworkFeeRequestQuery, u as useChain, g as useChains, j as useExchangeRate, h as useExchangeRateAction } from './misc-BUJSXsyz.js';
-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.js';
+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.js';
+import { HubRequest, HubAssetInterestRateModelRequest, HubAssetsRequest, HubSummaryHistoryRequest, HubsRequest, Hub, HubAssetInterestRateModelPoint, HubAsset, HubSummarySample, AssetRequest, AssetBorrowHistoryRequest, AssetPriceHistoryRequest, AssetSupplyHistoryRequest, ProtocolHistoryRequest, Asset, AssetBorrowSample, AssetPriceSample, AssetSupplySample, ProtocolHistorySample, BorrowApyHistoryRequest, ReserveRequest, ReservesRequest, SupplyApyHistoryRequest, ApySample, Reserve, UserClaimableRewardsRequest, UserClaimableReward, SpokeRequest, SpokePositionManagersRequest, SpokeUserPositionManagersRequest, SpokesRequest, Spoke, PaginatedSpokePositionManagerResult, 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, UserBalancesRequest, UserBorrowsRequest, UserPositionRequest, UserPositionsRequest, UserRiskPremiumBreakdownRequest, UserSummaryRequest, UserSummaryHistoryRequest, UserSuppliesRequest, UserBalance, UserBorrowItem, UserPosition, UserRiskPremiumBreakdownItem, UserSummary, UserSummaryHistoryItem, UserSupplyItem, StableVaultRequest, StableVaultClaimStatusRequest, StableVaultUserPositionsRequest, StableVaultsRequest, StableVault, StableVaultClaimStatus, StableVaultDepositRequest, StableVaultUserPosition, StableVaultWithdrawRequest, StableVaultWithdrawClaim, StableVaultWithdrawRedeemRequest } 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-mjFkGr9I.js';
+export { d as UseChainArgs, e as UseChainsArgs, f as UseExchangeRateArgs, U as UseNetworkFee, g as UseNetworkFeeArgs, h as UseNetworkFeeRequestQuery, u as useChain, i as useChainAction, j as useChains, k as useExchangeRate, l as useExchangeRateAction } from './misc-mjFkGr9I.js';
+import { CancelError, SigningError, UnexpectedError as UnexpectedError$1, ValidationError, TimeoutError, TransactionError } from '@aave/core';
 import { UserPositionQueryOptions } from '@aave/client/actions';
 
 /**
@@ -263,6 +263,82 @@ declare function useHubSummaryHistory(args: UseHubSummaryHistoryArgs): ReadResul
  * ```
  */
 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.
  *
@@ -292,11 +368,6 @@ declare function useHubSummaryHistory(args: Pausable<UseHubSummaryHistoryArgs>):
  */
 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.
@@ -405,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.
  *
@@ -458,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.
  *
@@ -511,112 +582,6 @@ declare function useAssetBorrowHistory(args: UseAssetBorrowHistoryArgs): ReadRes
  * ```
  */
 declare function useAssetBorrowHistory(args: Pausable<UseAssetBorrowHistoryArgs>): PausableReadResult<AssetBorrowSample[]>;
-type UseAssetCategoryBorrowHistoryArgs = Prettify<AssetCategoryBorrowHistoryRequest & CurrencyQueryOptions>;
-/**
- * Fetch historical borrow data for a specific token category.
- *
- * This signature supports React Suspense:
- *
- * ```tsx
- * const { data } = useAssetCategoryBorrowHistory({
- *   category: TokenCategory.Stablecoin,
- *   window: TimeWindow.LastWeek,
- *   suspense: true,
- * });
- * ```
- */
-declare function useAssetCategoryBorrowHistory(args: UseAssetCategoryBorrowHistoryArgs & Suspendable): SuspenseResult<AssetCategoryBorrowSample[]>;
-/**
- * Fetch historical borrow data for a specific token category.
- *
- * Pausable suspense mode.
- *
- * ```tsx
- * const { data } = useAssetCategoryBorrowHistory({
- *   category: TokenCategory.Stablecoin,
- *   suspense: true,
- *   pause: true,
- * });
- * ```
- */
-declare function useAssetCategoryBorrowHistory(args: Pausable<UseAssetCategoryBorrowHistoryArgs> & Suspendable): PausableSuspenseResult<AssetCategoryBorrowSample[]>;
-/**
- * Fetch historical borrow data for a specific token category.
- *
- * ```tsx
- * const { data, error, loading } = useAssetCategoryBorrowHistory({
- *   category: TokenCategory.Stablecoin,
- *   window: TimeWindow.LastWeek,
- * });
- * ```
- */
-declare function useAssetCategoryBorrowHistory(args: UseAssetCategoryBorrowHistoryArgs): ReadResult<AssetCategoryBorrowSample[]>;
-/**
- * Fetch historical borrow data for a specific token category.
- *
- * Pausable loading state mode.
- *
- * ```tsx
- * const { data, error, loading, paused } = useAssetCategoryBorrowHistory({
- *   category: TokenCategory.Stablecoin,
- *   pause: true,
- * });
- * ```
- */
-declare function useAssetCategoryBorrowHistory(args: Pausable<UseAssetCategoryBorrowHistoryArgs>): PausableReadResult<AssetCategoryBorrowSample[]>;
-type UseAssetCategorySupplyHistoryArgs = Prettify<AssetCategorySupplyHistoryRequest & CurrencyQueryOptions>;
-/**
- * Fetch historical supply data for a specific token category.
- *
- * This signature supports React Suspense:
- *
- * ```tsx
- * const { data } = useAssetCategorySupplyHistory({
- *   category: TokenCategory.Stablecoin,
- *   window: TimeWindow.LastWeek,
- *   suspense: true,
- * });
- * ```
- */
-declare function useAssetCategorySupplyHistory(args: UseAssetCategorySupplyHistoryArgs & Suspendable): SuspenseResult<AssetCategorySupplySample[]>;
-/**
- * Fetch historical supply data for a specific token category.
- *
- * Pausable suspense mode.
- *
- * ```tsx
- * const { data } = useAssetCategorySupplyHistory({
- *   category: TokenCategory.Stablecoin,
- *   suspense: true,
- *   pause: true,
- * });
- * ```
- */
-declare function useAssetCategorySupplyHistory(args: Pausable<UseAssetCategorySupplyHistoryArgs> & Suspendable): PausableSuspenseResult<AssetCategorySupplySample[]>;
-/**
- * Fetch historical supply data for a specific token category.
- *
- * ```tsx
- * const { data, error, loading } = useAssetCategorySupplyHistory({
- *   category: TokenCategory.Stablecoin,
- *   window: TimeWindow.LastWeek,
- * });
- * ```
- */
-declare function useAssetCategorySupplyHistory(args: UseAssetCategorySupplyHistoryArgs): ReadResult<AssetCategorySupplySample[]>;
-/**
- * Fetch historical supply data for a specific token category.
- *
- * Pausable loading state mode.
- *
- * ```tsx
- * const { data, error, loading, paused } = useAssetCategorySupplyHistory({
- *   category: TokenCategory.Stablecoin,
- *   pause: true,
- * });
- * ```
- */
-declare function useAssetCategorySupplyHistory(args: Pausable<UseAssetCategorySupplyHistoryArgs>): PausableReadResult<AssetCategorySupplySample[]>;
 type UseProtocolHistoryArgs = ProtocolHistoryRequest;
 /**
  * Fetch historical protocol-wide data (deposits, borrows, earnings).
@@ -753,18 +718,8 @@ declare function useReserve(args: Pausable<UseReserveArgs>): PausableReadResult<
  * }
  * ```
  */
-declare function useReserveAction(options?: Required<CurrencyQueryOptions> & TimeWindowQueryOptions): UseAsyncTask<ReserveRequest, Reserve | null, UnexpectedError>;
-type UseReservesArgs<T = Reserve[]> = Prettify<ReservesRequest & CurrencyQueryOptions & TimeWindowQueryOptions & {
-    /**
-     * A function that maps the full list of reserves
-     * into a derived or narrowed value.
-     *
-     * 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.
  *
@@ -783,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.
  *
@@ -831,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.
  *
@@ -847,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.
  *
@@ -892,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.
  *
@@ -922,38 +823,8 @@ 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> & TimeWindowQueryOptions): UseAsyncTask<ReservesRequest, Reserve[], UnexpectedError>;
+declare function useReservesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ReservesRequest, Reserve[], UnexpectedError>;
 type UseBorrowApyHistoryArgs = BorrowApyHistoryRequest;
 /**
  * Fetch borrow APY history for a specific reserve over time.
@@ -1065,81 +936,159 @@ declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs): ReadResult<
  */
 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,
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserClaimableRewardsAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   user: evmAddress('0x742d35cc…'),
  * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserClaimableReward[]
+ * } else {
+ *   console.error(result.error);
+ * }
  * ```
  */
-declare function useSpokes(args: UseSpokesArgs & Suspendable): SuspenseResult<Spoke[]>;
+declare function useUserClaimableRewardsAction(): UseAsyncTask<UserClaimableRewardsRequest, UserClaimableReward[], UnexpectedError>;
+
+type UseSpokeArgs = SpokeRequest;
 /**
- * Fetch spokes based on specified criteria.
+ * Fetch a specific spoke.
  *
- * Pausable suspense mode.
+ * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useSpokes({
- *   query: { chainIds: [chainId(1)] },
+ * const { data } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   suspense: true,
+ * });
+ * // data will be Spoke | null
+ * ```
+ */
+declare function useSpoke(args: UseSpokeArgs & Suspendable): SuspenseResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpoke(args: Pausable<UseSpokeArgs> & Suspendable): PausableSuspenseResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ * });
+ * // data will be Spoke | null
+ * ```
+ */
+declare function useSpoke(args: UseSpokeArgs): ReadResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpoke(args: Pausable<UseSpokeArgs>): PausableReadResult<Spoke | null>;
+type UseSpokesArgs = SpokesRequest;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSpokes(args: UseSpokesArgs & Suspendable): SuspenseResult<Spoke[]>;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
  *   suspense: true,
  *   pause: true,
  * });
@@ -1276,264 +1225,352 @@ 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.
  *
- * ```tsx
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- * const [signSwapByIntentWith, signing] = useSignSwapByIntentWith(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 [swap, swapping] = useSwapTokens((plan) => {
- *   switch (plan.__typename) {
- *     case 'SwapByIntentTypedData':
- *       return signSwapByIntentWith(plan);
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useRepayWithSupplyQuoteAction();
  *
- *     case 'SwapApprovalRequired':
- *     case 'SwapByIntentWithApprovalRequired':
- *       return sendTransaction(plan.transaction);
+ * // …
  *
- *     case 'SwapTransactionRequest':
- *       return sendTransaction(plan.transaction);
+ * 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 [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [swapSupply, { loading, error }] = useSupplySwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
+ *
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
  *   }
  * });
  *
- * const result = await swap({
+ * const result = await swapSupply({
  *   market: {
- *     chainId: chainId(1),
- *     buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *     sell: { erc20: evmAddress('0x6B175474E...') },
+ *     sellPosition: supplyPosition.id,
+ *     buyReserve: targetReserve.id,
  *     amount: bigDecimal('1000'),
- *     kind: SwapKind.SELL,
- *     user: evmAddress('0x742d35cc...'),
+ *     user: evmAddress('0x742d35cc…'),
+ *     enableCollateral: true,
  *   },
  * });
  *
@@ -1545,32 +1582,245 @@ 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 useSupplySwap(handler: PositionSwapHandler): UseAsyncTask<SupplySwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+type UseSupplySwapQuoteArgs = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * @internal
- * Executes the complete swap cancellation workflow combining preparation and execution.
+ * 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 [signSwapCancelWith] = useSignSwapCancelWith(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * const [cancelSwap, {loading, error}] = useCancelSwap((plan: CancelSwapTypedData | TransactionRequest) => {
+ * const [swap, { loading, error }] = useTokenSwap((plan) => {
  *   switch (plan.__typename) {
- *     case 'TransactionRequest':
- *       return sendTransaction(plan);
+ *     case 'Erc20Approval':
+ *       if (plan.bySignature) {
+ *         return signTypedData(plan.bySignature);
+ *       }
+ *       return sendTransaction(plan.byTransaction);
+ *
+ *     case 'SwapTransactionRequest':
+ *       return sendTransaction(plan.transaction);
  *
- *     case 'CancelSwapTypedData':
- *       return signSwapCancelWith(plan);
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
  *   }
  * });
  *
- * const result = await cancelSwap({
- *   id: swapId('123...'),
+ * const result = await swap({
+ *   fromQuote: {
+ *     quoteId: quote.quoteId,
+ *   },
  * });
  *
  * if (result.isErr()) {
@@ -1578,66 +1828,402 @@ type CancelSwapError = CancelError | CannotCancelSwapError | SigningError | Time
  *   return;
  * }
  *
- * // result.value: SwapCancelled
- * console.log('Swap cancelled:', result.value);
+ * // result.value: SwapReceipt
  * ```
  */
-declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelled, CancelSwapError>;
+declare function useTokenSwap(handler: TokenSwapHandler): UseAsyncTask<UseTokenSwapRequest, SwapReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
 
+type UseTokenSwapQuoteArgs = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * A hook that provides a way to supply assets to an Aave reserve.
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useTokenSwapQuote({
+ *   market: {
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useTokenSwapQuote({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useTokenSwapQuote({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useTokenSwapQuote({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * Low-level hook to execute a swap quote action directly.
+ *
+ * @remarks
+ * This hook **does not** actively watch for updated data on the swap quote.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow
+ * (e.g., in an event handler to get a fresh quote before executing a swap).
  *
  * ```ts
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [supply, { loading, error }] = useSupply((plan, { cancel }) => {
+ * 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 'TransactionRequest':
- *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
- *     case 'PreContractActionRequired':
- *       return sendTransaction(plan.transaction);
+ *     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…'),
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
+ * ```
+ */
+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>;
+/**
+ * Low-level hook to execute a withdraw 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 }] = useWithdrawSwapQuoteAction();
+ *
  * // …
  *
- * const result = await supply({ ... });
+ * const result = await getQuote({
+ *   position: userSupplyItem.id,
+ *   buyReserve: reserve.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Withdraw swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useWithdrawSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<WithdrawSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
+ *
+ * // data.items: ActivityItem[]
+ * ```
+ */
+declare function useActivities(args: UseActivitiesArgs & Suspendable): SuspenseResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
  *
- * 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.
  *
@@ -1647,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);
  *   }
@@ -1686,30 +2272,29 @@ 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')],
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x9abc…'),
+ * });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1729,10 +2314,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;
@@ -1740,22 +2321,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);
  *   }
@@ -1763,7 +2348,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) {
@@ -1794,120 +2385,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;
- *
- *     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;
- *   }
+ *   console.error(result.error);
  *   return;
  * }
  *
- * console.log('Transaction sent with hash:', result.value);
+ * console.log('Preview result:', result.value);
  * ```
- *
- * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useRenounceSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function usePreviewAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<PreviewRequest, PreviewUserPosition, UnexpectedError>;
+type UsePreviewArgs = Prettify<PreviewRequest & CurrencyQueryOptions>;
 /**
- * Hook for updating user position conditions (dynamic config and/or risk premium).
- *
- * ```ts
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [update, { loading, error }] = useUpdateUserPositionConditions((transaction, { cancel }) => {
- *   return sendTransaction(transaction);
- * });
+ * Fetch a preview of the impact of a potential action on a user's position.
  *
- * // …
+ * This signature supports React Suspense:
  *
- * const result = await update({
- *   userPositionId: userPosition.id,
- *   dynamicConfig: true,
- *   riskPremium: true,
+ * ```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.
  *
- * 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;
+ * Pausable suspense mode.
  *
- *     case 'TimeoutError':
- *       console.error(`Transaction timed out: ${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 'TransactionError':
- *       console.error(`Transaction failed: ${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 '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 useUpdateUserPositionConditions(handler: TransactionHandler): UseAsyncTask<UpdateUserPositionConditionsRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
+
 /**
- * Hook for updating the collateral status of user's supplies.
+ * A hook that provides a way to renounce a position manager of a user for a specific spoke.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [setUserSuppliesAsCollateral, { loading, error }] = useSetUserSuppliesAsCollateral((transaction, { cancel }) => {
- *   return sendTransaction(transaction);
- * });
+ * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
  *
- * const result = await setUserSuppliesAsCollateral({
- *   changes: [
- *     {
- *       reserve: reserve.id,
- *       enableCollateral: true
- *     }
- *   ],
- *   sender: evmAddress('0x456...')
- * });
+ * // …
+ *
+ * const result = await renounceSpokeUserPositionManager({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1934,22 +2558,26 @@ declare function useUpdateUserPositionConditions(handler: TransactionHandler): U
  *   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 useSetUserSuppliesAsCollateral(handler: TransactionHandler): UseAsyncTask<SetUserSuppliesAsCollateralRequest, 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);
  *   }
@@ -1957,13 +2585,7 @@ declare function useSetUserSuppliesAsCollateral(handler: TransactionHandler): Us
  *
  * // …
  *
- * 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) {
@@ -1994,12 +2616,13 @@ declare function useSetUserSuppliesAsCollateral(handler: TransactionHandler): Us
  *   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.
  *
@@ -2056,224 +2679,224 @@ 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);
+ *   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('Preview result:', 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 usePreviewAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<PreviewRequest, PreviewUserPosition, UnexpectedError>;
-type UsePreviewArgs = Prettify<PreviewRequest & CurrencyQueryOptions>;
+declare function useSetUserSuppliesAsCollateral(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetUserSuppliesAsCollateralRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * Fetch a preview of the impact of a potential action on a user's position.
+ * 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 } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   suspense: true,
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
  * });
- * ```
- */
-declare function usePreview(args: UsePreviewArgs & Suspendable): SuspenseResult<PreviewUserPosition>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
  *
- * Pausable suspense mode.
+ * // …
  *
- * ```tsx
- * const { data } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   suspense: true,
- *   pause: true,
- * });
- * ```
- */
-declare function usePreview(args: Pausable<UsePreviewArgs> & Suspendable): PausableSuspenseResult<PreviewUserPosition>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
+ * const result = await supply({ ... });
  *
- * ```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.
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
  *
- * Pausable loading state mode.
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
  *
- * ```tsx
- * const { data, error, loading, paused } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   pause: true,
- * });
- * ```
- */
-declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
-type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
-/**
- * Fetch paginated list of activities.
+ *     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 } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   suspense: true,
- * });
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
  *
- * // data.items: ActivityItem[]
+ * 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: UseActivitiesArgs & Suspendable): SuspenseResult<PaginatedActivitiesResult>;
+declare function useSupply(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<SupplyRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
- * Fetch paginated list of activities.
- *
- * Pausable suspense mode.
+ * Hook for updating user position conditions (dynamic config and/or risk premium).
  *
- * ```tsx
- * const { data } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   suspense: true,
- *   pause: true,
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [update, { loading, error }] = useUpdateUserPositionConditions((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
  * });
  *
- * // data?.items: ActivityItem[] | undefined
- * ```
- */
-declare function useActivities(args: Pausable<UseActivitiesArgs> & Suspendable): PausableSuspenseResult<PaginatedActivitiesResult>;
-/**
- * Fetch paginated list of activities.
+ * // …
  *
- * ```tsx
- * const { data, error, loading } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
+ * const result = await update({
+ *   userPositionId: userPosition.id,
+ *   update: UserPositionConditionsUpdate.AllDynamicConfig,
  * });
+ *
+ * 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: UseActivitiesArgs): ReadResult<PaginatedActivitiesResult>;
+declare function useUpdateUserPositionConditions(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<UpdateUserPositionConditionsRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * Fetch paginated list of activities.
+ * A hook that provides a way to withdraw supplied assets from an Aave reserve.
  *
- * Pausable loading state mode.
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [withdraw, { loading, error }] = useWithdraw((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
  *
- * ```tsx
- * const { data, error, loading } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   pause: true,
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
  * });
  *
- * // 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.
+ * // …
  *
- * @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).
+ * const result = await withdraw({ ... });
  *
- * @param options - The query options.
- * @returns The user history.
+ * 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> & TimeWindowQueryOptions): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
+declare function useWithdraw(handler: ExecutionPlanHandler<TransactionRequest | PreContractActionRequired, PendingTransaction>): UseAsyncTask<WithdrawRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
 
 type UseUserSuppliesArgs = Prettify<UserSuppliesRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
@@ -2388,7 +3011,7 @@ declare function useUserSupplies(args: Pausable<UseUserSuppliesArgs>): PausableR
  * }
  * ```
  */
-declare function useUserSuppliesAction(options?: Required<CurrencyQueryOptions> & TimeWindowQueryOptions): UseAsyncTask<UserSuppliesRequest, UserSupplyItem[], UnexpectedError>;
+declare function useUserSuppliesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<UserSuppliesRequest, UserSupplyItem[], UnexpectedError>;
 type UseUserBorrowsArgs = Prettify<UserBorrowsRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch all user borrow positions.
@@ -2495,7 +3118,7 @@ declare function useUserBorrows(args: Pausable<UseUserBorrowsArgs>): PausableRea
  * }
  * ```
  */
-declare function useUserBorrowsAction(options?: Required<CurrencyQueryOptions> & TimeWindowQueryOptions): 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.
@@ -2910,4 +3533,190 @@ 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 UseAssetCategoryBorrowHistoryArgs, type UseAssetCategorySupplyHistoryArgs, type UseAssetPriceHistoryArgs, type UseAssetSupplyHistoryArgs, UseAsyncTask, type UseBorrowApyHistoryArgs, type UseHubArgs, type UseHubAssetsArgs, type UseHubSummaryHistoryArgs, type UseHubsArgs, type UsePreviewArgs, type UseProtocolHistoryArgs, 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 UseUserRiskPremiumBreakdownArgs, type UseUserSummaryArgs, type UseUserSummaryHistoryArgs, type UseUserSuppliesArgs, type UseUserSwapsArgs, useAaveClient, useActivities, useActivitiesAction, useAsset, useAssetBorrowHistory, useAssetCategoryBorrowHistory, useAssetCategorySupplyHistory, useAssetPriceHistory, useAssetSupplyHistory, useBorrow, useBorrowApyHistory, useCancelSwap, useHub, useHubAssets, useHubSummaryHistory, useHubs, useHubsAction, useLiquidatePosition, usePermitTypedDataAction, usePreview, usePreviewAction, useProtocolHistory, useRenounceSpokeUserPositionManager, useRepay, useReserve, useReserveAction, useReserves, useReservesAction, useSetSpokeUserPositionManager, useSetUserSuppliesAsCollateral, useSpoke, useSpokePositionManagers, useSpokeUserPositionManagers, useSpokes, useSupply, useSupplyApyHistory, useSwapQuote, useSwapQuoteAction, useSwapTokens, useSwappableTokens, useUpdateUserPositionConditions, useUserBalances, useUserBalancesAction, useUserBorrows, useUserBorrowsAction, useUserPosition, useUserPositions, useUserPositionsAction, useUserRiskPremiumBreakdown, useUserSummary, useUserSummaryHistory, useUserSupplies, useUserSuppliesAction, useUserSwaps, useWithdraw };
+/**
+ * A hook that provides a way to deposit assets into a stable vault.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ *
+ * const [deposit, { loading, error }] = useStableVaultDeposit((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *   }
+ * });
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useStableVaultDeposit(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval, Signature | PendingTransaction>): UseAsyncTask<StableVaultDepositRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+type StableVaultWithdrawResult = TransactionReceipt | StableVaultWithdrawClaim;
+/**
+ * A hook that provides a way to withdraw from a stable vault.
+ *
+ * The result discriminates between instant and deferred withdrawals:
+ * - `TransactionReceipt` — Instant withdraw completed.
+ * - `StableVaultWithdrawClaim` — Deferred withdraw; IOU minted, funds need to be redeemed.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ *
+ * const [withdraw, { loading, error }] = useStableVaultWithdraw((transaction) =>
+ *   sendTransaction(transaction),
+ * );
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useStableVaultWithdraw(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<StableVaultWithdrawRequest, StableVaultWithdrawResult, SendTransactionError | PendingTransactionError>;
+/**
+ * A hook that provides a way to redeem a deferred withdrawal claim.
+ *
+ * Use this after the claim status is `READY` (see {@link useStableVaultClaimStatus}).
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ *
+ * const [redeem, { loading, error }] = useStableVaultWithdrawRedeem((plan) =>
+ *   sendTransaction(plan),
+ * );
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useStableVaultWithdrawRedeem(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<StableVaultWithdrawRedeemRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+type UseStableVaultClaimStatusArgs = StableVaultClaimStatusRequest;
+/**
+ * Poll a deferred withdrawal claim until it is ready.
+ *
+ * The hook automatically polls until the claim reaches a final status.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useStableVaultClaimStatus({
+ *   claimId,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useStableVaultClaimStatus(args: UseStableVaultClaimStatusArgs & Suspendable): SuspenseResult<StableVaultClaimStatus>;
+/**
+ * Pausable suspense mode.
+ */
+declare function useStableVaultClaimStatus(args: Pausable<UseStableVaultClaimStatusArgs> & Suspendable): PausableSuspenseResult<StableVaultClaimStatus>;
+/**
+ * Poll a deferred withdrawal claim until it is ready.
+ *
+ * ```tsx
+ * const { data, loading, error } = useStableVaultClaimStatus({
+ *   claimId,
+ * });
+ * ```
+ */
+declare function useStableVaultClaimStatus(args: UseStableVaultClaimStatusArgs): ReadResult<StableVaultClaimStatus>;
+/**
+ * Pausable loading state mode.
+ */
+declare function useStableVaultClaimStatus(args: Pausable<UseStableVaultClaimStatusArgs>): PausableReadResult<StableVaultClaimStatus>;
+type UseStableVaultUserPositionsArgs = StableVaultUserPositionsRequest;
+/**
+ * Fetch all stable vault positions for a given user.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useStableVaultUserPositions({
+ *   user: evmAddress('0x…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useStableVaultUserPositions(args: UseStableVaultUserPositionsArgs & Suspendable): SuspenseResult<StableVaultUserPosition[]>;
+/**
+ * Pausable suspense mode.
+ */
+declare function useStableVaultUserPositions(args: Pausable<UseStableVaultUserPositionsArgs> & Suspendable): PausableSuspenseResult<StableVaultUserPosition[]>;
+/**
+ * Fetch all stable vault positions for a given user.
+ *
+ * ```tsx
+ * const { data, loading, error } = useStableVaultUserPositions({
+ *   user: evmAddress('0x…'),
+ * });
+ * ```
+ */
+declare function useStableVaultUserPositions(args: UseStableVaultUserPositionsArgs): ReadResult<StableVaultUserPosition[]>;
+/**
+ * Pausable loading state mode.
+ */
+declare function useStableVaultUserPositions(args: Pausable<UseStableVaultUserPositionsArgs>): PausableReadResult<StableVaultUserPosition[]>;
+type UseStableVaultArgs = StableVaultRequest;
+/**
+ * Fetch a stable vault by ID.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useStableVault({
+ *   id: stableVaultId('vault-123'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useStableVault(args: UseStableVaultArgs & Suspendable): SuspenseResult<StableVault | null>;
+/**
+ * Pausable suspense mode.
+ */
+declare function useStableVault(args: Pausable<UseStableVaultArgs> & Suspendable): PausableSuspenseResult<StableVault | null>;
+/**
+ * Fetch a stable vault by ID.
+ *
+ * ```tsx
+ * const { data, loading, error } = useStableVault({
+ *   id: stableVaultId('vault-123'),
+ * });
+ * ```
+ */
+declare function useStableVault(args: UseStableVaultArgs): ReadResult<StableVault | null>;
+/**
+ * Pausable loading state mode.
+ */
+declare function useStableVault(args: Pausable<UseStableVaultArgs>): PausableReadResult<StableVault | null>;
+type UseStableVaultsArgs = StableVaultsRequest;
+/**
+ * Fetch all stable vaults managed by a given admin address.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useStableVaults({
+ *   adminAddress: evmAddress('0x…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useStableVaults(args: UseStableVaultsArgs & Suspendable): SuspenseResult<StableVault[]>;
+/**
+ * Pausable suspense mode.
+ */
+declare function useStableVaults(args: Pausable<UseStableVaultsArgs> & Suspendable): PausableSuspenseResult<StableVault[]>;
+/**
+ * Fetch all stable vaults managed by a given admin address.
+ *
+ * ```tsx
+ * const { data, loading, error } = useStableVaults({
+ *   adminAddress: evmAddress('0x…'),
+ * });
+ * ```
+ */
+declare function useStableVaults(args: UseStableVaultsArgs): ReadResult<StableVault[]>;
+/**
+ * Pausable loading state mode.
+ */
+declare function useStableVaults(args: Pausable<UseStableVaultsArgs>): PausableReadResult<StableVault[]>;
+
+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 UseStableVaultArgs, type UseStableVaultClaimStatusArgs, type UseStableVaultUserPositionsArgs, type UseStableVaultsArgs, 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, useStableVault, useStableVaultClaimStatus, useStableVaultDeposit, useStableVaultUserPositions, useStableVaultWithdraw, useStableVaultWithdrawRedeem, useStableVaults, 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 };