@aave/client 0.7.0 → 4.0.0-next.0

package/dist/actions/index.d.ts

@@ -1,412 +1,576 @@
-import * as _aave_core from '@aave/core';
-import { UnexpectedError } from '@aave/core';
-import * as _aave_graphql from '@aave/graphql';
-import { SavingsGhoBalanceRequest, TokenAmount, SavingsGhoWithdrawRequest, ExecutionPlan, SavingsGhoDepositRequest, UserMeritRewardsRequest, MarketReservesRequestOrderBy, Market, UserMarketStateRequest, MarketUserState, ChainsFilter, Chain, UsdExchangeRatesRequest, UsdExchangeRate, HasProcessedKnownTransactionRequest, HealthFactorPreviewRequest, HealthFactorPreviewResponse, PermitTypedDataRequest, PermitTypedDataResponse, ReserveRequest, Reserve, BorrowAPYHistoryRequest, APYSample, SupplyAPYHistoryRequest, BorrowRequest, SupplyRequest, RepayRequest, WithdrawRequest, UserSetEmodeRequest, TransactionRequest, VaultDepositRequest, VaultRedeemSharesRequest, VaultDeployRequest, VaultSetFeeRequest, VaultWithdrawFeesRequest, VaultWithdrawRequest, VaultMintSharesRequest, CollateralToggleRequest, LiquidateRequest, ApproveBorrowCreditDelegatorRequest, CreditDelegateeAmountRequest, UserSuppliesRequest, MarketUserReserveSupplyPosition, UserBorrowsRequest, MarketUserReserveBorrowPosition, UserTransactionHistoryRequest, PaginatedUserTransactionHistoryResult, VaultRequest, Vault, VaultsRequest, PaginatedVaultsResult, UserVaultsRequest, VaultPreviewDepositRequest, VaultPreviewMintRequest, VaultPreviewWithdrawRequest, VaultPreviewRedeemRequest, VaultUserTransactionHistoryRequest, PaginatedVaultUserTransactionHistoryResult, VaultUserActivityRequest, VaultUserActivityResult, VaultTransferOwnershipRequest, VaultCreateRecipientsConfigurationRequest, VaultRecipientConfigurationRequest, VaultFeesRecipientsConfiguration, VaultSetRecipientsConfigurationRequest } from '@aave/graphql';
-import * as _aave_types from '@aave/types';
-import { ResultAsync, ChainId, EvmAddress } from '@aave/types';
-import { A as AaveClient } from '../AaveClient-C-OkXfVz.js';
+import { UnexpectedError, TimeoutError } from '@aave/core';
+import { HubRequest, Hub, HubsRequest, HubAssetsRequest, HubAsset, ChainRequest, Chain, ChainsFilter, HasProcessedKnownTransactionRequest, ExchangeRateRequest, FiatAmount, PermitRequest, PermitTypedDataResponse, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, ReserveRequest, Reserve, ReservesRequest, BorrowAPYHistoryRequest, APYSample, SupplyAPYHistoryRequest, SpokeRequest, Spoke, SpokesRequest, SpokePositionManagersRequest, PaginatedSpokePositionManagerResult, SpokeUserPositionManagersRequest, PaginatedSpokeUserPositionManagerResult, SwapQuoteRequest, SwapQuote, SwappableTokensRequest, Token, PrepareSwapRequest, PrepareSwapResult, SwapStatusRequest, SwapStatus, SwapCancelled, SwapExpired, SwapFulfilled, SwapReceipt, SwapRequest, SwapExecutionPlan, PrepareSwapCancelRequest, PrepareSwapCancelResult, CancelSwapRequest, CancelSwapExecutionPlan, UserSwapsRequest, PaginatedUserSwapsResult, BorrowRequest, ExecutionPlan, SupplyRequest, RepayRequest, WithdrawRequest, RenounceSpokeUserPositionManagerRequest, TransactionRequest, UpdateUserDynamicConfigRequest, UpdateUserRiskPremiumRequest, LiquidatePositionRequest, SetSpokeUserPositionManagerRequest, PreviewRequest, PreviewUserPosition, SetUserSupplyAsCollateralRequest, ActivitiesRequest, PaginatedActivitiesResult, UserSuppliesRequest, UserSupplyItem, UserBorrowsRequest, UserBorrowItem, UserSummaryRequest, UserSummary, UserPositionsRequest, UserPosition, UserPositionRequest, UserBalancesRequest, UserBalance, UserSummaryHistoryRequest, UserSummaryHistoryItem } from '@aave/graphql';
+import { ResultAsync, Prettify } from '@aave/types';
+import { A as AaveClient } from '../AaveClient-CgHY2iS9.js';
+import { C as CurrencyQueryOptions, R as RequestPolicyOptions, T as TimeWindowQueryOptions } from '../options-vB2peXdE.js';
 import '@urql/core';
-import '../types-ieyj0UmJ.js';
+import '../types-Bu63z0x6.js';
 
 /**
- * Fetches the current sGHO balance for a user.
+ * Fetches a specific hub by ID or by address and chain ID.
  *
  * ```ts
- * const result = await savingsGhoBalance(client, {
- *   user: evmAddress('0x742d35cc…'),
+ * const result = await hub(client, {
+ *   query: { hubId: hubId('SGVsbG8h') }
  * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The sGHO balance request parameters.
- * @returns The user's sGHO balance.
+ * @param request - The hub request parameters.
+ * @param options - The query options.
+ * @returns The hub data, or null if not found.
  */
