@aave/react 4.0.0-next.8 → 4.0.0

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, PermitRequest, PermitTypedDataResponse, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, 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, 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';
 
 /**
@@ -208,6 +208,137 @@ declare function useHubAssets(args: UseHubAssetsArgs): ReadResult<HubAsset[]>;
  * ```
  */
 declare function useHubAssets(args: Pausable<UseHubAssetsArgs>): PausableReadResult<HubAsset[]>;
+type UseHubSummaryHistoryArgs = HubSummaryHistoryRequest;
+/**
+ * Fetch historical summary data for a specific hub.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useHubSummaryHistory({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useHubSummaryHistory(args: UseHubSummaryHistoryArgs & Suspendable): SuspenseResult<HubSummarySample[]>;
+/**
+ * Fetch historical summary data for a specific hub.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useHubSummaryHistory({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubSummaryHistory(args: Pausable<UseHubSummaryHistoryArgs> & Suspendable): PausableSuspenseResult<HubSummarySample[]>;
+/**
+ * Fetch historical summary data for a specific hub.
+ *
+ * ```tsx
+ * const { data, error, loading } = useHubSummaryHistory({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useHubSummaryHistory(args: UseHubSummaryHistoryArgs): ReadResult<HubSummarySample[]>;
+/**
+ * Fetch historical summary data for a specific hub.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useHubSummaryHistory({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubSummaryHistory(args: Pausable<UseHubSummaryHistoryArgs>): PausableReadResult<HubSummarySample[]>;
+type UseHubAssetInterestRateModelArgs = Prettify<HubAssetInterestRateModelRequest & CurrencyQueryOptions>;
+/**
+ * Fetch the interest rate model for a specific hub asset.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useHubAssetInterestRateModel({
+ *   query: { hubAssetId: hubAssetId('...') },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useHubAssetInterestRateModel(args: UseHubAssetInterestRateModelArgs & Suspendable): SuspenseResult<HubAssetInterestRateModelPoint[]>;
+/**
+ * Fetch the interest rate model for a specific hub asset.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useHubAssetInterestRateModel({
+ *   query: { hubAssetId: hubAssetId('...') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubAssetInterestRateModel(args: Pausable<UseHubAssetInterestRateModelArgs> & Suspendable): PausableSuspenseResult<HubAssetInterestRateModelPoint[]>;
+/**
+ * Fetch the interest rate model for a specific hub asset.
+ *
+ * ```tsx
+ * const { data, error, loading } = useHubAssetInterestRateModel({
+ *   query: { hubAssetId: hubAssetId('...') },
+ * });
+ * ```
+ */
+declare function useHubAssetInterestRateModel(args: UseHubAssetInterestRateModelArgs): ReadResult<HubAssetInterestRateModelPoint[]>;
+/**
+ * Fetch the interest rate model for a specific hub asset.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useHubAssetInterestRateModel({
+ *   query: { hubAssetId: hubAssetId('...') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubAssetInterestRateModel(args: Pausable<UseHubAssetInterestRateModelArgs>): PausableReadResult<HubAssetInterestRateModelPoint[]>;
+/**
+ * Low-level hook to execute a {@link hubAssetInterestRateModel} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data.
+ * Use this hook to retrieve data on demand as part of a larger workflow.
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useHubAssetInterestRateModelAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   query: { hubAssetId: hubAssetId('...') },
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // HubAssetInterestRateModelPoint[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useHubAssetInterestRateModelAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<HubAssetInterestRateModelRequest, HubAssetInterestRateModelPoint[], UnexpectedError>;
 /**
  * Low-level hook to execute a {@link hubs} action directly.
  *
@@ -237,11 +368,6 @@ declare function useHubAssets(args: Pausable<UseHubAssetsArgs>): PausableReadRes
  */
 declare function useHubsAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<HubsRequest, Hub[], UnexpectedError>;
 
-/**
- * @internal
- */
-declare function usePermitTypedDataAction(): UseAsyncTask<PermitRequest, PermitTypedDataResponse, UnexpectedError>;
-
 type UseAssetArgs = Prettify<AssetRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
@@ -350,7 +476,7 @@ declare function useAssetPriceHistory(args: UseAssetPriceHistoryArgs): ReadResul
  * ```
  */
 declare function useAssetPriceHistory(args: Pausable<UseAssetPriceHistoryArgs>): PausableReadResult<AssetPriceSample[]>;
-type UseAssetSupplyHistoryArgs = AssetSupplyHistoryRequest;
+type UseAssetSupplyHistoryArgs = Prettify<AssetSupplyHistoryRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch historical supply data for a specific asset.
  *
@@ -403,7 +529,7 @@ declare function useAssetSupplyHistory(args: UseAssetSupplyHistoryArgs): ReadRes
  * ```
  */
 declare function useAssetSupplyHistory(args: Pausable<UseAssetSupplyHistoryArgs>): PausableReadResult<AssetSupplySample[]>;
