@aave/react 0.6.0 → 0.7.0

package/dist/index.d.cts

@@ -0,0 +1,1349 @@
+import { AaveClient, UnexpectedError } from '@aave/client';
+export * from '@aave/client';
+import React, { ReactNode } from 'react';
+import { SavingsGhoBalanceRequest, TokenAmount, SavingsGhoWithdrawRequest, ExecutionPlan, SavingsGhoDepositRequest, UserMeritRewardsRequest, UserMeritRewards, Market, ChainsFilter, Chain, UsdExchangeRatesRequest, UsdExchangeRate, HealthFactorPreviewRequest, HealthFactorPreviewResponse, ReserveRequest, Reserve, BorrowAPYHistoryRequest, APYSample, SupplyAPYHistoryRequest, CreditDelegateeAmountRequest, SupplyRequest, BorrowRequest, RepayRequest, WithdrawRequest, UserSetEmodeRequest, TransactionRequest, CollateralToggleRequest, LiquidateRequest, VaultDepositRequest, VaultMintSharesRequest, VaultRedeemSharesRequest, VaultWithdrawRequest, VaultDeployRequest, VaultSetFeeRequest, VaultWithdrawFeesRequest, VaultTransferOwnershipRequest, ApproveBorrowCreditDelegatorRequest, UserSuppliesRequest, MarketUserReserveSupplyPosition, UserBorrowsRequest, MarketUserReserveBorrowPosition, UserMarketStateRequest, MarketUserState, UserTransactionHistoryRequest, PaginatedUserTransactionHistoryResult, VaultRequest, Vault, VaultsRequest, PaginatedVaultsResult, UserVaultsRequest, VaultPreviewDepositRequest, VaultPreviewMintRequest, VaultPreviewWithdrawRequest, VaultPreviewRedeemRequest, VaultUserTransactionHistoryRequest, PaginatedVaultUserTransactionHistoryResult, VaultUserActivityRequest, VaultUserActivityResult } from '@aave/graphql';
+import { U as UseAsyncTask } from './tasks-DUn7x8pK.cjs';
+import { MarketRequest, MarketsRequest } from '@aave/client/actions';
+import '@aave/types';
+
+/**
+ * A read hook result.
+ *
+ * It's a discriminated union of the possible results of a read operation:
+ * - Rely on the `loading` value to determine if the `data` or `error` can be evaluated.
+ * - If `error` is `undefined`, then `data` value will be available.
+ */
+type ReadResult<T, E = never> = {
+    data: undefined;
+    error: undefined;
+    loading: true;
+} | {
+    data: T;
+    error: undefined;
+    loading: false;
+} | {
+    data: undefined;
+    error: E;
+    loading: false;
+};
+/**
+ * @internal
+ */
+declare const ReadResult: {
+    Initial: <T, E = never>() => ReadResult<T, E>;
+    Success: <T, E = never>(data: T) => ReadResult<T, E>;
+    Failure: <T, E = never>(error: E) => ReadResult<T, E>;
+};
+/**
+ * A read hook result that supports React Suspense
+ */
+type SuspenseResult<T> = {
+    data: T;
+};
+
+/**
+ * @internal
+ */
+type Suspendable = {
+    suspense: true;
+};
+
+/**
+ * <AaveProvider> props
+ */
+type AaveProviderProps = {
+    /**
+     * The children to render
+     */
+    children: ReactNode;
+    /**
+     * The Aave client instance to use
+     */
+    client: AaveClient;
+};
+/**
+ * Manages the internal state of the Aave SDK.
+ *
+ * ```tsx
+ * import { AaveProvider, AaveClient, production } from '@aave/react';
+ *
+ * const client = AaveClient.create({
+ *   environment: production,
+ * });
+ *
+ * function App() {
+ *   return (
+ *     <AaveProvider client={client}>
+ *        // ...
+ *     </AaveProvider>
+ *   );
+ * }
+ * ```
+ */
+declare function AaveProvider({ children, client }: AaveProviderProps): React.JSX.Element;
+
+/**
+ * Retrieve the injected {@link AaveClient} from the context.
+ */
+declare function useAaveClient(): AaveClient;
+
+type SavingsGhoBalanceArgs = SavingsGhoBalanceRequest;
+/**
+ * Fetches the current sGHO balance for a user.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSavingsGhoBalance({
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSavingsGhoBalance(args: SavingsGhoBalanceArgs & Suspendable): SuspenseResult<TokenAmount>;
+/**
+ * Fetches the current sGHO balance for a user.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSavingsGhoBalance({
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ * ```
+ */
+declare function useSavingsGhoBalance(args: SavingsGhoBalanceArgs): ReadResult<TokenAmount>;
+/**
+ * A hook that provides a way to withdraw sGHO.
+ *
+ * ```ts
+ * const [withdraw, withdrawing] = useSavingsGhoWithdraw();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = withdrawing.loading && sending.loading;
+ * const error = withdrawing.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await withdraw({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance to withdraw: ${plan.required.value} is the maximum withdrawal allowed.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useSavingsGhoWithdraw(): UseAsyncTask<SavingsGhoWithdrawRequest, ExecutionPlan, UnexpectedError>;
+/**
+ * A hook that provides a way to deposit GHO into sGHO.
+ *
+ * ```ts
+ * const [deposit, depositing] = useSavingsGhoDeposit();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = depositing.loading && sending.loading;
+ * const error = depositing.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await deposit({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance: ${plan.required.value} required.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useSavingsGhoDeposit(): UseAsyncTask<SavingsGhoDepositRequest, ExecutionPlan, UnexpectedError>;
+
+type UserMeritRewardsArgs = UserMeritRewardsRequest;
+/**
+ * Fetches Merit claim rewards for a user with the transaction request to claim them.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserMeritRewards({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserMeritRewards(args: UserMeritRewardsArgs & Suspendable): SuspenseResult<UserMeritRewards | null>;
+/**
+ * Fetches Merit claim rewards for a user with the transaction request to claim them.
+ *
+ * ```tsx
+ * const { data, loading } = useUserMeritRewards({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainId: chainId(1),
+ * });
+ * ```
+ */
+declare function useUserMeritRewards(args: UserMeritRewardsArgs): ReadResult<UserMeritRewards | null>;
+
+type UseAaveMarketArgs = MarketRequest;
+/**
+ * Fetch a single Aave Market.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAaveMarket({
+ *   address: evmAddress('0x8787…'),
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useAaveMarket(args: UseAaveMarketArgs & Suspendable): SuspenseResult<Market | null>;
+/**
+ * Fetch a single Aave Market.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAaveMarket({
+ *   address: evmAddress('0x8787…'),
+ *   chainId: chainId(1),
+ * });
+ * ```
+ */
+declare function useAaveMarket(args: UseAaveMarketArgs): ReadResult<Market | null>;
+type UseAaveMarketsArgs = MarketsRequest;
+/**
+ * Fetch all Aave Markets for the specified chains.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAaveMarkets({
+ *   chainIds: [chainId(1), chainId(8453)],
+ *   user: evmAddress('0x742d35cc...'),
+ *   suspense: true
+ * });
+ * ```
+ */
+declare function useAaveMarkets(args: UseAaveMarketsArgs & Suspendable): SuspenseResult<Market[]>;
+/**
+ * Fetch all Aave Markets for the specified chains.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAaveMarkets({
+ *   chainIds: [chainId(1), chainId(8453)],
+ *   user: evmAddress('0x742d35cc...'),
+ * });
+ * ```
+ */
+declare function useAaveMarkets(args: UseAaveMarketsArgs): ReadResult<Market[]>;
+
+type UseAaveChainsArgs = {
+    filter?: ChainsFilter;
+};
+/**
+ * Fetch all supported Aave chains.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAaveChains({
+ *   filter: ChainsFilter.MAINNET_ONLY,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useAaveChains(args: UseAaveChainsArgs & Suspendable): SuspenseResult<Chain[]>;
+/**
+ * Fetch all supported Aave chains.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAaveChains({
+ *   filter: ChainsFilter.MAINNET_ONLY,
+ * });
+ * ```
+ */
+declare function useAaveChains(args: UseAaveChainsArgs): ReadResult<Chain[]>;
+/**
+ * Health check query.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAaveHealth({
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useAaveHealth(args: Suspendable): SuspenseResult<boolean>;
+/**
+ * Health check query.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAaveHealth();
+ * ```
+ */
+declare function useAaveHealth(): ReadResult<boolean>;
+type UseUsdExchangeRatesArgs = UsdExchangeRatesRequest;
+/**
+ * Fetch USD exchange rates for different tokens on a given market.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUsdExchangeRates({
+ *   market: evmAddress('0x1234…'),
+ *   underlyingTokens: [evmAddress('0x5678…'), evmAddress('0x90ab…')],
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUsdExchangeRates(args: UseUsdExchangeRatesArgs & Suspendable): SuspenseResult<UsdExchangeRate[]>;
+/**
+ * Fetch USD exchange rates for different tokens on a given market.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUsdExchangeRates({
+ *   market: evmAddress('0x1234…'),
+ *   underlyingTokens: [evmAddress('0x5678…'), evmAddress('0x90ab…')],
+ *   chainId: chainId(1),
+ * });
+ * ```
+ */
+declare function useUsdExchangeRates(args: UseUsdExchangeRatesArgs): ReadResult<UsdExchangeRate[]>;
+/**
+ * Determines the health factor after a given action.
+ *
+ * ```ts
+ * const [preview, { loading, error }] = useAaveHealthFactorPreview();
+ *
+ * // …
+ *
+ * const result = await preview({
+ *   action: {
+ *     borrow: {
+ *       market: market.address,
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       borrower: evmAddress('0x9abc…'),
+ *       chainId: market.chain.chainId,
+ *     },
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ * } else {
+ *   console.log(result.value);
+ * }
+ * ```
+ */
+declare function useAaveHealthFactorPreview(): UseAsyncTask<HealthFactorPreviewRequest, HealthFactorPreviewResponse, UnexpectedError>;
+
+type UseAaveReserveArgs = ReserveRequest;
+/**
+ * Fetch a single Aave Reserve.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAaveReserve({
+ *   market: evmAddress('0x87870bca...'),
+ *   underlyingToken: evmAddress('0xa0b86a33...'),
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useAaveReserve(args: UseAaveReserveArgs & Suspendable): SuspenseResult<Reserve | null>;
+/**
+ * Fetch a single Aave Reserve.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAaveReserve({
+ *   market: evmAddress('0x87870bca...'),
+ *   underlyingToken: evmAddress('0xa0b86a33...'),
+ *   chainId: chainId(1),
+ * });
+ * ```
+ */
+declare function useAaveReserve(args: UseAaveReserveArgs): ReadResult<Reserve | null>;
+type UseBorrowAPYHistoryArgs = BorrowAPYHistoryRequest;
+/**
+ * Fetches historical borrow APY data for a given underlying asset on a specific market
+ * within a defined time window.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useBorrowAPYHistory({
+ *   chainId: chainId(1),
+ *   underlyingToken: evmAddress('0x742d35cc…'),
+ *   market: evmAddress('0x24dc35d3c…'),
+ *   window: TimeWindow.LastWeek
+ *   suspense: true
+ * });
+ * ```
+ */
+declare function useBorrowAPYHistory(args: UseBorrowAPYHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+/**
+ * Fetches historical borrow APY data for a given underlying asset on a specific market
+ * within a defined time window.
+ *
+ * ```tsx
+ * const { data } = useBorrowAPYHistory({
+ *   chainId: chainId(1),
+ *   underlyingToken: evmAddress('0x742d35cc…'),
+ *   market: evmAddress('0x24dc35d3c…'),
+ *   window: TimeWindow.LastWeek
+ * });
+ * ```
+ */
+declare function useBorrowAPYHistory(args: UseBorrowAPYHistoryArgs): ReadResult<APYSample[]>;
+type UseSupplyAPYHistoryArgs = SupplyAPYHistoryRequest;
+/**
+ * Fetches historical supply APY data for a given underlying asset on a specific market
+ * within a defined time window.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSupplyAPYHistory({
+ *   chainId: chainId(1),
+ *   underlyingToken: evmAddress('0x742d35cc…'),
+ *   market: evmAddress('0x24dc35d3c…'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true
+ * });
+ * ```
+ */
+declare function useSupplyAPYHistory(args: UseSupplyAPYHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+/**
+ * Fetches historical supply APY data for a given underlying asset on a specific market
+ * within a defined time window.
+ *
+ * ```tsx
+ * const { data } = useSupplyAPYHistory({
+ *   chainId: chainId(1),
+ *   underlyingToken: evmAddress('0x742d35cc…'),
+ *   market: evmAddress('0x24dc35d3c…'),
+ *   window: TimeWindow.LastWeek
+ * });
+ * ```
+ */
+declare function useSupplyAPYHistory(args: UseSupplyAPYHistoryArgs): ReadResult<APYSample[]>;
+type UseCreditDelegateeAllowanceArgs = CreditDelegateeAmountRequest;
+/**
+ * Get the amount delegated to the credit delegatee that can borrow on your behalf.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useCreditDelegateeAllowance({
+ *   market: evmAddress('0x87870bca...'),
+ *   underlyingToken: evmAddress('0xa0b86a33...'),
+ *   user: evmAddress('0x742d35cc...'),
+ *   delegatee: evmAddress('0x5678...'),
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useCreditDelegateeAllowance(args: UseCreditDelegateeAllowanceArgs & Suspendable): SuspenseResult<TokenAmount>;
+/**
+ * Get the amount delegated to the credit delegatee that can borrow on your behalf.
+ *
+ * ```tsx
+ * const { data, error, loading } = useCreditDelegateeAllowance({
+ *   market: evmAddress('0x87870bca...'),
+ *   underlyingToken: evmAddress('0xa0b86a33...'),
+ *   user: evmAddress('0x742d35cc...'),
+ *   delegatee: evmAddress('0x5678...'),
+ *   chainId: chainId(1),
+ * });
+ * ```
+ */
+declare function useCreditDelegateeAllowance(args: UseCreditDelegateeAllowanceArgs): ReadResult<TokenAmount>;
+
+/**
+ * A hook that provides a way to supply assets to an Aave market.
+ *
+ * ```ts
+ * const [supply, supplying] = useSupply();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = supplying.loading && sending.loading;
+ * const error = supplying.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await supply({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance: ${plan.required.value} required.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useSupply(): UseAsyncTask<SupplyRequest, ExecutionPlan, UnexpectedError>;
+/**
+ * A hook that provides a way to borrow assets from an Aave market.
+ *
+ * ```ts
+ * const [borrow, borrowing] = useBorrow();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = borrowing.loading && sending.loading;
+ * const error = borrowing.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await borrow({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance: ${plan.required.value} required.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useBorrow(): UseAsyncTask<BorrowRequest, ExecutionPlan, UnexpectedError>;
+/**
+ * A hook that provides a way to repay borrowed assets to an Aave market.
+ *
+ * ```ts
+ * const [repay, repaying] = useRepay();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = repaying.loading && sending.loading;
+ * const error = repaying.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await repay({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance: ${plan.required.value} required.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useRepay(): UseAsyncTask<RepayRequest, ExecutionPlan, UnexpectedError>;
+/**
+ * A hook that provides a way to withdraw supplied assets from an Aave market.
+ *
+ * ```ts
+ * const [withdraw, withdrawing] = useWithdraw();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = withdrawing.loading && sending.loading;
+ * const error = withdrawing.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await withdraw({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance: ${plan.required.value} required.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useWithdraw(): UseAsyncTask<WithdrawRequest, ExecutionPlan, UnexpectedError>;
+/**
+ * A hook that provides a way to set eMode for a user.
+ *
+ * ```ts
+ * const [setUserEMode, setting] = useUserEMode();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = setting.loading && sending.loading;
+ * const error = setting.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await setUserEMode({ ... })
+ *   .andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useUserEMode(): UseAsyncTask<UserSetEmodeRequest, TransactionRequest, UnexpectedError>;
+/**
+ * A hook that provides a way to enable/disable a specific supplied asset as collateral.
+ *
+ * ```ts
+ * const [toggle, toggling] = useCollateralToggle();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = toggling.loading && sending.loading;
+ * const error = toggling.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await toggle({ ... })
+ *   .andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useCollateralToggle(): UseAsyncTask<CollateralToggleRequest, TransactionRequest, UnexpectedError>;
+/**
+ * A hook that provides a way to liquidate a non-healthy position with Health Factor below 1.
+ *
+ * ```ts
+ * const [liquidate, liquidating] = useLiquidate();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = liquidating.loading && sending.loading;
+ * const error = liquidating.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await liquidate({ ... })
+ *   .andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useLiquidate(): UseAsyncTask<LiquidateRequest, TransactionRequest, UnexpectedError>;
+/**
+ * A hook that provides a way to deposit assets into a vault.
+ *
+ * ```ts
+ * const [deposit, depositing] = useVaultDeposit();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = depositing.loading && sending.loading;
+ * const error = depositing.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await deposit({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance: ${plan.required.value} required.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useVaultDeposit(): UseAsyncTask<VaultDepositRequest, ExecutionPlan, UnexpectedError>;
+/**
+ * A hook that provides a way to mint vault shares.
+ *
+ * ```ts
+ * const [mint, minting] = useVaultMintShares();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = minting.loading && sending.loading;
+ * const error = minting.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await mint({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance: ${plan.required.value} required.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useVaultMintShares(): UseAsyncTask<VaultMintSharesRequest, ExecutionPlan, UnexpectedError>;
+/**
+ * A hook that provides a way to redeem vault shares.
+ *
+ * ```ts
+ * const [redeem, redeeming] = useVaultRedeemShares();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = redeeming.loading && sending.loading;
+ * const error = redeeming.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await redeem({ ... })
+ *   .andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useVaultRedeemShares(): UseAsyncTask<VaultRedeemSharesRequest, TransactionRequest, UnexpectedError>;
+/**
+ * A hook that provides a way to withdraw assets from a vault.
+ *
+ * ```ts
+ * const [withdraw, withdrawing] = useVaultWithdraw();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = withdrawing.loading && sending.loading;
+ * const error = withdrawing.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await withdraw({ ... })
+ *   .andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useVaultWithdraw(): UseAsyncTask<VaultWithdrawRequest, TransactionRequest, UnexpectedError>;
+/**
+ * A hook that provides a way to deploy a vault.
+ *
+ * ```ts
+ * const [deploy, deploying] = useVaultDeploy();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = deploying.loading && sending.loading;
+ * const error = deploying.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await deploy({ ... })
+ *   .andThen((plan) => {
+ *     switch (plan.__typename) {
+ *       case 'TransactionRequest':
+ *         return sendTransaction(plan);
+ *
+ *       case 'ApprovalRequired':
+ *         return sendTransaction(plan.approval)
+ *           .andThen(() => sendTransaction(plan.originalTransaction));
+ *
+ *       case 'InsufficientBalanceError':
+ *         return errAsync(
+ *           new Error(`Insufficient balance: ${plan.required.value} required.`)
+ *         );
+ *     }
+ *   });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useVaultDeploy(): UseAsyncTask<VaultDeployRequest, ExecutionPlan, UnexpectedError>;
+/**
+ * A hook that provides a way to set vault fee.
+ *
+ * ```ts
+ * const [setFee, setting] = useVaultSetFee();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = setting.loading && sending.loading;
+ * const error = setting.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await setFee({ ... })
+ *   .andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useVaultSetFee(): UseAsyncTask<VaultSetFeeRequest, TransactionRequest, UnexpectedError>;
+/**
+ * A hook that provides a way to withdraw vault fees.
+ *
+ * ```ts
+ * const [withdraw, withdrawing] = useVaultWithdrawFees();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = withdrawing.loading && sending.loading;
+ * const error = withdrawing.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await withdraw({ ... })
+ *   .andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useVaultWithdrawFees(): UseAsyncTask<VaultWithdrawFeesRequest, TransactionRequest, UnexpectedError>;
+/**
+ * A hook that provides a way to transfer ownership of a vault.
+ *
+ * ```ts
+ * const [transferOwnership, transferring] = useVaultTransferOwnership();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = transferring.loading && sending.loading;
+ * const error = transferring.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await transferOwnership({ ... })
+ *   .andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useVaultTransferOwnership(): UseAsyncTask<VaultTransferOwnershipRequest, TransactionRequest, UnexpectedError>;
+/**
+ * A hook that provides a way to approve a credit borrow delegator to be able to borrow on your behalf.
+ *
+ * ```ts
+ * const [approve, approving] = useApproveBorrowCreditDelegation();
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ *
+ * const loading = approving.loading && sending.loading;
+ * const error = approving.error || sending.error;
+ *
+ * // …
+ *
+ * const result = await approve({
+ *   market: evmAddress('0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2'),
+ *   underlyingToken: evmAddress('0xa0b86a33e6441c8c5f0bb9b7e5e1f8bbf5b78b5c'),
+ *   amount: '1000',
+ *   user: evmAddress('0x742d35cc6e5c4ce3b69a2a8c7c8e5f7e9a0b1234'),
+ *   delegatee: evmAddress('0x5678…'),
+ *   chainId: chainId(1),
+ * }).andThen(sendTransaction);
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ */
+declare function useApproveBorrowCreditDelegation(): UseAsyncTask<ApproveBorrowCreditDelegatorRequest, TransactionRequest, UnexpectedError>;
+
+type UseUserSuppliesArgs = UserSuppliesRequest;
+/**
+ * Fetch all user supply positions.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserSupplies({
+ *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
+ *   user: evmAddress('0x742d35cc…'),
+ *   orderBy: { name: OrderDirection.ASC },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserSupplies(args: UseUserSuppliesArgs & Suspendable): SuspenseResult<MarketUserReserveSupplyPosition[]>;
+/**
+ * Fetch all user supply positions.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserSupplies({
+ *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
+ *   user: evmAddress('0x742d35cc…'),
+ *   orderBy: { name: OrderDirection.ASC },
+ * });
+ * ```
+ */
+declare function useUserSupplies(args: UseUserSuppliesArgs): ReadResult<MarketUserReserveSupplyPosition[]>;
+type UseUserBorrowsArgs = UserBorrowsRequest;
+/**
+ * Fetch all user borrow positions.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserBorrows({
+ *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
+ *   user: evmAddress('0x742d35cc…'),
+ *   orderBy: { name: OrderDirection.ASC },
+ *   suspense: true
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: UseUserBorrowsArgs & Suspendable): SuspenseResult<MarketUserReserveBorrowPosition[]>;
+/**
+ * Fetch all user borrow positions.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserBorrows({
+ *   markets: [{ address: evmAddress('0x87870bca…'), chainId: chainId(1) }],
+ *   user: evmAddress('0x742d35cc…'),
+ *   orderBy: { name: OrderDirection.ASC },
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: UseUserBorrowsArgs): ReadResult<MarketUserReserveBorrowPosition[]>;
+type UseUserStateArgs = UserMarketStateRequest;
+/**
+ * Fetch user account market data across all reserves.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserMarketState({
+ *   market: evmAddress('0x1234…'),
+ *   user: evmAddress('0x5678…'),
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserMarketState(args: UseUserStateArgs & Suspendable): SuspenseResult<MarketUserState>;
+/**
+ * Fetch user account market data across all reserves.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserMarketState({
+ *   market: evmAddress('0x1234…'),
+ *   user: evmAddress('0x5678…'),
+ *   chainId: chainId(1),
+ * });
+ * ```
+ */
+declare function useUserMarketState(args: UseUserStateArgs): ReadResult<MarketUserState>;
+type UseUserTransactionHistoryArgs = UserTransactionHistoryRequest;
+/**
+ * Fetch user transaction history.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserTransactionHistory({
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserTransactionHistory(args: UseUserTransactionHistoryArgs & Suspendable): SuspenseResult<PaginatedUserTransactionHistoryResult>;
+/**
+ * Fetch user transaction history.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserTransactionHistory();
+ * ```
+ */
+declare function useUserTransactionHistory(args: UseUserTransactionHistoryArgs): ReadResult<PaginatedUserTransactionHistoryResult>;
+
+type UseVaultArgs = VaultRequest;
+/**
+ * Fetch a single vault by address and chain ID.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useVault({
+ *   by: {
+ *     address: evmAddress('0x1234…'),
+ *   },
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x5678…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useVault(args: UseVaultArgs & Suspendable): SuspenseResult<Vault | null>;
+/**
+ * Fetch a single vault by address and chain ID.
+ *
+ * ```tsx
+ * const { data, error, loading } = useVault({
+ *   address: evmAddress('0x1234…'),
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x5678…'),
+ * });
+ * ```
+ */
+declare function useVault(args: UseVaultArgs): ReadResult<Vault | null>;
+type UseVaultsArgs = VaultsRequest;
+/**
+ * Fetch vaults based on filter criteria.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useVaults({
+ *   criteria: {
+ *     ownedBy: [evmAddress('0x1234…')]
+ *   },
+ *   pageSize: PageSize.Ten,
+ *   user: evmAddress('0x5678…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useVaults(args: UseVaultsArgs & Suspendable): SuspenseResult<PaginatedVaultsResult>;
+/**
+ * Fetch vaults based on filter criteria.
+ *
+ * ```tsx
+ * const { data, error, loading } = useVaults({
+ *   criteria: {
+ *     ownedBy: [evmAddress('0x1234…')]
+ *   },
+ *   pageSize: PageSize.Ten,
+ *   user: evmAddress('0x5678…'),
+ * });
+ * ```
+ */
+declare function useVaults(args: UseVaultsArgs): ReadResult<PaginatedVaultsResult>;
+type UseUserVaultsArgs = UserVaultsRequest;
+/**
+ * Fetch vaults that a user has shares in.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserVaults({
+ *   user: evmAddress('0x1234…'),
+ *   filters: {
+ *     markets: [evmAddress('0x5678…')]
+ *   },
+ *   orderBy: { shares: OrderDirection.Desc },
+ *   pageSize: PageSize.Fifty,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserVaults(args: UseUserVaultsArgs & Suspendable): SuspenseResult<PaginatedVaultsResult>;
+/**
+ * Fetch vaults that a user has shares in.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserVaults({
+ *   user: evmAddress('0x1234…'),
+ *   filters: {
+ *     markets: [evmAddress('0x5678…')]
+ *   },
+ *   orderBy: { shares: OrderDirection.Desc },
+ *   pageSize: PageSize.Fifty,
+ * });
+ * ```
+ */
+declare function useUserVaults(args: UseUserVaultsArgs): ReadResult<PaginatedVaultsResult>;
+/**
+ * Determines the amount of shares that would be received for a deposit.
+ *
+ * ```ts
+ * const [preview, { loading, error }] = useVaultDepositPreview();
+ *
+ * // …
+ *
+ * const result = await preview({
+ *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
+ *   chainId: chainId(1),
+ *   amount: bigDecimal('1000'),
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ * } else {
+ *   console.log(result.value);
+ * }
+ * ```
+ */
+declare function useVaultDepositPreview(): UseAsyncTask<VaultPreviewDepositRequest, TokenAmount, UnexpectedError>;
+/**
+ * Determines the amount of assets that would be required to mint a specific amount of vault shares.
+ *
+ * ```ts
+ * const [preview, { loading, error }] = useVaultMintPreview();
+ *
+ * // …
+ *
+ * const result = await preview({
+ *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
+ *   chainId: chainId(1),
+ *   amount: bigDecimal('500'),
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ * } else {
+ *   console.log(result.value);
+ * }
+ * ```
+ */
+declare function useVaultMintPreview(): UseAsyncTask<VaultPreviewMintRequest, TokenAmount, UnexpectedError>;
+/**
+ * Determines the amount of shares that would be burned for a withdrawal.
+ *
+ * ```ts
+ * const [preview, { loading, error }] = useVaultWithdrawPreview();
+ *
+ * // …
+ *
+ * const result = await preview({
+ *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
+ *   chainId: chainId(1),
+ *   amount: bigDecimal('750'),
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ * } else {
+ *   console.log(result.value);
+ * }
+ * ```
+ */
+declare function useVaultWithdrawPreview(): UseAsyncTask<VaultPreviewWithdrawRequest, TokenAmount, UnexpectedError>;
+/**
+ * Determines the amount of assets that would be received for redeeming a specific amount of vault shares.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```ts
+ * const [preview, { loading, error }] = useVaultRedeemPreview();
+ *
+ * // …
+ *
+ * const result = await preview({
+ *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
+ *   chainId: chainId(1),
+ *   amount: bigDecimal('200'),
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ * } else {
+ *   console.log(result.value);
+ * }
+ * ```
+ */
+declare function useVaultRedeemPreview(): UseAsyncTask<VaultPreviewRedeemRequest, TokenAmount, UnexpectedError>;
+type UseVaultUserTransactionHistoryArgs = VaultUserTransactionHistoryRequest;
+/**
+ * Fetch user transaction history for a vault.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useVaultUserTransactionHistory({
+ *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x5678901234567890abcdef1234567890abcdef12'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useVaultUserTransactionHistory(args: UseVaultUserTransactionHistoryArgs & Suspendable): SuspenseResult<PaginatedVaultUserTransactionHistoryResult>;
+/**
+ * Fetch user transaction history for a vault.
+ *
+ * ```tsx
+ * const { data, error, loading } = useVaultUserTransactionHistory({
+ *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x5678901234567890abcdef1234567890abcdef12'),
+ * });
+ * ```
+ */
+declare function useVaultUserTransactionHistory(args: UseVaultUserTransactionHistoryArgs): ReadResult<PaginatedVaultUserTransactionHistoryResult>;
+type UseVaultUserActivityArgs = VaultUserActivityRequest;
+/**
+ * Fetch user activity data for a vault, including earnings breakdown over time.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useVaultUserActivity({
+ *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x5678901234567890abcdef1234567890abcdef12'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useVaultUserActivity(args: UseVaultUserActivityArgs & Suspendable): SuspenseResult<VaultUserActivityResult>;
+/**
+ * Fetch user activity data for a vault, including earnings breakdown over time.
+ *
+ * ```tsx
+ * const { data, error, loading } = useVaultUserActivity({
+ *   vault: evmAddress('0x1234567890abcdef1234567890abcdef12345678'),
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x5678901234567890abcdef1234567890abcdef12'),
+ * });
+ *
+ * if (data) {
+ *   console.log('Total earned:', data.earned.amount.value);
+ *   data.breakdown.forEach(activity => {
+ *     console.log('Date:', activity.date);
+ *     console.log('Balance:', activity.balance.amount.value);
+ *   });
+ * }
+ * ```
+ */
+declare function useVaultUserActivity(args: UseVaultUserActivityArgs): ReadResult<VaultUserActivityResult>;
+
+export { AaveProvider, type AaveProviderProps, type SavingsGhoBalanceArgs, type UseAaveChainsArgs, type UseAaveMarketArgs, type UseAaveMarketsArgs, type UseAaveReserveArgs, type UseBorrowAPYHistoryArgs, type UseCreditDelegateeAllowanceArgs, type UseSupplyAPYHistoryArgs, type UseUsdExchangeRatesArgs, type UseUserBorrowsArgs, type UseUserStateArgs, type UseUserSuppliesArgs, type UseUserTransactionHistoryArgs, type UseUserVaultsArgs, type UseVaultArgs, type UseVaultUserActivityArgs, type UseVaultUserTransactionHistoryArgs, type UseVaultsArgs, type UserMeritRewardsArgs, useAaveChains, useAaveClient, useAaveHealth, useAaveHealthFactorPreview, useAaveMarket, useAaveMarkets, useAaveReserve, useApproveBorrowCreditDelegation, useBorrow, useBorrowAPYHistory, useCollateralToggle, useCreditDelegateeAllowance, useLiquidate, useRepay, useSavingsGhoBalance, useSavingsGhoDeposit, useSavingsGhoWithdraw, useSupply, useSupplyAPYHistory, useUsdExchangeRates, useUserBorrows, useUserEMode, useUserMarketState, useUserMeritRewards, useUserSupplies, useUserTransactionHistory, useUserVaults, useVault, useVaultDeploy, useVaultDeposit, useVaultDepositPreview, useVaultMintPreview, useVaultMintShares, useVaultRedeemPreview, useVaultRedeemShares, useVaultSetFee, useVaultTransferOwnership, useVaultUserActivity, useVaultUserTransactionHistory, useVaultWithdraw, useVaultWithdrawFees, useVaultWithdrawPreview, useVaults, useWithdraw };