-declare function savingsGhoBalance(client: AaveClient, request: SavingsGhoBalanceRequest): ResultAsync<TokenAmount, UnexpectedError>;
+declare function hub(client: AaveClient, request: HubRequest, options?: CurrencyQueryOptions & RequestPolicyOptions): ResultAsync<Hub | null, UnexpectedError>;
 /**
- * Creates a transaction to withdraw sGHO.
+ * Fetches multiple hubs based on specified criteria.
  *
  * ```ts
- * const result = await savingsGhoWithdraw(client, {
- *   amount: {
- *     exact: '1000',
- *   },
- *   sharesOwner: evmAddress('0x9abc…'),
- * }).andThen(sendWith(wallet))
+ * const result = await hubs(client, {
+ *   query: {
+ *     chainIds: [chainId(1)]
+ *   }
+ * });
+ * ```
  *
- * if (result.isErr()) {
- *   // Handle error, e.g. signing error, etc.
- *   return;
- * }
+ * @param client - Aave client.
+ * @param request - The hubs request parameters (either tokens or chainIds).
+ * @param options - The query options.
+ * @returns Array of hub data.
+ */
+declare function hubs(client: AaveClient, request: HubsRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<Hub[], UnexpectedError>;
+/**
+ * Fetches hub assets for a specific hub by ID or by address and chain ID.
  *
- * // result.value: TxHash
+ * ```ts
+ * const result = await hubAssets(client, {
+ *   query: { hubId: hubId('SGVsbG8h') },
+ * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The sGHO withdraw request parameters.
- * @returns The transaction request data to withdraw sGHO.
+ * @param request - The hub assets request parameters.
+ * @param options - The query options.
+ * @returns The hub assets array.
  */
-declare function savingsGhoWithdraw(client: AaveClient, request: SavingsGhoWithdrawRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
+declare function hubAssets(client: AaveClient, request: HubAssetsRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<HubAsset[], UnexpectedError>;
+
 /**
- * Creates a transaction to deposit GHO into sGHO.
+ * Fetches a specific chain by chain ID.
  *
  * ```ts
- * const result = await savingsGhoDeposit(client, {
- *   amount: {
- *     value: '1000',
- *   },
- *   depositor: evmAddress('0x9abc…'),
- * }).andThen(sendWith(wallet))
+ * const result = await chain(client, {
+ *   chainId: chainId(1),
+ * });
+ * ```
  *
- * if (result.isErr()) {
- *   // Handle error, e.g. insufficient balance, signing error, etc.
- *   return;
- * }
+ * @param client - Aave client.
+ * @param request - The chain request parameters.
+ * @returns The chain data, or null if not found.
+ */
+declare function chain(client: AaveClient, request: ChainRequest): ResultAsync<Chain | null, UnexpectedError>;
+/**
+ * Fetches the list of supported chains.
  *
- * // result.value: TxHash
+ * ```ts
+ * const chains = await chains(client, { filter: ChainsFilter.ALL });
  * ```
  *
  * @param client - Aave client.
- * @param request - The sGHO deposit request parameters.
- * @returns The transaction data, approval requirements, or insufficient balance error.
+ * @param filter - The filter for chains.
+ * @returns Array of supported chains.
+ */
+declare function chains(client: AaveClient, filter?: ChainsFilter): ResultAsync<Chain[], UnexpectedError>;
+/**
+ * Check if a transaction has been processed by the Aave API.
+ *
+ * @param client - Aave client.
+ * @param request - The request containing transaction hash and operations to check.
+ * @returns True if the transaction has been processed, false otherwise.
+ */
+declare function hasProcessedKnownTransaction(client: AaveClient, request: HasProcessedKnownTransactionRequest): ResultAsync<boolean, UnexpectedError>;
+/**
+ * Fetches the exchange rate between tokens and fiat currencies.
+ *
+ * ```ts
+ * const result = await exchangeRate(client, {
+ *   from: { erc20: { chainId: chainId(1), address: evmAddress('0xA0b86a33E6...') } },
+ *   to: Currency.Usd,
+ * });
+ * ```
+ *
+ * @param client - Aave client.
+ * @param request - The exchange rate request parameters.
+ * @returns The exchange rate information as a fiat amount.
  */
-declare function savingsGhoDeposit(client: AaveClient, request: SavingsGhoDepositRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
+declare function exchangeRate(client: AaveClient, request: ExchangeRateRequest): ResultAsync<FiatAmount, UnexpectedError>;
 
 /**
- * Fetches Merit rewards for a user with the transaction request to claim them.
+ * Generates EIP-712 typed data for permit signatures.
  *
  * ```ts
- * const result = await userMeritRewards(client, {
- *   user: evmAddress('0x742d35cc…'),
- *   chainId: chainId(1),
+ * const result = await permitTypedData(client, {
+ *   spender: evmAddress('0x87870bca…'),
+ *   currency: evmAddress('0xa0b86991c431c924b2047c7094daf21b77e…'),
+ *   amount: '1000.5',
  * });
+ *
+ * if (result.isOk()) {
+ *   // Use the typed data to create a signature
+ *   const signature = await wallet.signTypedData(result.value);
+ * }
  * ```
  *
  * @param client - Aave client.
- * @param request - The merit claim rewards request parameters.
- * @returns The rewards with the transaction request.
+ * @param request - The permit request parameters.
+ * @returns The EIP-712 typed data for permit signature.
  */
-declare function userMeritRewards(client: AaveClient, request: UserMeritRewardsRequest): _aave_types.ResultAsync<{
-    __typename: "UserMeritRewards";
-    chain: _aave_types.ChainId;
-    claimable: {
-        __typename: "ClaimableMeritReward";
-        amount: {
-            __typename: "TokenAmount";
-            usdPerToken: _aave_types.BigDecimal;
-            amount: {
-                __typename: "DecimalValue";
-                raw: _aave_types.BigIntString;
-                decimals: number;
-                value: _aave_types.BigDecimal;
-            };
-            usd: _aave_types.BigDecimal;
-        };
-        currency: {
-            __typename: "Currency";
-            address: _aave_types.EvmAddress;
-            imageUrl: string;
-            name: string;
-            symbol: string;
-            decimals: number;
-            chainId: _aave_types.ChainId;
-        };
-    }[];
-    transaction: {
-        __typename: "TransactionRequest";
-        to: _aave_types.EvmAddress;
-        from: _aave_types.EvmAddress;
-        data: _aave_types.BlockchainData;
-        value: _aave_types.BigIntString;
-        chainId: _aave_types.ChainId;
-        operation: _aave_graphql.OperationType | null;
-    };
-} | null, _aave_core.UnexpectedError>;
+declare function permitTypedData(client: AaveClient, request: PermitRequest): ResultAsync<PermitTypedDataResponse, UnexpectedError>;
 
-declare const defaultMarketReservesRequestOrderBy: MarketReservesRequestOrderBy;
-type MarketsRequest = {
-    /**
-     * The markets you want to see based on the chain ids.
-     */
-    chainIds: ChainId[];
-    /**
-     * The user viewing the market (e.g., the connected wallet).
-     *
-     * If not provided, user fields will not be included.
-     */
-    user?: EvmAddress;
-    /**
-     * The order by clause for the borrow reserves in the market.
-     *
-     * @defaultValue { tokenName: OrderDirection.Asc }
-     */
-    borrowsOrderBy?: MarketReservesRequestOrderBy;
-    /**
-     * The order by clause for the supply reserves in the market.
-     *
-     * @defaultValue { tokenName: OrderDirection.Asc }
-     */
-    suppliesOrderBy?: MarketReservesRequestOrderBy;
-};
 /**
- * Fetches all markets for the specified chain IDs.
+ * Fetches information about a specific asset (ERC20 token) in the protocol by ID or by token.
  *
  * ```ts
- * const result = await markets(client, {
- *   chainIds: [chainId(1), chainId(8453)],
+ * const result = await asset(client, {
+ *   query: { assetId: assetId('SGVsbG8h') }
  * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The markets request parameters.
- * @returns The list of markets.
+ * @param request - The asset request parameters.
+ * @param options - The query options including currency and time window.
+ * @returns The asset data, or null if not found.
  */
-declare function markets(client: AaveClient, { chainIds, borrowsOrderBy, suppliesOrderBy, user, }: MarketsRequest): ResultAsync<Market[], UnexpectedError>;
-type MarketRequest = {
-    /**
-     * The pool address for the market.
-     */
-    address: EvmAddress;
-    /**
-     * The chain id the market pool address is deployed on.
-     */
-    chainId: ChainId;
-    /**
-     * The user viewing the market (e.g., the connected wallet).
-     *
-     * If not provided, user fields will not be included.
-     */
-    user?: EvmAddress;
-    /**
-     * The order by clause for the borrow reserves in the market.
-     *
-     * @defaultValue { tokenName: OrderDirection.Asc }
-     */
-    borrowsOrderBy?: MarketReservesRequestOrderBy;
-    /**
-     * The order by clause for the supply reserves in the market.
-     *
-     * @defaultValue { tokenName: OrderDirection.Asc }
-     */
-    suppliesOrderBy?: MarketReservesRequestOrderBy;
-};
+declare function asset(client: AaveClient, request: AssetRequest, options?: CurrencyQueryOptions & TimeWindowQueryOptions & RequestPolicyOptions): ResultAsync<Asset | null, UnexpectedError>;
 /**
- * Fetches a specific market by address and chain ID.
+ * Fetches historical price data for a specific asset.
  *
  * ```ts
- * const result = await market(client, {
- *   address: evmAddress('0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2'),
- *   chainId: chainId(1),
+ * const result = await assetPriceHistory(client, {
+ *   token: { chainId: chainId(1), address: evmAddress('0x123…') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
  * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The market request parameters.
- * @returns The market data, or null if not found.
+ * @param request - The asset price history request parameters.
+ * @param options - The query options.
+ * @returns Array of asset price samples over time.
  */
-declare function market(client: AaveClient, { address, chainId, user, borrowsOrderBy, suppliesOrderBy, }: MarketRequest): ResultAsync<Market | null, UnexpectedError>;
+declare function assetPriceHistory(client: AaveClient, request: AssetPriceHistoryRequest, options?: Required<RequestPolicyOptions>): ResultAsync<AssetPriceSample[], UnexpectedError>;
 /**
- * Fetches user account market data across all reserves.
+ * Fetches historical supply data for a specific asset.
  *
  * ```ts
- * const result = await userMarketState(client, {
- *   market: evmAddress('0x1234…'),
- *   user: evmAddress('0x5678…'),
- *   chainId: chainId(1)
+ * const result = await assetSupplyHistory(client, {
+ *   token: { chainId: chainId(1), address: evmAddress('0x123…') },
+ *   window: TimeWindow.LastWeek,
  * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The user market state request parameters.
- * @returns The user's market state.
+ * @param request - The asset supply history request parameters.
+ * @param options - The query options.
+ * @returns Array of asset supply samples over time.
  */
-declare function userMarketState(client: AaveClient, request: UserMarketStateRequest): ResultAsync<MarketUserState, UnexpectedError>;
+declare function assetSupplyHistory(client: AaveClient, request: AssetSupplyHistoryRequest, options?: Required<RequestPolicyOptions>): ResultAsync<AssetSupplySample[], UnexpectedError>;
+/**
+ * Fetches historical borrow data for a specific asset.
+ *
+ * ```ts
+ * const result = await assetBorrowHistory(client, {
+ *   token: { chainId: chainId(1), address: evmAddress('0x123…') },
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ *
+ * @param client - Aave client.
+ * @param request - The asset borrow history request parameters.
+ * @param options - The query options.
+ * @returns Array of asset borrow samples over time.
+ */
+declare function assetBorrowHistory(client: AaveClient, request: AssetBorrowHistoryRequest, options?: Required<RequestPolicyOptions>): ResultAsync<AssetBorrowSample[], UnexpectedError>;
 
 /**
- * Health check query.
+ * Fetches a specific reserve by reserve ID, spoke, and chain.
  *
  * ```ts
- * const result = await health(client);
+ * const result = await reserve(client, {
+ *   reserve: reserveId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
  * ```
  *
  * @param client - Aave client.
- * @returns True or false
+ * @param request - The reserve request parameters.
+ * @param options - The query options.
+ * @returns The reserve data, or null if not found.
  */
-declare function health(client: AaveClient): ResultAsync<boolean, UnexpectedError>;
+declare function reserve(client: AaveClient, request: ReserveRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<Reserve | null, UnexpectedError>;
 /**
- * Fetches the list of supported chains.
+ * Fetches reserves based on specified criteria.
  *
  * ```ts
- * const result = await chains(client, ChainsFilter.MAINNET_ONLY);
+ * const result = await reserves(client, {
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   filter: ReservesRequestFilter.All,
+ *   orderBy: { name: 'ASC' }
+ * });
  * ```
  *
  * @param client - Aave client.
- * @param filter - The filter for the chains.
- * @returns The list of supported chains.
+ * @param request - The reserves request parameters.
+ * @param options - The query options.
+ * @returns Array of reserves matching the criteria.
  */
-declare function chains(client: AaveClient, filter?: ChainsFilter): ResultAsync<Chain[], UnexpectedError>;
+declare function reserves(client: AaveClient, request: ReservesRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<Reserve[], UnexpectedError>;
 /**
- * Fetches USD exchange rates for different tokens on a given market.
+ * Fetches borrow APY history for a specific reserve over time.
  *
  * ```ts
- * const result = await usdExchangeRates(client, {
- *   market: evmAddress('0x1234…'),
- *   underlyingTokens: [evmAddress('0x5678…'), evmAddress('0x90ab…')],
- *   chainId: chainId(1),
+ * const result = await borrowApyHistory(client, {
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek
  * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The USD exchange rates request parameters.
- * @returns The list of USD exchange rates.
+ * @param request - The borrow APY history request parameters.
+ * @returns The borrow APY history samples.
  */
-declare function usdExchangeRates(client: AaveClient, request: UsdExchangeRatesRequest): ResultAsync<UsdExchangeRate[], UnexpectedError>;
+declare function borrowApyHistory(client: AaveClient, request: BorrowAPYHistoryRequest): ResultAsync<APYSample[], UnexpectedError>;
 /**
- * Checks if the API has processed a known transaction hash.
+ * Fetches supply APY history for a specific reserve over time.
+ *
+ * ```ts
+ * const result = await supplyApyHistory(client, {
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek
+ * });
+ * ```
  *
- * This is useful to know when cached data has been invalidated after
- * a transaction is complete, as the API uses caching and has an
- * invalidation task that may take 100-200ms longer.
+ * @param client - Aave client.
+ * @param request - The supply APY history request parameters.
+ * @returns The supply APY history samples.
+ */
+declare function supplyApyHistory(client: AaveClient, request: SupplyAPYHistoryRequest): ResultAsync<APYSample[], UnexpectedError>;
+
+/**
+ * Fetches a specific spoke.
  *
  * ```ts
- * const result = await borrow(client, request)
- *   .andThen(sendWith(wallet))
- *   .andThen(client.waitForTransaction);
+ * const result = await spoke(client, {
+ *   query: { spokeId: spokeId('SGVsbG8h') }
+ * });
+ * ```
  *
- * if (result.isErr()) {
- *   // Handle error
- *   return;
- * }
+ * @param client - Aave client.
+ * @param request - The spoke request parameters.
+ * @returns The spoke data, or null if not found.
+ */
+declare function spoke(client: AaveClient, request: SpokeRequest): ResultAsync<Spoke | null, UnexpectedError>;
+/**
+ * Fetches spokes based on specified criteria.
  *
- * // Check if the transaction has been processed by the API
- * const processed = await hasProcessedKnownTransaction(client, {
- *   txHash: result.value,
- *   operation: OperationType.Borrow
+ * ```ts
+ * const result = await spokes(client, {
+ *   query: { chainIds: [chainId(1)] }
  * });
+ * ```
  *
- * if (processed.isErr()) {
- *   // Handle error
- *   return;
- * }
+ * @param client - Aave client.
+ * @param request - The spokes request parameters.
+ * @returns Array of spokes matching the criteria.
+ */
+declare function spokes(client: AaveClient, request: SpokesRequest): ResultAsync<Spoke[], UnexpectedError>;
+/**
+ * Fetches all positions manager for a specific spoke.
  *
- * if (processed.value) {
- *   // Transaction processed, cached data is up to date
- *   console.log('Transaction processed, data is fresh');
- * } else {
- *   // Transaction not yet processed, may need to wait
- *   console.log('Transaction not yet processed');
- * }
+ * ```ts
+ * const result = await spokePositionManagers(client, {
+ *   spoke: spokeId('SGVsbG8h'),
+ * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The request containing transaction hash and operation type to check.
- * @returns True if the transaction has been processed, false otherwise.
+ * @param request - The spokes request parameters.
+ * @returns Array of spokes matching the criteria.
  */
-declare function hasProcessedKnownTransaction(client: AaveClient, request: HasProcessedKnownTransactionRequest): ResultAsync<boolean, UnexpectedError>;
+declare function spokePositionManagers(client: AaveClient, request: SpokePositionManagersRequest): ResultAsync<PaginatedSpokePositionManagerResult, UnexpectedError>;
 /**
- * Fetches health factor preview for a given market action.
+ * Fetches all the positions managers of a user for a specific spoke.
  *
  * ```ts
- * const result = await healthFactorPreview(client, {
- *   action: {
- *     borrow: {
- *       market: market.address,
- *       amount: {
- *         erc20: {
- *           currency: evmAddress('0x5678…'),
- *           value: '1000',
- *         },
- *       },
- *       borrower: evmAddress('0x9abc…'),
- *       chainId: market.chain.chainId,
- *     },
- *   },
+ * const result = await spokeUserPositionManagers(client, {
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
  * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The health factor preview request parameters.
- * @returns The health factor preview response with before and after values.
+ * @param request - The spokes and pagination request parameters.
+ * @returns Array of position managers of a user for a specific spoke.
  */
-declare function healthFactorPreview(client: AaveClient, request: HealthFactorPreviewRequest): ResultAsync<HealthFactorPreviewResponse, UnexpectedError>;
+declare function spokeUserPositionManagers(client: AaveClient, request: SpokeUserPositionManagersRequest): ResultAsync<PaginatedSpokeUserPositionManagerResult, UnexpectedError>;
 
 /**
- * Generates EIP-712 typed data for ERC-20 permit signature.
+ * @internal
+ * Fetches a swap quote for the specified trade parameters.
  *
  * ```ts
- * const result = await permitTypedData(client, {
- *   market: evmAddress('0x87870bca...'),
- *   underlyingToken: evmAddress('0xa0b86a33...'),
- *   amount: '1.5',
+ * const result = await swapQuote(client, {
  *   chainId: chainId(1),
- *   spender: evmAddress('0x123...'),
- *   owner: evmAddress('0x456...'),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ *   from: evmAddress('0x742d35cc...'),
+ * });
+ * ```
+ *
+ * @param client - Aave client.
+ * @param request - The swap quote request parameters.
+ * @param options - The query options.
+ * @returns The swap quote including pricing and cost information.
+ */
+declare function swapQuote(client: AaveClient, request: SwapQuoteRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<SwapQuote, UnexpectedError>;
+/**
+ * @internal
+ * Fetches the list of tokens available for swapping on a specific chain.
+ *
+ * ```ts
+ * const result = await swappableTokens(client, {
+ *   query: { chainIds: [chainId(1)] },
+ * });
+ * ```
+ *
+ * @param client - Aave client.
+ * @param request - The swappable tokens request parameters.
+ * @returns The list of tokens available for swapping.
+ */
+declare function swappableTokens(client: AaveClient, request: SwappableTokensRequest): ResultAsync<Token[], UnexpectedError>;
+/**
+ * @internal
+ * Prepares a swap for the specified trade parameters.
+ *
+ * ```ts
+ * const result = await prepareSwap(client, {
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *     sell: { erc20: evmAddress('0x6B175474E...') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.SELL,
+ *     user: evmAddress('0x742d35cc...'),
+ *   },
+ * }).andThen(plan => {
+ *   switch (plan.__typename) {
+ *     case 'SwapByIntent':
+ *       return signSwapByIntentWith(plan.data)
+ *         .andThen((signature) => swap({ intent: { quoteId: quote.quoteId, signature } }))
+ *         .andThen((plan) => {
+ *           // …
+ *         });
+ *       );
+ *
+ *     case 'SwapByIntentWithApprovalRequired':
+ *       return sendTransaction(plan.transaction)
+ *         .andThen(signSwapByIntentWith(plan.data))
+ *         .andThen((signature) => swap({ intent: { quoteId: quote.quoteId, signature } }))
+ *         .andThen((plan) => {
+ *         // …
+ *         });
+ *       );
+ *
+ *     case 'SwapByTransaction':
+ *       return swap({ transaction: { quoteId: quote.quoteId } })
+ *         .andThen((plan) => {
+ *           // …
+ *         });
+ *       );
+ *
+ *     case 'InsufficientBalanceError':
+ *       return errAsync(new Error(`Insufficient balance: ${plan.required.value} required.`));
+ *   }
+ * });
+ * ```
+ *
+ * @param client - Aave client.
+ * @param request - The prepare swap request parameters.
+ * @param options - The query options.
+ * @returns The prepared swap result containing details of the swap.
+ */
+declare function prepareSwap(client: AaveClient, request: PrepareSwapRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<PrepareSwapResult, UnexpectedError>;
+/**
+ * @internal
+ * Fetches the status of a specific swap.
+ *
+ * ```ts
+ * const result = await swapStatus(client, {
+ *   id: swapId('swap_123'),
  * });
+ * ```
+ *
+ * @param client - Aave client.
+ * @param request - The swap status request parameters.
+ * @param options - The query options.
+ * @returns The current status of the swap.
+ */
+declare function swapStatus(client: AaveClient, request: SwapStatusRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<SwapStatus, UnexpectedError>;
+type SwapOutcome = SwapCancelled | SwapExpired | SwapFulfilled;
+/**
+ * @internal
+ * Waits for a swap to reach a final outcome (cancelled, expired, or fulfilled).
+ *
+ * ```ts
+ * const result = waitForSwapOutcome(client)(swapReceipt);
  *
  * if (result.isOk()) {
- *   const typedData = result.value;
- *   // Use typedData for permit signing
+ *   const outcome = result.value;
+ *   switch (outcome.__typename) {
+ *     case 'SwapFulfilled':
+ *       console.log('Swap completed successfully:', outcome.txHash);
+ *       break;
+ *     case 'SwapCancelled':
+ *       console.log('Swap was cancelled:', outcome.cancelledAt);
+ *       break;
+ *     case 'SwapExpired':
+ *       console.log('Swap expired:', outcome.expiredAt);
+ *       break;
+ *   }
+ * }
+ * ```
+ *
+ * @param client - Aave client configured with polling settings.
+ * @returns A function that takes a SwapReceipt and returns a ResultAsync with the final outcome.
+ */
+declare function waitForSwapOutcome(client: AaveClient): (receipt: SwapReceipt) => ResultAsync<SwapOutcome, TimeoutError | UnexpectedError>;
+/**
+ * @internal
+ * Executes a swap for the specified request parameters.
+ *
+ * ```ts
+ * const result = await swap(client, {
+ *   intent: {
+ *     quoteId: swapQuoteId('123...'),
+ *     signature: {
+ *       value: signature('0x456...'),
+ *       deadline: 1234567890,
+ *     },
+ *   },
+ * }).andThen((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'SwapTransactionRequest':
+ *       return sendTransaction(plan.transaction)
+ *         .map(() => plan.orderReceipt);
+ *
+ *     case 'SwapApprovalRequired':
+ *       return sendTransaction(plan.transaction)
+ *         .andThen(() => sendTransaction(plan.originalTransaction))
+ *         .map(() => plan.originalTransaction.orderReceipt);
+ *
+ *     case 'SwapReceipt':
+ *       return okAsync(plan.orderReceipt);
+ *
+ *     case 'InsufficientBalanceError':
+ *       return errAsync(new Error(`Insufficient balance: ${plan.required.value} required.`));
+ *   }
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
  * }
+ *
+ * console.log('Order receipt:', result.value);
  * ```
  *
  * @param client - Aave client.
- * @param request - The permit typed data request parameters.
- * @returns The EIP-712 typed data for permit signature.
+ * @param request - The swap request parameters.
+ * @returns The swap execution plan containing transaction details or receipt.
  */
-declare function permitTypedData(client: AaveClient, request: PermitTypedDataRequest): ResultAsync<PermitTypedDataResponse, UnexpectedError>;
-
+declare function swap(client: AaveClient, request: SwapRequest): ResultAsync<SwapExecutionPlan, UnexpectedError>;
 /**
- * Fetches a specific reserve by market address, token address, and chain ID.
+ * @internal
+ * Prepares a swap cancellation for the specified swap ID.
  *
  * ```ts
- * const result = await reserve(client, {
- *   market: evmAddress('0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2'),
- *   underlyingToken: evmAddress('0xa0b86a33e6441c8c5f0bb9b7e5e1f8bbf5b78b5c'),
- *   chainId: chainId(1),
+ * const result = await prepareSwapCancel(client, {
+ *   id: swapId('123...'),
  * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The reserve request parameters.
- * @returns The reserve data, or null if not found.
+ * @param request - The prepare swap cancel request parameters.
+ * @returns The prepared swap cancel result containing typed data for signing.
  */
-declare function reserve(client: AaveClient, request: ReserveRequest): ResultAsync<Reserve | null, UnexpectedError>;
+declare function prepareSwapCancel(client: AaveClient, request: PrepareSwapCancelRequest): ResultAsync<PrepareSwapCancelResult, UnexpectedError>;
 /**
- * Fetches historical borrow APY data for a given underlying asset on a specific market,
- * within a defined time window.
+ * @internal
+ * Executes a swap cancellation for the specified request parameters.
  *
- * The returned data represents APY samples over time, or `null` if unavailable.
+ * ```ts
+ * const result = await cancelSwap(client, {
+ *   intent: {
+ *     id: swapId('123...'),
+ *     signature: {
+ *       value: signature('0x456...'),
+ *       deadline: 1234567890,
+ *     },
+ *   },
+ * }).andThen((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan)
+ *         .map(() => ({ success: true }));
+ *
+ *     case 'SwapCancelled':
+ *       return okAsync(plan);
+ *   }
+ * });
+ * ```
  *
- * @param client - The Aave client instance used to perform the query.
- * @param request - The borrow APY history request parameters.
- * @returns A `ResultAsync` containing an array of APY samples, or `null` if not found.
+ * @param client - Aave client.
+ * @param request - The cancel swap request parameters.
+ * @returns The cancel swap execution plan containing transaction details or cancellation receipt.
  */
-declare function borrowAPYHistory(client: AaveClient, request: BorrowAPYHistoryRequest): ResultAsync<APYSample[] | null, UnexpectedError>;
+declare function cancelSwap(client: AaveClient, request: CancelSwapRequest): ResultAsync<CancelSwapExecutionPlan, UnexpectedError>;
 /**
- * Fetches historical supply APY data for a given underlying asset on a specific market,
- * within a defined time window.
+ * @internal
+ * Fetches the user's swap history for a specific chain.
  *
- * The returned data represents APY samples over time, or `null` if unavailable.
+ * ```ts
+ * const result = await userSwaps(client, {
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * });
+ * ```
  *
- * @param client - The Aave client instance used to perform the query.
- * @param request - The supply APY history request parameters.
- * @returns A `ResultAsync` containing an array of APY samples, or `null` if not found.
+ * @param client - Aave client.
+ * @param request - The user swaps request parameters.
+ * @param options - The query options.
+ * @returns The paginated list of user swaps with their status information.
  */
-declare function supplyAPYHistory(client: AaveClient, request: SupplyAPYHistoryRequest): ResultAsync<APYSample[] | null, UnexpectedError>;
+declare function userSwaps(client: AaveClient, request: UserSwapsRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<PaginatedUserSwapsResult, UnexpectedError>;
 
 /**
  * Creates a transaction to borrow from a market.
  *
  * ```ts
  * const result = await borrow(client, {
- *   market: market.address,
  *   amount: {
  *     erc20: {
- *       currency: evmAddress('0x5678…'),
- *       value: '1000',
+ *       value: bigDecimal('1000'),
  *     },
  *   },
- *   borrower: evmAddress('0x9abc…'),
- *   chainId: market.chain.chainId,
+ *   reserve: reserveId('SGVsbG8h'),
+ *   sender: evmAddress('0x9abc…'),
  * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  *
  * if (result.isErr()) {
@@ -427,16 +591,19 @@ declare function borrow(client: AaveClient, request: BorrowRequest): ResultAsync
  *
  * ```ts
  * const result = await supply(client, {
- *   market: market.address,
+ *   reserve: {
+ *     reserveId: "1234567890",
+ *     spoke: evmAddress('0x8787…'),
+ *     chainId: chainId(1),
+ *   },
  *   amount: {
  *     erc20: {
- *       currency: evmAddress('0x5678…'),
- *       value: '1000',
+ *       value: bigDecimal('1000'),
  *     },
  *   },
- *   supplier: evmAddress('0x9abc…'),
- *   chainId: market.chain.chainId,
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
+ *   enableCollateral: true, // Optional, defaults to true
+ *   sender: evmAddress('0x9abc…'),
+ * });
  *
  * if (result.isErr()) {
  *   // Handle error, e.g. insufficient balance, signing error, etc.
@@ -456,17 +623,15 @@ declare function supply(client: AaveClient, request: SupplyRequest): ResultAsync
  *
  * ```ts
  * const result = await repay(client, {
- *   market: market.address,
  *   amount: {
  *     erc20: {
- *       currency: evmAddress('0x5678…'),
  *       value: {
- *         exact: '500',
+ *         exact: bigDecimal('500'),
  *       },
  *     },
  *   },
- *   borrower: evmAddress('0x9abc…'),
- *   chainId: market.chain.chainId,
+ *   sender: evmAddress('0x9abc…'),
+ *   reserve: reserveId('SGVsbG8h'),
  * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  *
  * if (result.isErr()) {
@@ -483,19 +648,17 @@ declare function supply(client: AaveClient, request: SupplyRequest): ResultAsync
  */
 declare function repay(client: AaveClient, request: RepayRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
 /**
- * Creates a transaction to withdraw from a market.
+ * Creates a transaction to withdraw from a reserve.
  *
  * ```ts
  * const result = await withdraw(client, {
- *   market: market.address,
+ *   reserve: reserveId('SGVsbG8h'),
  *   amount: {
  *     erc20: {
- *       currency: evmAddress('0x5678…'),
- *       value: { exact: '750' },
+ *       exact: bigDecimal('750.5'),
  *     },
  *   },
- *   supplier: evmAddress('0x9abc…'),
- *   chainId: market.chain.chainId,
+ *   sender: evmAddress('0x9abc…'),
  * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  *
  * if (result.isErr()) {
@@ -506,191 +669,118 @@ declare function repay(client: AaveClient, request: RepayRequest): ResultAsync<E
  * // result.value: TxHash
  * ```
  *
- * @param client - Aave client.
- * @param request - The withdraw request parameters.
- * @returns The transaction data, approval requirements, or insufficient balance error.
- */
-declare function withdraw(client: AaveClient, request: WithdrawRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
-/**
- * Creates a transaction to enable/disable the user's eMode for a market.
- *
- * **Example: Enable a Specific eMode**
+ * **Withdraw specific amount:**
  * ```ts
- * const result = await userSetEmode(client, {
- *   market: market.address,
- *   user: evmAddress('0x5678…'),
- *   categoryId: market.eModeCategories[0].id,
- *   chainId: market.chain.chainId,
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
- *
- * if (result.isErr()) {
- *   // Handle error, e.g. signing error, etc.
- *   return;
+ * amount: {
+ *   erc20: {
+ *     exact: bigDecimal('100.5'), // Exact amount to withdraw
+ *   }
  * }
- *
- * // result.value: TxHash
  * ```
  *
- * **Example: Disable eMode**
+ * **Withdraw all available:**
  * ```ts
- * const result = await userSetEmode(client, {
- *   market: market.address,
- *   user: evmAddress('0x5678…'),
- *   categoryId: null,
- *   chainId: market.chain.chainId,
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
- *
- * if (result.isErr()) {
- *   // Handle error, e.g. signing error, etc.
- *   return;
+ * amount: {
+ *   erc20: {
+ *     max: true, // Withdraw the full position
+ *   }
  * }
- *
- * // result.value: TxHash
  * ```
  *
- * @param client - Aave client.
- * @param request - The user set eMode request parameters.
- * @returns The transaction request data to set eMode.
- */
-declare function userSetEmode(client: AaveClient, request: UserSetEmodeRequest): ResultAsync<TransactionRequest, UnexpectedError>;
-/**
- * Creates a transaction to deposit assets into a vault and mint shares.
- *
+ * **Withdraw native token:**
  * ```ts
- * const result = await vaultDeposit(client, {
- *   vault: evmAddress('0x1234…'),
- *   amount: {
- *     value: '1000',
- *   },
- *   depositor: evmAddress('0x9abc…'),
- *   chainId: chainId(1),
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
- *
- * if (result.isErr()) {
- *   // Handle error, e.g. insufficient balance, signing error, etc.
- *   return;
+ * amount: {
+ *   native: bigDecimal('0.5'), // For ETH on Ethereum
  * }
- *
- * // result.value: TxHash
  * ```
  *
  * @param client - Aave client.
- * @param request - The vault deposit request parameters.
+ * @param request - The withdraw request parameters.
  * @returns The transaction data, approval requirements, or insufficient balance error.
  */
-declare function vaultDeposit(client: AaveClient, request: VaultDepositRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
+declare function withdraw(client: AaveClient, request: WithdrawRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
 /**
- * Creates a transaction to redeem vault shares for underlying assets.
+ * Creates a transaction to renounce a position manager of a user in a specific spoke.
  *
  * ```ts
- * const result = await vaultRedeemShares(client, {
- *   vault: evmAddress('0x1234…'),
- *   shares: {
- *     amount: '500',
- *     asAToken: false,
- *   },
- *   sharesOwner: evmAddress('0x9abc…'),
- *   chainId: chainId(1),
+ * const result = await renounceSpokeUserPositionManager(client, {
+ *   manager: evmAddress('0x9abc…'),
+ *   managing: evmAddress('0xdef0…'),
+ *   spoke: spokeId('SGVsbG8h'),
  * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  *
  * if (result.isErr()) {
- *   // Handle error, e.g. signing error, etc.
+ *   // Handle error
  *   return;
  * }
  *
  * // result.value: TxHash
  * ```
  *
- * @param client - Aave client.
- * @param request - The redeem vault shares request parameters.
- * @returns The transaction request data to redeem shares.
- */
-declare function vaultRedeemShares(client: AaveClient, request: VaultRedeemSharesRequest): ResultAsync<TransactionRequest, UnexpectedError>;
-/**
- * Creates an execution plan to deploy a new vault.
- *
- * ```ts
- * const result = await vaultDeploy(client, {
- *   underlyingToken: evmAddress('0x1234…'),
- *   market: evmAddress('0x5678…'),
- *   deployer: evmAddress('0x9abc…'),
- *   initialFee: '0.1',
- *   shareName: 'Aave Vault Shares',
- *   shareSymbol: 'avs',
- *   initialLockDeposit: '1000',
- *   chainId: chainId(1),
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
- *
- * if (result.isErr()) {
- *   // Handle error, e.g. signing error, insufficient balance, etc.
- *   return;
- * }
- *
- * // result.value: TxHash
- * ```
  *
  * @param client - Aave client.
- * @param request - The deploy vault request parameters.
- * @returns The execution plan data to deploy a vault. May require approval transactions.
+ * @param request - The renounce spoke user position manager request parameters.
+ * @returns The transaction data.
  */
-declare function vaultDeploy(client: AaveClient, request: VaultDeployRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
+declare function renounceSpokeUserPositionManager(client: AaveClient, request: RenounceSpokeUserPositionManagerRequest): ResultAsync<TransactionRequest, UnexpectedError>;
 /**
- * Creates a transaction to set the vault fee (owner only).
+ * Creates a transaction to update user dynamic config for a specific spoke.
  *
  * ```ts
- * const result = await vaultSetFee(client, {
- *   vault: evmAddress('0x1234…'),
- *   newFee: '0.2',
- *   chainId: chainId(1),
+ * const result = await updateUserDynamicConfig(client, {
+ *   sender: evmAddress('0x9abc…'),
+ *   spoke: spokeId('SGVsbG8h'),
  * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  *
  * if (result.isErr()) {
- *   // Handle error, e.g. signing error, etc.
+ *   // Handle error
  *   return;
  * }
  *
  * // result.value: TxHash
  * ```
  *
+ *
  * @param client - Aave client.
- * @param request - The set vault fee request parameters.
- * @returns The transaction request data to set vault fee.
+ * @param request - The update user dynamic config request parameters.
+ * @returns The transaction data.
  */
-declare function vaultSetFee(client: AaveClient, request: VaultSetFeeRequest): ResultAsync<TransactionRequest, UnexpectedError>;
+declare function updateUserDynamicConfig(client: AaveClient, request: UpdateUserDynamicConfigRequest): ResultAsync<TransactionRequest, UnexpectedError>;
 /**
- * Creates a transaction to withdraw accumulated fees from a vault (owner only).
+ * Creates a transaction to update user risk premium for a specific spoke.
  *
  * ```ts
- * const result = await vaultWithdrawFees(client, {
- *   vault: evmAddress('0x1234…'),
- *   amount: '100',
- *   chainId: chainId(1),
+ * const result = await updateUserRiskPremium(client, {
+ *   sender: evmAddress('0x9abc…'),
+ *   spoke: spokeId('SGVsbG8h'),
  * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  *
  * if (result.isErr()) {
- *   // Handle error, e.g. signing error, etc.
+ *   // Handle error
  *   return;
  * }
  *
  * // result.value: TxHash
  * ```
  *
+ *
  * @param client - Aave client.
- * @param request - The withdraw vault fees request parameters.
- * @returns The transaction request data to withdraw vault fees.
+ * @param request - The update user risk premium request parameters.
+ * @returns The transaction data.
  */
-declare function vaultWithdrawFees(client: AaveClient, request: VaultWithdrawFeesRequest): ResultAsync<TransactionRequest, UnexpectedError>;
+declare function updateUserRiskPremium(client: AaveClient, request: UpdateUserRiskPremiumRequest): ResultAsync<TransactionRequest, UnexpectedError>;
 /**
- * Creates a transaction to withdraw assets from a vault, burning shares.
+ * Creates a transaction to liquidate a user's position.
  *
  * ```ts
- * const result = await vaultWithdraw(client, {
- *   vault: evmAddress('0x1234…'),
+ * const result = await liquidatePosition(client, {
+ *   collateral: reserveId('SGVsbG8h'),
+ *   debt: reserveId('Q2lhbyE= '),
  *   amount: {
- *     value: '500',
+ *     exact: bigDecimal('1000'),
  *   },
- *   sharesOwner: evmAddress('0x9abc…'),
- *   chainId: chainId(1),
+ *   liquidator: evmAddress('0x9abc…'),
+ *   user: evmAddress('0xdef0…'),
  * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  *
  * if (result.isErr()) {
@@ -702,46 +792,34 @@ declare function vaultWithdrawFees(client: AaveClient, request: VaultWithdrawFee
  * ```
  *
  * @param client - Aave client.
- * @param request - The withdraw vault request parameters.
- * @returns The transaction request data to withdraw from vault.
+ * @param request - The liquidate position request parameters.
+ * @returns The transaction data, approval requirements, or insufficient balance error.
  */
-declare function vaultWithdraw(client: AaveClient, request: VaultWithdrawRequest): ResultAsync<TransactionRequest, UnexpectedError>;
+declare function liquidatePosition(client: AaveClient, request: LiquidatePositionRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
 /**
- * Creates a transaction to mint exact amount of vault shares by depositing calculated assets.
- *
- * ```ts
- * const result = await vaultMintShares(client, {
- *   vault: evmAddress('0x1234…'),
- *   shares: {
- *     amount: '1000',
- *     asAToken: false,
- *   },
- *   minter: evmAddress('0x9abc…'),
- *   chainId: chainId(1),
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
+ * Sets or removes a position manager for a user on a specific spoke.
  *
- * if (result.isErr()) {
- *   // Handle error, e.g. insufficient balance, signing error, etc.
- *   return;
- * }
+ * **Position managers** can perform transactions on behalf of other users, including:
+ * - Supply assets
+ * - Borrow assets
+ * - Withdraw assets
+ * - Enable/disable collateral
  *
- * // result.value: TxHash
- * ```
- *
- * @param client - Aave client.
- * @param request - The mint vault shares request parameters.
- * @returns The transaction data, approval requirements, or insufficient balance error.
- */
-declare function vaultMintShares(client: AaveClient, request: VaultMintSharesRequest): ResultAsync<ExecutionPlan, UnexpectedError>;
-/**
- * Creates a transaction to enable/disable a specific supplied asset as 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 result = await collateralToggle(client, {
- *   market: market.address,
- *   underlyingToken: market.supplyReserves[n].underlyingToken.address,
- *   user: evmAddress('0x9abc…'),
- *   chainId: market.chain.chainId,
+ * const result = await setSpokeUserPositionManager(client, {
+ *   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
+ *   },
  * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  *
  * if (result.isErr()) {
@@ -753,365 +831,203 @@ declare function vaultMintShares(client: AaveClient, request: VaultMintSharesReq
  * ```
  *
  * @param client - Aave client.
- * @param request - The collateral toggle request parameters.
- * @returns The transaction request data to toggle collateral.
+ * @param request - The spoke set for the position manager request parameters.
+ * @returns The transaction request data to set position manager.
  */
-declare function collateralToggle(client: AaveClient, request: CollateralToggleRequest): ResultAsync<TransactionRequest, UnexpectedError>;
+declare function setSpokeUserPositionManager(client: AaveClient, request: SetSpokeUserPositionManagerRequest): ResultAsync<TransactionRequest, UnexpectedError>;
 /**
- * Creates a transaction to liquidate a non-healthy position with Health Factor below 1.
+ * Previews the impact of a potential action on a user's position.
  *
  * ```ts
- * const result = await liquidate(client, {
- *   collateralToken: evmAddress('0x1234…'),
- *   debtToken: evmAddress('0x5678…'),
- *   user: evmAddress('0x9abc…'),
- *   debtToCover: { max: true },
- *   chainId: chainId(1),
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
- *
- * if (result.isErr()) {
- *   // Handle error, e.g. signing error, etc.
- *   return;
- * }
- *
- * // result.value: TxHash
+ * const result = await preview(client, {
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           value: '1000',
+ *         },
+ *       },
+ *       sender: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The liquidate request parameters.
- * @returns The transaction request data to liquidate position.
+ * @param request - The preview request parameters containing the action to preview.
+ * @param options - The query options.
+ * @returns The preview result showing position changes.
  */
-declare function liquidate(client: AaveClient, request: LiquidateRequest): ResultAsync<TransactionRequest, UnexpectedError>;
+declare function preview(client: AaveClient, request: PreviewRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<PreviewUserPosition, UnexpectedError>;
 /**
- * Creates a transaction to approve a credit borrow delegator to be able to borrow on your behalf.
+ * Sets whether a user's supply should be used as collateral.
  *
  * ```ts
- * const result = await approveBorrowCreditDelegation(client, {
- *   market: evmAddress('0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2'),
- *   underlyingToken: evmAddress('0xa0b86a33e6441c8c5f0bb9b7e5e1f8bbf5b78b5c'),
- *   amount: '1000',
- *   user: evmAddress('0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234'),
- *   delegatee: evmAddress('0x5678…'),
- *   chainId: chainId(1),
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
- *
- * if (result.isErr()) {
- *   // Handle error, e.g. signing error, etc.
- *   return;
- * }
- *
- * // result.value: TxHash
+ * const result = await setUserSupplyAsCollateral(client, {
+ *   reserve: reserveId('SGVsbG8h'),
+ *   sender: evmAddress('0x456...'),
+ *   enableCollateral: true
+ * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The approve borrow credit delegation request parameters.
- * @returns The transaction request data to approve credit delegation.
+ * @param request - The set user supply as collateral request parameters.
+ * @returns The transaction request to set collateral status.
  */
-declare function approveBorrowCreditDelegation(client: AaveClient, request: ApproveBorrowCreditDelegatorRequest): ResultAsync<TransactionRequest, UnexpectedError>;
+declare function setUserSupplyAsCollateral(client: AaveClient, request: SetUserSupplyAsCollateralRequest): ResultAsync<TransactionRequest, UnexpectedError>;
 /**
- * Gets the amount delegated to the credit delegatee that can borrow on your behalf.
+ * Fetches paginated list of activities.
  *
  * ```ts
- * const result = await creditDelegateeAllowance(client, {
- *   market: evmAddress('0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2'),
- *   underlyingToken: evmAddress('0xa0b86a33e6441c8c5f0bb9b7e5e1f8bbf5b78b5c'),
- *   user: evmAddress('0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234'),
- *   delegatee: evmAddress('0x5678…'),
- *   chainId: chainId(1),
+ * const result = await activities(client, {
+ *   query: {
+ *     chainIds: [chainId(1)],
+ *   },
+ *   user: evmAddress('0x742d35cc…'), // Optional
+ *   types: [ActivityType.Supply, ActivityType.Borrow, ActivityType.Withdraw, ActivityType.Repay],
  * });
- *
- * if (result.isErr()) {
- *   // Handle error
- *   return;
- * }
- *
- * // result.value: TokenAmount with credit delegation allowance
  * ```
  *
  * @param client - Aave client.
- * @param request - The credit delegatee allowance request parameters.
- * @returns The token amount representing the credit delegation allowance.
+ * @param request - The activities request parameters.
+ * @param options - The query options.
+ * @returns The paginated list of activities.
  */
-declare function creditDelegateeAllowance(client: AaveClient, request: CreditDelegateeAmountRequest): ResultAsync<TokenAmount, UnexpectedError>;
+declare function activities(client: AaveClient, request: ActivitiesRequest, options?: CurrencyQueryOptions & RequestPolicyOptions): ResultAsync<PaginatedActivitiesResult, UnexpectedError>;
 
 /**
- * Fetches all user supply positions across the specified markets.
+ * Fetches all user supply positions across the specified spoke.
  *
  * ```ts
  * const result = await userSupplies(client, {
- *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
- *   user: evmAddress('0x742d35cc…'),
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
  * });
  * ```
  *
  * @param client - Aave client.
  * @param request - The user supplies request parameters.
+ * @param options - The query options.
  * @returns The user's supply positions.
  */
-declare function userSupplies(client: AaveClient, request: UserSuppliesRequest): ResultAsync<MarketUserReserveSupplyPosition[], UnexpectedError>;
+declare function userSupplies(client: AaveClient, request: UserSuppliesRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<UserSupplyItem[], UnexpectedError>;
 /**
- * Fetches all user borrow positions.
+ * Fetches all user borrow positions across the specified spoke.
  *
  * ```ts
  * const result = await userBorrows(client, {
- *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
- *   user: evmAddress('0x742d35cc…'),
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
  * });
  * ```
  *
  * @param client - Aave client.
  * @param request - The user borrows request parameters.
+ * @param options - The query options.
  * @returns The user's borrow positions.
  */
-declare function userBorrows(client: AaveClient, request: UserBorrowsRequest): ResultAsync<MarketUserReserveBorrowPosition[], UnexpectedError>;
+declare function userBorrows(client: AaveClient, request: UserBorrowsRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<UserBorrowItem[], UnexpectedError>;
+type UserSummaryQueryOptions = Prettify<CurrencyQueryOptions & TimeWindowQueryOptions>;
 /**
- * Fetches the user's transaction history for a given market.
+ * Fetches a user's summary across all positions.
  *
  * ```ts
- * const result = await userTransactionHistory(client, {
- *   chainId: chainId(1),
- *   market: evmAddress('0x87870bca…'),
+ * const result = await userSummary(client, {
  *   user: evmAddress('0x742d35cc…'),
- * });
- * ```
- *
- * @param client - Aave client.
- * @param request - The user transaction history request parameters.
- * @returns The user's paginated transaction history.
- */
-declare function userTransactionHistory(client: AaveClient, request: UserTransactionHistoryRequest): ResultAsync<PaginatedUserTransactionHistoryResult, UnexpectedError>;
-
-/**
- * Fetches a specific vault by address and chain ID.
- *
- * **Example: By Address**
- * ```ts
- * const result = await vault(client, {
- *   by: {
- *     address: evmAddress('0x1234…'),
- *   },
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678…'),
- * });
- * ```
- *
- * **Example: Tx Hash**
- * ```ts
- * const result = await vault(client, {
- *   by: {
- *     txHash: txHash('0x1234…'),
- *   },
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678…'),
- * });
- * ```
- *
- * @param client - Aave client.
- * @param request - The vault request parameters.
- * @returns The vault data, or null if not found.
- */
-declare function vault(client: AaveClient, request: VaultRequest): ResultAsync<Vault | null, UnexpectedError>;
-/**
- * Fetches vaults based on filter criteria.
- *
- * ```ts
- * const result = await vaults(client, {
- *   criteria: {
- *     ownedBy: [evmAddress('0x1234…')]
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
  *   },
- *   pageSize: PageSize.Ten,
- *   user: evmAddress('0x5678…'),
  * });
  * ```
  *
  * @param client - Aave client.
- * @param request - The vaults request parameters.
- * @returns The paginated vaults result.
+ * @param request - The user summary request parameters.
+ * @param options - The query options.
+ * @returns The user's financial summary.
  */
-declare function vaults(client: AaveClient, request: VaultsRequest): ResultAsync<PaginatedVaultsResult, UnexpectedError>;
+declare function userSummary(client: AaveClient, request: UserSummaryRequest, { currency, timeWindow, }?: UserSummaryQueryOptions): ResultAsync<UserSummary, UnexpectedError>;
+type UserPositionQueryOptions = CurrencyQueryOptions & TimeWindowQueryOptions;
 /**
- * Fetches vaults that a user has shares in.
+ * Fetches all user positions across specified chains.
  *
  * ```ts
- * const result = await userVaults(client, {
- *   user: evmAddress('0x1234…'),
- *   filters: {
- *     markets: [evmAddress('0x5678…')]
+ * const result = await userPositions(client, {
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     chainIds: [chainId(1), chainId(137)],
  *   },
- *   orderBy: { shares: OrderDirection.Desc },
- *   pageSize: PageSize.Fifty,
- * });
- * ```
- *
- * @param client - Aave client.
- * @param request - The user vaults request parameters.
- * @returns The paginated user vaults result.
- */
-declare function userVaults(client: AaveClient, request: UserVaultsRequest): ResultAsync<PaginatedVaultsResult, UnexpectedError>;
-/**
- * Determines the amount of shares that would be received for a deposit.
- *
- * ```ts
- * const result = await vaultPreviewDeposit(client, {
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   amount: bigDecimal('1000'),
- * });
- *
- * if (result.isOk()) {
- *   console.log('Shares to receive:', result.value.amount.value);
- *   console.log('USD value:', result.value.usd);
- * }
- * ```
- *
- * @param client - Aave client.
- * @param request - The vault preview deposit request parameters.
- * @returns The simulated shares amount that would be received.
- */
-declare function vaultPreviewDeposit(client: AaveClient, request: VaultPreviewDepositRequest): ResultAsync<TokenAmount, UnexpectedError>;
-/**
- * Determines the amount of assets that would be required to mint a specific amount of vault shares.
- *
- * ```ts
- * const result = await vaultPreviewMint(client, {
- *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
- *   chainId: chainId(1),
- *   amount: bigDecimal('500'),
- * });
- *
- * if (result.isOk()) {
- *   console.log('Assets required:', result.value.amount.value);
- *   console.log('USD value:', result.value.usd);
- * }
- * ```
- *
- * @param client - Aave client.
- * @param request - The vault preview mint request parameters.
- * @returns The simulated assets amount that would be required.
- */
-declare function vaultPreviewMint(client: AaveClient, request: VaultPreviewMintRequest): ResultAsync<TokenAmount, UnexpectedError>;
-/**
- * Determines the amount of shares that would be burned for a withdrawal.
- *
- * ```ts
- * const result = await vaultPreviewWithdraw(client, {
- *   vault: evmAddress('0x1234…'),
- *   chainId: chainId(1),
- *   amount: bigDecimal('750'),
+ *   orderBy: { balance: 'DESC' },
  * });
- *
- * if (result.isOk()) {
- *   console.log('Shares to burn:', result.value.amount.value);
- *   console.log('USD value:', result.value.usd);
- * }
  * ```
  *
  * @param client - Aave client.
- * @param request - The vault preview withdraw request parameters.
- * @returns The simulated shares amount that would be burned.
+ * @param request - The user positions request parameters.
+ * @param options - The query options.
+ * @returns The user's positions across all specified chains.
  */
-declare function vaultPreviewWithdraw(client: AaveClient, request: VaultPreviewWithdrawRequest): ResultAsync<TokenAmount, UnexpectedError>;
+declare function userPositions(client: AaveClient, request: UserPositionsRequest, { currency, timeWindow, }?: UserPositionQueryOptions): ResultAsync<UserPosition[], UnexpectedError>;
 /**
- * Determines the amount of assets that would be received for redeeming a specific amount of vault shares.
+ * Fetches a specific user position by ID.
  *
  * ```ts
- * const result = await vaultPreviewRedeem(client, {
- *   vault: evmAddress('0x1234…'),
- *   chainId: chainId(1),
- *   amount: bigDecimal('200'),
+ * const result = await userPosition(client, {
+ *   id: userPositionId('SGVsbG8h'),
  * });
- *
- * if (result.isOk()) {
- *   console.log('Assets to receive:', result.value.amount.value);
- *   console.log('USD value:', result.value.usd);
- * }
  * ```
  *
  * @param client - Aave client.
- * @param request - The vault preview redeem request parameters.
- * @returns The simulated assets amount that would be received.
+ * @param request - The user position request parameters.
+ * @param options - The query options.
+ * @returns The specific user position or null if not found.
  */
-declare function vaultPreviewRedeem(client: AaveClient, request: VaultPreviewRedeemRequest): ResultAsync<TokenAmount, UnexpectedError>;
+declare function userPosition(client: AaveClient, request: UserPositionRequest, { currency, timeWindow, }?: UserPositionQueryOptions): ResultAsync<UserPosition | null, UnexpectedError>;
 /**
- * Fetches the user transaction history for a vault.
+ * Fetches all user balances across specified chains.
  *
  * ```ts
- * const result = await vaultUserTransactionHistory(client, {
- *   vault: evmAddress('0x1234…'),
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678…'),
+ * const result = await userBalances(client, {
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     chainIds: [chainId(1), chainId(137)],
+ *   },
  * });
- *
- * if (result.isOk()) {
- *   console.log('Transaction count:', result.value.items.length);
- *   result.value.items.forEach(tx => {
- *     if (tx.__typename === 'VaultUserDepositItem') {
- *       console.log('Deposit:', tx.asset.amount.value, 'shares:', tx.shares.amount.value);
- *     } else if (tx.__typename === 'VaultUserWithdrawItem') {
- *       console.log('Withdraw:', tx.asset.amount.value, 'shares:', tx.shares.amount.value);
- *     }
- *   });
- * }
  * ```
  *
  * @param client - Aave client.
- * @param request - The vault user transaction history request parameters.
- * @returns The paginated vault user transaction history result.
- */
-declare function vaultUserTransactionHistory(client: AaveClient, request: VaultUserTransactionHistoryRequest): ResultAsync<PaginatedVaultUserTransactionHistoryResult, UnexpectedError>;
+ * @param request - The user balances request parameters.
+ * @param options - The query options.
+ * @returns The user's balances across all specified chains.
+ **/
+declare function userBalances(client: AaveClient, request: UserBalancesRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<UserBalance[], UnexpectedError>;
 /**
- * Fetches the user activity data for a vault, including earnings breakdown over time.
+ * Fetches user summary history over time.
  *
  * ```ts
- * const result = await vaultUserActivity(client, {
- *   vault: evmAddress('0x1234…'),
- *   chainId: chainId(1),
- *   user: evmAddress('0x5678…'),
+ * const result = await userSummaryHistory(client, {
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: {
+ *     chainIds: [chainId(1)]
+ *   }
  * });
- *
- * if (result.isOk()) {
- *   console.log('Total earned:', result.value.earned.amount.value);
- *   console.log('Activity breakdown count:', result.value.breakdown.length);
- *   result.value.breakdown.forEach(activity => {
- *     console.log('Date:', activity.date);
- *     console.log('Balance:', activity.balance.amount.value);
- *     console.log('Earned:', activity.earned.amount.value);
- *   });
- * }
- * ```
- *
- * @param client - Aave client.
- * @param request - The vault user activity request parameters.
- * @returns The vault user activity result.
- */
-declare function vaultUserActivity(client: AaveClient, request: VaultUserActivityRequest): ResultAsync<VaultUserActivityResult, UnexpectedError>;
-/**
- * Creates a transaction to transfer ownership of a vault.
- *
- * ```ts
- * const result = await vaultTransferOwnership(client, {
- *   vault: evmAddress('0x1234…'),
- *   chainId: chainId(1),
- *   newOwner: evmAddress('0x5678…'),
- * }).andThen(sendWith(wallet)).andThen(client.waitForTransaction);
  * ```
  *
  * @param client - Aave client.
- * @param request - The vault transfer ownership request parameters.
- * @returns The transaction data for transferring vault ownership.
- */
-declare function vaultTransferOwnership(client: AaveClient, request: VaultTransferOwnershipRequest): ResultAsync<TransactionRequest, UnexpectedError>;
-/**
- * @internal
- */
-declare function vaultCreateRecipientsConfiguration(client: AaveClient, request: VaultCreateRecipientsConfigurationRequest): ResultAsync<TransactionRequest, UnexpectedError>;
-/**
- * @internal
- */
-declare function vaultRecipientConfiguration(client: AaveClient, request: VaultRecipientConfigurationRequest): ResultAsync<VaultFeesRecipientsConfiguration | null, UnexpectedError>;
-/**
- * @internal
+ * @param request - The user summary history request parameters.
+ * @param options - The query options.
+ * @returns The user summary history items.
  */
-declare function vaultSetRecipientsConfiguration(client: AaveClient, request: VaultSetRecipientsConfigurationRequest): ResultAsync<TransactionRequest, UnexpectedError>;
+declare function userSummaryHistory(client: AaveClient, request: UserSummaryHistoryRequest, options?: Required<CurrencyQueryOptions>): ResultAsync<UserSummaryHistoryItem[], UnexpectedError>;
 
-export { type MarketRequest, type MarketsRequest, approveBorrowCreditDelegation, borrow, borrowAPYHistory, chains, collateralToggle, creditDelegateeAllowance, defaultMarketReservesRequestOrderBy, hasProcessedKnownTransaction, health, healthFactorPreview, liquidate, market, markets, permitTypedData, repay, reserve, savingsGhoBalance, savingsGhoDeposit, savingsGhoWithdraw, supply, supplyAPYHistory, usdExchangeRates, userBorrows, userMarketState, userMeritRewards, userSetEmode, userSupplies, userTransactionHistory, userVaults, vault, vaultCreateRecipientsConfiguration, vaultDeploy, vaultDeposit, vaultMintShares, vaultPreviewDeposit, vaultPreviewMint, vaultPreviewRedeem, vaultPreviewWithdraw, vaultRecipientConfiguration, vaultRedeemShares, vaultSetFee, vaultSetRecipientsConfiguration, vaultTransferOwnership, vaultUserActivity, vaultUserTransactionHistory, vaultWithdraw, vaultWithdrawFees, vaults, withdraw };
+export { type SwapOutcome, type UserPositionQueryOptions, type UserSummaryQueryOptions, activities, asset, assetBorrowHistory, assetPriceHistory, assetSupplyHistory, borrow, borrowApyHistory, cancelSwap, chain, chains, exchangeRate, hasProcessedKnownTransaction, hub, hubAssets, hubs, liquidatePosition, permitTypedData, prepareSwap, prepareSwapCancel, preview, renounceSpokeUserPositionManager, repay, reserve, reserves, setSpokeUserPositionManager, setUserSupplyAsCollateral, spoke, spokePositionManagers, spokeUserPositionManagers, spokes, supply, supplyApyHistory, swap, swapQuote, swapStatus, swappableTokens, updateUserDynamicConfig, updateUserRiskPremium, userBalances, userBorrows, userPosition, userPositions, userSummary, userSummaryHistory, userSupplies, userSwaps, waitForSwapOutcome, withdraw };