-type UseAssetBorrowHistoryArgs = AssetBorrowHistoryRequest;
+type UseAssetBorrowHistoryArgs = Prettify<AssetBorrowHistoryRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
  * Fetch historical borrow data for a specific asset.
  *
@@ -592,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.
  *
@@ -622,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.
  *
@@ -670,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.
  *
@@ -686,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.
  *
@@ -731,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.
  *
@@ -761,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.
@@ -904,6 +936,84 @@ declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs): ReadResult<
  */
 declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs>): PausableReadResult<ApySample[]>;
 
+type UseUserClaimableRewardsArgs = Prettify<UserClaimableRewardsRequest>;
+/**
+ * Fetch all claimable rewards for a user.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserClaimableRewards({
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserClaimableRewards(args: UseUserClaimableRewardsArgs & Suspendable): SuspenseResult<UserClaimableReward[]>;
+/**
+ * Fetch all claimable rewards for a user.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserClaimableRewards({
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserClaimableRewards(args: Pausable<UseUserClaimableRewardsArgs> & Suspendable): PausableSuspenseResult<UserClaimableReward[]>;
+/**
+ * Fetch all claimable rewards for a user.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserClaimableRewards({
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ * ```
+ */
+declare function useUserClaimableRewards(args: UseUserClaimableRewardsArgs): ReadResult<UserClaimableReward[]>;
+/**
+ * Fetch all claimable rewards for a user.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserClaimableRewards({
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserClaimableRewards(args: Pausable<UseUserClaimableRewardsArgs>): PausableReadResult<UserClaimableReward[]>;
+/**
+ * Low-level hook to execute a {@link userClaimableRewards} 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 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).
+ *
+ * ```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 useUserClaimableRewardsAction(): UseAsyncTask<UserClaimableRewardsRequest, UserClaimableReward[], UnexpectedError>;
+
 type UseSpokeArgs = SpokeRequest;
 /**
  * Fetch a specific spoke.
@@ -1115,168 +1225,727 @@ 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.
- *
- * This signature supports React Suspense:
+ * Orchestrate the borrow swap execution plan.
  *
  * ```tsx
- * const { data } = useSwapQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
- *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
- *   suspense: true,
- * });
- * ```
- */
-declare function useSwapQuote(args: UseSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
-/**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * Pausable suspense mode.
+ * const [swapBorrow, { loading, error }] = useBorrowSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
  *
- * ```tsx
- * const { data } = useSwapQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
- *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
- *   from: evmAddress('0x742d35cc...'),
- *   suspense: true,
+ *     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 } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a borrow swap operation with the specified parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a borrow swap operation with the specified parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useBorrowSwapQuote(args: UseBorrowSwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a quote for a borrow swap operation with the specified parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useBorrowSwapQuote({
+ *   market: {
+ *     sellPosition: userBorrowItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
  *   pause: true,
  * });
  * ```
  */
-declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+declare function useBorrowSwapQuote(args: Pausable<UseBorrowSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * Low-level hook to execute a borrow swap quote action directly.
+ *
+ * @remarks
+ * This hook **does not** actively watch for updated data on the swap quote.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow.
+ *
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useBorrowSwapQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   debtPosition: userBorrowItem.id,
+ *   buyReserve: reserve.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Borrow swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useBorrowSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<BorrowSwapQuoteRequest, SwapQuote, UnexpectedError$1 | 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;
+/**
+ * Executes the complete swap cancellation workflow combining preparation and execution.
+ *
+ * ```tsx
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
+ *
+ * const [cancelSwap, { loading, error }] = useCancelSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
+ * });
+ *
+ * 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 useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelledResult, CancelSwapError>;
+
+type UseRepayWithSupplyRequest = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Orchestrate the repay with supply execution plan.
+ *
+ * ```tsx
+ * 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 useRepayWithSupply(handler: PositionSwapHandler): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+type UseRepayWithSupplyQuoteArgs = Prettify<RepayWithSupplyQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a quote for a repay with supply operation with the specified parameters.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a repay with supply operation with the specified parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a repay with supply operation with the specified parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useRepayWithSupplyQuote(args: UseRepayWithSupplyQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a quote for a repay with supply operation with the specified parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useRepayWithSupplyQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyPosition: userBorrowItem.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useRepayWithSupplyQuote(args: Pausable<UseRepayWithSupplyQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * Low-level hook to execute a repay with supply quote action directly.
+ *
+ * @remarks
+ * This hook **does not** actively watch for updated data on the swap quote.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow.
+ *
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useRepayWithSupplyQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   repayWithReserve: reserve.id,
+ *   debtPosition: userBorrowItem.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Repay with supply quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useRepayWithSupplyQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<RepayWithSupplyQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type UseSupplySwapRequest = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Orchestrate the supply swap execution plan.
+ *
+ * ```tsx
+ * const [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 swapSupply({
+ *   market: {
+ *     sellPosition: supplyPosition.id,
+ *     buyReserve: targetReserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *     enableCollateral: true,
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
+ * ```
+ */
+declare function useSupplySwap(handler: PositionSwapHandler): UseAsyncTask<SupplySwapQuoteRequest, SwapReceipt, SwapSignerError | SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+type UseSupplySwapQuoteArgs = Prettify<SupplySwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a quote for a supply swap operation with the specified parameters.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSupplySwapQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSupplySwapQuote(args: UseSupplySwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a supply swap operation with the specified parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSupplySwapQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSupplySwapQuote(args: Pausable<UseSupplySwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * Fetch a quote for a supply swap operation with the specified parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSupplySwapQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ * });
+ * ```
+ */
+declare function useSupplySwapQuote(args: UseSupplySwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * Fetch a quote for a supply swap operation with the specified parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSupplySwapQuote({
+ *   market: {
+ *     sellPosition: userSupplyItem.id,
+ *     buyReserve: reserve.id,
+ *     amount: bigDecimal('1000'),
+ *     user: evmAddress('0x742d35cc…'),
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSupplySwapQuote(args: Pausable<UseSupplySwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * Low-level hook to execute a supply swap quote action directly.
+ *
+ * @remarks
+ * This hook **does not** actively watch for updated data on the swap quote.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow.
+ *
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useSupplySwapQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   sellPosition: userSupplyItem.id,
+ *   buyReserve: reserve.id,
+ *   amount: bigDecimal('1000'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Supply swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useSupplySwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<SupplySwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type UseSwappableTokensArgs = SwappableTokensRequest;
+/**
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: UseSwappableTokensArgs & Suspendable): SuspenseResult<Token[]>;
+/**
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs> & Suspendable): PausableSuspenseResult<Token[]>;
+/**
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: UseSwappableTokensArgs): ReadResult<Token[]>;
+/**
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs>): PausableReadResult<Token[]>;
+
+type UseSwapStatusArgs = Prettify<SwapStatusRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
+/**
+ * Monitor the status of a single swap operation in real-time.
+ *
+ * Polls automatically until the swap reaches a terminal state (fulfilled, cancelled, or expired).
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSwapStatus(args: UseSwapStatusArgs & Suspendable): SuspenseResult<SwapStatus>;
+/**
+ * Monitor the status of a single swap operation in real-time.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   suspense: true,
+ *   pause: shouldPause,
+ * });
+ * ```
+ */
+declare function useSwapStatus(args: Pausable<UseSwapStatusArgs> & Suspendable): PausableSuspenseResult<SwapStatus>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * 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 } = useSwapQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
- *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
+ * const { data, error, loading } = useSwapStatus({
+ *   id: swapReceipt.id,
  * });
  * ```
  */
-declare function useSwapQuote(args: UseSwapQuoteArgs): ReadResult<SwapQuote>;
+declare function useSwapStatus(args: UseSwapStatusArgs): ReadResult<SwapStatus>;
 /**
- * @internal
- * Fetch a swap quote for the specified trade parameters.
+ * Monitor the status of a single swap operation in real-time.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useSwapQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
- *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
- *   from: evmAddress('0x742d35cc...'),
- *   pause: true,
+ * const { data, error, loading, paused } = useSwapStatus({
+ *   id: swapReceipt.id,
+ *   pause: shouldPause,
  * });
  * ```
  */
-declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+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>;
 /**
- * @internal
- * Low-level hook to execute a swap quote action directly.
+ * Orchestrate the token swap execution plan.
  *
- * @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).
+ * ```tsx
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * ```ts
- * const [getQuote, { called, data, error, loading }] = useSwapQuoteAction();
+ * const [swap, { loading, error }] = useTokenSwap((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'Erc20Approval':
+ *       if (plan.bySignature) {
+ *         return signTypedData(plan.bySignature);
+ *       }
+ *       return sendTransaction(plan.byTransaction);
  *
- * // …
+ *     case 'SwapTransactionRequest':
+ *       return sendTransaction(plan.transaction);
  *
- * const result = await getQuote({
- *   chainId: chainId(1),
- *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *   sell: { erc20: evmAddress('0x6B175474E...') },
- *   amount: bigDecimal('1000'),
- *   kind: SwapKind.SELL,
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
+ *   }
  * });
  *
- * if (result.isOk()) {
- *   console.log('Swap quote:', result.value);
- * } else {
+ * const result = await swap({
+ *   fromQuote: {
+ *     quoteId: quote.quoteId,
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
  *   console.error(result.error);
+ *   return;
  * }
+ *
+ * // result.value: SwapReceipt
  * ```
  */
-declare function useSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<SwapQuoteRequest, SwapQuote, UnexpectedError$1>;
-type UseSwappableTokensArgs = SwappableTokensRequest;
+declare function useTokenSwap(handler: TokenSwapHandler): UseAsyncTask<UseTokenSwapRequest, SwapReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError | InsufficientLiquidityError>>;
+
+type UseTokenSwapQuoteArgs = Prettify<TokenSwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
+ * Fetch a swap quote for the specified trade parameters.
  *
  * This signature supports React Suspense:
  *
  * ```tsx
- * const { data } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * 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 useSwappableTokens(args: UseSwappableTokensArgs & Suspendable): SuspenseResult<Token[]>;
+declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
+ * Fetch a swap quote for the specified trade parameters.
  *
  * Pausable suspense mode.
  *
  * ```tsx
- * const { data } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * 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 useSwappableTokens(args: Pausable<UseSwappableTokensArgs> & Suspendable): PausableSuspenseResult<Token[]>;
+declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
+ * Fetch a swap quote for the specified trade parameters.
  *
  * ```tsx
- * const { data, error, loading } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * 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 useSwappableTokens(args: UseSwappableTokensArgs): ReadResult<Token[]>;
+declare function useTokenSwapQuote(args: UseTokenSwapQuoteArgs): ReadResult<SwapQuote>;
 /**
- * @internal
- * Fetch the list of tokens available for swapping on a specific chain.
+ * Fetch a swap quote for the specified trade parameters.
  *
  * Pausable loading state mode.
  *
  * ```tsx
- * const { data, error, loading, paused } = useSwappableTokens({
- *   query: { chainIds: [chainId(1)] },
+ * 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 useSwappableTokens(args: Pausable<UseSwappableTokensArgs>): PausableReadResult<Token[]>;
-type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions>;
+declare function useTokenSwapQuote(args: Pausable<UseTokenSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * Low-level hook to execute a swap quote action directly.
+ *
+ * @remarks
+ * This hook **does not** actively watch for updated data on the swap quote.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow
+ * (e.g., in an event handler to get a fresh quote before executing a swap).
+ *
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useTokenSwapQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6…') },
+ *     sell: { erc20: evmAddress('0x6B175474E…') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.Sell,
+ *   },
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useTokenSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<TokenSwapQuoteRequest, SwapQuote, UnexpectedError$1 | ValidationError<InsufficientLiquidityError>>;
+
+type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
- * @internal
  * Fetch the user's swap history for a specific chain.
  *
  * This signature supports React Suspense:
@@ -1284,7 +1953,7 @@ type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions>;
  * ```tsx
  * const { data } = useUserSwaps({
  *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
+ *   user: evmAddress('0x742d35cc…'),
  *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
  *   suspense: true,
  * });
@@ -1292,7 +1961,6 @@ type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions>;
  */
 declare function useUserSwaps(args: UseUserSwapsArgs & Suspendable): SuspenseResult<PaginatedUserSwapsResult>;
 /**
- * @internal
  * Fetch the user's swap history for a specific chain.
  *
  * Pausable suspense mode.
@@ -1300,7 +1968,7 @@ declare function useUserSwaps(args: UseUserSwapsArgs & Suspendable): SuspenseRes
  * ```tsx
  * const { data } = useUserSwaps({
  *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
+ *   user: evmAddress('0x742d35cc…'),
  *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
  *   suspense: true,
  *   pause: true,
@@ -1309,20 +1977,18 @@ declare function useUserSwaps(args: UseUserSwapsArgs & Suspendable): SuspenseRes
  */
 declare function useUserSwaps(args: Pausable<UseUserSwapsArgs> & Suspendable): PausableSuspenseResult<PaginatedUserSwapsResult>;
 /**
- * @internal
  * Fetch the user's swap history for a specific chain.
  *
  * ```tsx
  * const { data, error, loading } = useUserSwaps({
  *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
+ *   user: evmAddress('0x742d35cc…'),
  *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
  * });
  * ```
  */
 declare function useUserSwaps(args: UseUserSwapsArgs): ReadResult<PaginatedUserSwapsResult>;
 /**
- * @internal
  * Fetch the user's swap history for a specific chain.
  *
  * Pausable loading state mode.
@@ -1330,109 +1996,244 @@ declare function useUserSwaps(args: UseUserSwapsArgs): ReadResult<PaginatedUserS
  * ```tsx
  * const { data, error, loading, paused } = useUserSwaps({
  *   chainId: chainId(1),
- *   user: evmAddress('0x742d35cc...'),
+ *   user: evmAddress('0x742d35cc…'),
  *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
  *   pause: true,
  * });
  * ```
  */
 declare function useUserSwaps(args: Pausable<UseUserSwapsArgs>): PausableReadResult<PaginatedUserSwapsResult>;
-type UseSwapTokensRequest = Prettify<PrepareSwapRequest & CurrencyQueryOptions>;
-type SwapIntent = SwapByIntentTypedData | SwapByIntentWithApprovalRequired | SwapTransactionRequest | SwapApprovalRequired;
-type SwapHandlerOptions = {
-    cancel: CancelOperation;
-};
-type SwapHandler = (intent: SwapIntent, options: SwapHandlerOptions) => ResultAsync<ERC20PermitSignature | SwapReceipt, SendTransactionError | PendingTransactionError>;
+
+type UseWithdrawSwapRequest = Prettify<WithdrawSwapQuoteRequest & CurrencyQueryOptions>;
 /**
- * @internal
- * Orchestrate the swap execution plan.
+ * Orchestrate the withdraw swap execution plan.
  *
  * ```tsx
- * const [sendTransaction, sending] = useSendTransaction(wallet);
- * const [signSwapByIntentWith, signing] = useSignSwapByIntentWith(wallet);
+ * const [signTypedData] = useSignTypedData(wallet);
  *
- * const [swap, swapping] = useSwapTokens((plan) => {
+ * const [withdrawSwap, { loading, error }] = useWithdrawSwap((plan) => {
  *   switch (plan.__typename) {
- *     case 'SwapByIntentTypedData':
- *       return signSwapByIntentWith(plan);
- *
- *     case 'SwapApprovalRequired':
- *     case 'SwapByIntentWithApprovalRequired':
- *       return sendTransaction(plan.transaction);
+ *     case 'PositionSwapAdapterContractApproval':
+ *     case 'PositionSwapPositionManagerApproval':
+ *       return signTypedData(plan.bySignature);
  *
- *     case 'SwapTransactionRequest':
- *       return sendTransaction(plan.transaction);
+ *     case 'SwapTypedData':
+ *       return signTypedData(plan);
  *   }
  * });
  *
- * const result = await swap({
+ * const result = await withdrawSwap({
  *   market: {
- *     chainId: chainId(1),
- *     buy: { erc20: evmAddress('0xA0b86a33E6...') },
- *     sell: { erc20: evmAddress('0x6B175474E...') },
+ *     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'),
- *     kind: SwapKind.SELL,
- *     user: evmAddress('0x742d35cc...'),
+ *     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 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.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ *
+ * // data?.items: ActivityItem[] | undefined
+ * ```
+ */
+declare function useActivities(args: Pausable<UseActivitiesArgs> & Suspendable): PausableSuspenseResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
  *   },
+ *   user: evmAddress('0x742d35cc…'),
  * });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
- *
- * // 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 useActivities(args: UseActivitiesArgs): ReadResult<PaginatedActivitiesResult>;
 /**
- * @internal
- * Executes the complete swap cancellation workflow combining preparation and execution.
- *
- * ```tsx
- * const [sendTransaction] = useSendTransaction(wallet);
- * const [signSwapCancelWith] = useSignSwapCancelWith(wallet);
+ * Fetch paginated list of activities.
  *
- * const [cancelSwap, {loading, error}] = useCancelSwap((plan: CancelSwapTypedData | TransactionRequest) => {
- *   switch (plan.__typename) {
- *     case 'TransactionRequest':
- *       return sendTransaction(plan);
+ * Pausable loading state mode.
  *
- *     case 'CancelSwapTypedData':
- *       return signSwapCancelWith(plan);
- *   }
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
  * });
  *
- * const result = await cancelSwap({
- *   id: swapId('123...'),
- * });
+ * // 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.
  *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
+ * @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).
  *
- * // result.value: SwapCancelled
- * console.log('Swap cancelled:', result.value);
- * ```
+ * @param options - The query options.
+ * @returns The user history.
  */
-declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelled, CancelSwapError>;
+declare function useActivitiesAction(options?: CurrencyQueryOptions & TimeWindowQueryOptions): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
 
 /**
- * A hook that provides a way to supply assets to an Aave reserve.
+ * A hook that provides a way to borrow assets from an Aave reserve.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [supply, { loading, error }] = useSupply((plan, { cancel }) => {
+ * const [borrow, { loading, error }] = useBorrow((plan, { cancel }) => {
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1440,7 +2241,7 @@ declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<Prepare
  *
  * // …
  *
- * const result = await supply({ ... });
+ * const result = await borrow({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1471,30 +2272,29 @@ declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<Prepare
  *   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 useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequest, 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 borrow assets from an Aave reserve.
+ * A hook that provides a way to claim rewards.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [borrow, { loading, error }] = useBorrow((plan, { cancel }) => {
- *   switch (plan.__typename) {
- *     case 'TransactionRequest':
- *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
- *     case 'PreContractActionRequired':
- *       return sendTransaction(plan.transaction);
- *   }
+ * const [claim, { loading, error }] = useClaimRewards((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
  * });
  *
  * // …
  *
- * const result = await borrow({ ... });
+ * const result = await claim({
+ *   ids: [rewardId('abc123')],
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x9abc…'),
+ * });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1514,10 +2314,6 @@ declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequ
  *       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;
@@ -1525,22 +2321,26 @@ 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.
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequest, 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 repay borrowed assets to an Aave reserve.
+ * A hook that provides a way to liquidate a user's position.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [repay, { loading, error }] = useRepay((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);
  *   }
@@ -1548,7 +2348,13 @@ declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequ
  *
  * // …
  *
- * const result = await repay({ ... });
+ * const result = await liquidatePosition({
+ *   collateral: reserveId('SGVsbG8h'),
+ *   debt: reserveId('Q2lhbyE= '),
+ *   amount: amount,
+ *   liquidator: liquidator,
+ *   borrower: borrower,
+ * });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1579,30 +2385,153 @@ 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.
  */
-declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayRequest, 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 withdraw supplied assets from an Aave reserve.
+ * 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;
+ *
+ * // …
+ *
+ * const result = await getPreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           value: '1000',
+ *         },
+ *       },
+ *       sender: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Preview result:', result.value);
+ * ```
+ */
+declare function usePreviewAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<PreviewRequest, PreviewUserPosition, UnexpectedError>;
+type UsePreviewArgs = Prettify<PreviewRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: UsePreviewArgs & Suspendable): SuspenseResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: Pausable<UsePreviewArgs> & Suspendable): PausableSuspenseResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * ```tsx
+ * const { data, error, loading } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function usePreview(args: UsePreviewArgs): ReadResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
+
+/**
+ * A hook that provides a way to renounce a position manager of a user for a specific spoke.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [withdraw, { loading, error }] = useWithdraw((plan, { cancel }) => {
- *   switch (plan.__typename) {
- *     case 'TransactionRequest':
- *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
- *     case 'PreContractActionRequired':
- *       return sendTransaction(plan.transaction);
- *   }
- * });
+ * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
  *
  * // …
  *
- * const result = await withdraw({ ... });
+ * const result = await renounceSpokeUserPositionManager({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1622,10 +2551,6 @@ declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayReques
  *       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;
@@ -1633,22 +2558,34 @@ 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.
+ * @param handler - The handler that will be used to handle the transaction.
  */
-declare function useWithdraw(handler: TransactionHandler): UseAsyncTask<WithdrawRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+declare function useRenounceSpokeUserPositionManager(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * A hook that provides a way to renounce a position manager of a user for a specific spoke.
+ * A hook that provides a way to repay borrowed assets to an Aave reserve.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
+ * const [repay, { loading, error }] = useRepay((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
  *
  * // …
  *
- * const result = await renounceSpokeUserPositionManager({ ... });
+ * const result = await repay({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1668,6 +2605,10 @@ declare function useWithdraw(handler: TransactionHandler): UseAsyncTask<Withdraw
  *       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;
@@ -1675,27 +2616,42 @@ declare function useWithdraw(handler: TransactionHandler): UseAsyncTask<Withdraw
  *   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.
+ * @param handler - The handler that will be used to handle the transactions.
  */
-declare function useRenounceSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function useRepay(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<RepayRequest, TransactionReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+
 /**
- * Hook for updating user position conditions (dynamic config and/or risk premium).
+ * A hook that provides a way to set or remove a position manager for a user on a specific spoke.
+ *
+ * **Position managers** can perform transactions on behalf of other users, including:
+ * - Supply assets
+ * - Borrow assets
+ * - Withdraw assets
+ * - Enable/disable collateral
+ *
+ * The `signature` parameter is an **ERC712 signature** that must be signed by the **user**
+ * (the account granting permissions) to authorize the position manager. The signature contains:
+ * - `value`: The actual cryptographic signature
+ * - `deadline`: Unix timestamp when the authorization expires
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [update, { loading, error }] = useUpdateUserPositionConditions((transaction, { cancel }) => {
+ * const [setSpokeUserPositionManager, { loading, error }] = useSetSpokeUserPositionManager((transaction, { cancel }) => {
  *   return sendTransaction(transaction);
  * });
  *
- * // …
- *
- * const result = await update({
- *   userPositionId: userPosition.id,
- *   dynamicConfig: true,
- *   riskPremium: true,
+ * const result = await setSpokeUserPositionManager({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   manager: evmAddress('0x9abc…'), // Address that will become the position manager
+ *   approve: true, // true to approve, false to remove the manager
+ *   user: evmAddress('0xdef0…'), // User granting the permission (must sign the signature)
+ *   signature: {
+ *     value: '0x1234...', // ERC712 signature signed by the user
+ *     deadline: 1735689600, // Unix timestamp when signature expires
+ *   },
  * });
  *
  * if (result.isErr()) {
@@ -1723,12 +2679,13 @@ declare function useRenounceSpokeUserPositionManager(handler: TransactionHandler
  *   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 useUpdateUserPositionConditions(handler: TransactionHandler): UseAsyncTask<UpdateUserPositionConditionsRequest, TxHash, SendTransactionError | PendingTransactionError>;
+declare function useSetSpokeUserPositionManager(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetSpokeUserPositionManagerRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
  * Hook for updating the collateral status of user's supplies.
  *
@@ -1773,22 +2730,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 useSetUserSuppliesAsCollateral(handler: ExecutionPlanHandler<TransactionRequest, PendingTransaction>): UseAsyncTask<SetUserSuppliesAsCollateralRequest, TransactionReceipt, SendTransactionError | PendingTransactionError>;
+
 /**
- * A hook that provides a way to liquidate a user's position.
+ * A hook that provides a way to supply assets to an Aave reserve.
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [liquidatePosition, { loading, error }] = useLiquidatePosition((plan, { cancel }) => {
+ * const [supply, { loading, error }] = useSupply((plan, { cancel }) => {
  *   switch (plan.__typename) {
  *     case 'TransactionRequest':
  *       return sendTransaction(plan);
- *     case 'Erc20ApprovalRequired':
+ *
+ *     case 'Erc20Approval':
+ *       return sendTransaction(plan.byTransaction);
+ *
  *     case 'PreContractActionRequired':
  *       return sendTransaction(plan.transaction);
  *   }
@@ -1796,13 +2757,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 supply({ ... });
  *
  * if (result.isErr()) {
  *   switch (result.error.name) {
@@ -1833,41 +2788,27 @@ 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 useSupply(handler: ExecutionPlanHandler<TransactionRequest | Erc20Approval | PreContractActionRequired, Signature | PendingTransaction>): UseAsyncTask<SupplyRequest, 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.
- *
- * **Position managers** can perform transactions on behalf of other users, including:
- * - Supply assets
- * - Borrow assets
- * - Withdraw assets
- * - Enable/disable collateral
- *
- * The `signature` parameter is an **ERC712 signature** that must be signed by the **user**
- * (the account granting permissions) to authorize the position manager. The signature contains:
- * - `value`: The actual cryptographic signature
- * - `deadline`: Unix timestamp when the authorization expires
+ * Hook for updating user position conditions (dynamic config and/or risk premium).
  *
  * ```ts
  * const [sendTransaction] = useSendTransaction(wallet);
- * const [setSpokeUserPositionManager, { loading, error }] = useSetSpokeUserPositionManager((transaction, { cancel }) => {
+ * const [update, { loading, error }] = useUpdateUserPositionConditions((transaction, { cancel }) => {
  *   return sendTransaction(transaction);
  * });
  *
- * const result = await setSpokeUserPositionManager({
- *   spoke: spokeId('SGVsbG8h'),
- *   manager: evmAddress('0x9abc…'), // Address that will become the position manager
- *   approve: true, // true to approve, false to remove the manager
- *   user: evmAddress('0xdef0…'), // User granting the permission (must sign the signature)
- *   signature: {
- *     value: '0x1234...', // ERC712 signature signed by the user
- *     deadline: 1735689600, // Unix timestamp when signature expires
- *   },
+ * // …
+ *
+ * const result = await update({
+ *   userPositionId: userPosition.id,
+ *   update: UserPositionConditionsUpdate.AllDynamicConfig,
  * });
  *
  * if (result.isErr()) {
@@ -1888,231 +2829,74 @@ declare function useLiquidatePosition(handler: TransactionHandler): UseAsyncTask
  *       console.error(`Transaction failed: ${result.error.message}`);
  *       break;
  *
- *     case 'UnexpectedError':
- *       console.error(result.error.message);
- *       break;
- *   }
- *   return;
- * }
- *
- * console.log('Transaction sent with hash:', result.value);
- * ```
- *
- * @param handler - The handler that will be used to handle the transaction.
- */
-declare function useSetSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<SetSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
-/**
- * Preview the impact of a potential action on a user's position.
- *
- * ```tsx
- * const [getPreview, previewing] = usePreviewAction();
- *
- * const loading = previewing.loading;
- * const error = previewing.error;
- *
- * // …
- *
- * const result = await getPreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           value: '1000',
- *         },
- *       },
- *       sender: evmAddress('0x9abc…'),
- *     },
- *   },
- * });
- *
- * if (result.isErr()) {
- *   console.error(result.error);
- *   return;
- * }
- *
- * console.log('Preview result:', result.value);
- * ```
- */
-declare function usePreviewAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<PreviewRequest, PreviewUserPosition, UnexpectedError>;
-type UsePreviewArgs = Prettify<PreviewRequest & CurrencyQueryOptions>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
- *
- * This signature supports React Suspense:
- *
- * ```tsx
- * const { data } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   suspense: true,
- * });
- * ```
- */
-declare function usePreview(args: UsePreviewArgs & Suspendable): SuspenseResult<PreviewUserPosition>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
- *
- * Pausable suspense mode.
- *
- * ```tsx
- * const { data } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   suspense: true,
- *   pause: true,
- * });
- * ```
- */
-declare function usePreview(args: Pausable<UsePreviewArgs> & Suspendable): PausableSuspenseResult<PreviewUserPosition>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
- *
- * ```tsx
- * const { data, error, loading } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- * });
- * ```
- */
-declare function usePreview(args: UsePreviewArgs): ReadResult<PreviewUserPosition>;
-/**
- * Fetch a preview of the impact of a potential action on a user's position.
- *
- * Pausable loading state mode.
- *
- * ```tsx
- * const { data, error, loading, paused } = usePreview({
- *   action: {
- *     supply: {
- *       reserve: reserveId('SGVsbG8h'),
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       supplier: evmAddress('0x9abc…'),
- *     },
- *   },
- *   pause: true,
- * });
- * ```
- */
-declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
-type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions & 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.
- *
- * Pausable suspense mode.
- *
- * ```tsx
- * const { data } = useActivities({
- *   query: {
- *     chainId: chainId(1),
- *   },
- *   user: evmAddress('0x742d35cc…'),
- *   suspense: true,
- *   pause: true,
- * });
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
  *
- * // data?.items: ActivityItem[] | undefined
+ * console.log('Transaction sent with hash:', result.value.txHash);
  * ```
- */
-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…'),
- * });
- * ```
+ * @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>;
 /**
@@ -2227,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.
@@ -2334,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.
@@ -2597,6 +3381,69 @@ declare function useUserBalances(args: UseUserBalancesArgs): ReadResult<UserBala
  * ```
  */
 declare function useUserBalances(args: Pausable<UseUserBalancesArgs>): PausableReadResult<UserBalance[]>;
+type UseUserRiskPremiumBreakdownArgs = UserRiskPremiumBreakdownRequest;
+/**
+ * Fetch the risk premium breakdown for a user position or spoke.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserRiskPremiumBreakdown({
+ *   query: {
+ *     userPositionId: userPositionId('SGVsbG8h'),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserRiskPremiumBreakdown(args: UseUserRiskPremiumBreakdownArgs & Suspendable): SuspenseResult<UserRiskPremiumBreakdownItem[]>;
+/**
+ * Fetch the risk premium breakdown for a user position or spoke.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserRiskPremiumBreakdown({
+ *   query: {
+ *     userPositionId: userPositionId('SGVsbG8h'),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserRiskPremiumBreakdown(args: Pausable<UseUserRiskPremiumBreakdownArgs> & Suspendable): PausableSuspenseResult<UserRiskPremiumBreakdownItem[]>;
+/**
+ * Fetch the risk premium breakdown for a user position or spoke.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserRiskPremiumBreakdown({
+ *   query: {
+ *     userPositionId: userPositionId('SGVsbG8h'),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ * ```
+ */
+declare function useUserRiskPremiumBreakdown(args: UseUserRiskPremiumBreakdownArgs): ReadResult<UserRiskPremiumBreakdownItem[]>;
+/**
+ * Fetch the risk premium breakdown for a user position or spoke.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserRiskPremiumBreakdown({
+ *   query: {
+ *     userPositionId: userPositionId('SGVsbG8h'),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserRiskPremiumBreakdown(args: Pausable<UseUserRiskPremiumBreakdownArgs>): PausableReadResult<UserRiskPremiumBreakdownItem[]>;
 /**
  * Low-level hook to execute a {@link userBalances} action directly.
  *
@@ -2686,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 UseAssetPriceHistoryArgs, type UseAssetSupplyHistoryArgs, UseAsyncTask, type UseBorrowApyHistoryArgs, type UseHubArgs, type UseHubAssetsArgs, 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 UseUserSummaryArgs, type UseUserSummaryHistoryArgs, type UseUserSuppliesArgs, type UseUserSwapsArgs, useAaveClient, useActivities, useActivitiesAction, useAsset, useAssetBorrowHistory, useAssetPriceHistory, useAssetSupplyHistory, useBorrow, useBorrowApyHistory, useCancelSwap, useHub, useHubAssets, useHubs, useHubsAction, useLiquidatePosition, usePermitTypedDataAction, usePreview, usePreviewAction, 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, 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 };