@aave/react 4.0.0-next.1 → 4.0.0-next.2

package/dist/index.d.ts

@@ -0,0 +1,2670 @@
+import { AaveClient, CurrencyQueryOptions, UnexpectedError, TimeWindowQueryOptions, ValidationError, ActivitiesRequest, PaginatedActivitiesResult } from '@aave/client';
+export * from '@aave/client';
+import React, { ReactNode } from 'react';
+import { a as UseAsyncTask, C as CancelOperation, S as SendTransactionError, P as PendingTransactionError, b as PendingTransaction, T as TransactionHandler } from './writes-BXnwYgAQ.js';
+export { A as AsyncTaskError, c as AsyncTaskIdle, d as AsyncTaskLoading, e as AsyncTaskState, f as AsyncTaskSuccess, g as TransactionHandlerOptions, U as UseSendTransactionResult } from './writes-BXnwYgAQ.js';
+import { HubRequest, Hub, HubsRequest, HubAssetsRequest, HubAsset, PermitRequest, PermitTypedDataResponse, AssetRequest, Asset, AssetPriceHistoryRequest, AssetPriceSample, AssetSupplyHistoryRequest, AssetSupplySample, AssetBorrowHistoryRequest, AssetBorrowSample, ReserveRequest, Reserve, ReservesRequest, BorrowAPYHistoryRequest, APYSample, SupplyAPYHistoryRequest, SpokeRequest, Spoke, SpokesRequest, SpokePositionManagersRequest, PaginatedSpokePositionManagerResult, SpokeUserPositionManagersRequest, PaginatedSpokeUserPositionManagerResult, SwapQuoteRequest, SwapQuote, SwappableTokensRequest, Token, UserSwapsRequest, PaginatedUserSwapsResult, PrepareSwapRequest, SwapByIntentTypedData, SwapByIntentWithApprovalRequired, SwapTransactionRequest, SwapApprovalRequired, ERC20PermitSignature, SwapReceipt, InsufficientBalanceError, CancelSwapTypedData, TransactionRequest, PrepareSwapCancelRequest, SwapCancelled, SupplyRequest, BorrowRequest, RepayRequest, WithdrawRequest, RenounceSpokeUserPositionManagerRequest, UpdateUserRiskPremiumRequest, UpdateUserDynamicConfigRequest, SetUserSupplyAsCollateralRequest, LiquidatePositionRequest, SetSpokeUserPositionManagerRequest, PreviewRequest, PreviewUserPosition, UserSuppliesRequest, UserSupplyItem, UserBorrowsRequest, UserBorrowItem, UserSummaryRequest, UserSummary, UserPositionsRequest, UserPosition, UserPositionRequest, UserBalancesRequest, UserBalance, UserSummaryHistoryRequest, UserSummaryHistoryItem } from '@aave/graphql';
+import { Prettify, ResultAsync, ResultAwareError, TxHash } from '@aave/types';
+import { S as Suspendable, a as SuspenseResult, P as Pausable, b as PausableSuspenseResult, R as ReadResult, c as PausableReadResult, d as Selector } from './misc-gmAnSdm5.js';
+export { e as UseChainArgs, f as UseChainsArgs, i as UseExchangeRateArgs, U as UseNetworkFee, l as UseNetworkFeeArgs, k as UseNetworkFeeRequestQuery, u as useChain, g as useChains, j as useExchangeRate, h as useExchangeRateAction } from './misc-gmAnSdm5.js';
+import { UnexpectedError as UnexpectedError$1, SigningError, CancelError, TimeoutError, TransactionError, ValidationError as ValidationError$1 } from '@aave/core';
+import { UserPositionQueryOptions } from '@aave/client/actions';
+
+/**
+ * <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;
+
+/**
+ * @internal
+ */
+declare function useAaveClient(): AaveClient;
+
+type UseHubArgs = Prettify<HubRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a specific hub by ID or by address and chain ID.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useHub({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   suspense: true,
+ * });
+ * // data will be Hub | null
+ * ```
+ */
+declare function useHub(args: UseHubArgs & Suspendable): SuspenseResult<Hub | null>;
+/**
+ * Fetch a specific hub by ID or by address and chain ID.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useHub({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHub(args: Pausable<UseHubArgs> & Suspendable): PausableSuspenseResult<Hub | null>;
+/**
+ * Fetch a specific hub by ID or by address and chain ID.
+ *
+ * ```tsx
+ * const { data, error, loading } = useHub({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ * });
+ * // data will be Hub | null
+ * ```
+ */
+declare function useHub(args: UseHubArgs): ReadResult<Hub | null>;
+/**
+ * Fetch a specific hub by ID or by address and chain ID.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useHub({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHub(args: Pausable<UseHubArgs>): PausableReadResult<Hub | null>;
+type UseHubsArgs = Prettify<HubsRequest & CurrencyQueryOptions>;
+/**
+ * Fetch multiple hubs based on specified criteria.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useHubs({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useHubs(args: UseHubsArgs & Suspendable): SuspenseResult<Hub[]>;
+/**
+ * Fetch multiple hubs based on specified criteria.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useHubs({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubs(args: Pausable<UseHubsArgs> & Suspendable): PausableSuspenseResult<Hub[]>;
+/**
+ * Fetch multiple hubs based on specified criteria.
+ *
+ * ```tsx
+ * const { data, error, loading } = useHubs({
+ *   query: { chainIds: [chainId(1)] },
+ * });
+ * ```
+ */
+declare function useHubs(args: UseHubsArgs): ReadResult<Hub[]>;
+/**
+ * Fetch multiple hubs based on specified criteria.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useHubs({
+ *   query: { chainIds: [chainId(1)] },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubs(args: Pausable<UseHubsArgs>): PausableReadResult<Hub[]>;
+type UseHubAssetsArgs = Prettify<HubAssetsRequest & CurrencyQueryOptions>;
+/**
+ * Fetch hub assets for a specific hub by ID or by address and chain ID.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useHubAssets({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   user: evmAddress('0x456...'), // optional
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useHubAssets(args: UseHubAssetsArgs & Suspendable): SuspenseResult<HubAsset[]>;
+/**
+ * Fetch hub assets for a specific hub by ID or by address and chain ID.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useHubAssets({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   user: evmAddress('0x456...'), // optional
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubAssets(args: Pausable<UseHubAssetsArgs> & Suspendable): PausableSuspenseResult<HubAsset[]>;
+/**
+ * Fetch hub assets for a specific hub by ID or by address and chain ID.
+ *
+ * ```tsx
+ * const { data, error, loading } = useHubAssets({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   user: evmAddress('0x456...'), // optional
+ * });
+ * ```
+ */
+declare function useHubAssets(args: UseHubAssetsArgs): ReadResult<HubAsset[]>;
+/**
+ * Fetch hub assets for a specific hub by ID or by address and chain ID.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useHubAssets({
+ *   query: { hubId: hubId('SGVsbG8h') },
+ *   user: evmAddress('0x456...'), // optional
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useHubAssets(args: Pausable<UseHubAssetsArgs>): PausableReadResult<HubAsset[]>;
+/**
+ * Low-level hook to execute a {@link hubs} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on the hubs.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useHubsAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   query: {
+ *     chainIds: [chainId(1)]
+ *   }
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Hub[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useHubsAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<HubsRequest, Hub[], UnexpectedError>;
+
+/**
+ * @internal
+ */
+declare function usePermitTypedDataAction(): UseAsyncTask<PermitRequest, PermitTypedDataResponse, UnexpectedError>;
+
+type UseAssetArgs = Prettify<AssetRequest & CurrencyQueryOptions & TimeWindowQueryOptions>;
+/**
+ * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAsset({
+ *   query: { assetId: assetId('SGVsbG8h') },
+ *   suspense: true,
+ * });
+ * // data will be Asset | null
+ * ```
+ */
+declare function useAsset(args: UseAssetArgs & Suspendable): SuspenseResult<Asset | null>;
+/**
+ * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useAsset({
+ *   query: { assetId: assetId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useAsset(args: Pausable<UseAssetArgs> & Suspendable): PausableSuspenseResult<Asset | null>;
+/**
+ * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAsset({
+ *   query: { assetId: assetId('SGVsbG8h') },
+ * });
+ * // data will be Asset | null
+ * ```
+ */
+declare function useAsset(args: UseAssetArgs): ReadResult<Asset | null>;
+/**
+ * Fetch information about a specific asset (ERC20 token) in the protocol by ID or by token.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useAsset({
+ *   query: { assetId: assetId('SGVsbG8h') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useAsset(args: Pausable<UseAssetArgs>): PausableReadResult<Asset | null>;
+type UseAssetPriceHistoryArgs = AssetPriceHistoryRequest;
+/**
+ * Fetch historical price data for a specific asset.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAssetPriceHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useAssetPriceHistory(args: UseAssetPriceHistoryArgs & Suspendable): SuspenseResult<AssetPriceSample[]>;
+/**
+ * Fetch historical price data for a specific asset.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useAssetPriceHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useAssetPriceHistory(args: Pausable<UseAssetPriceHistoryArgs> & Suspendable): PausableSuspenseResult<AssetPriceSample[]>;
+/**
+ * Fetch historical price data for a specific asset.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAssetPriceHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   currency: Currency.Usd,
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useAssetPriceHistory(args: UseAssetPriceHistoryArgs): ReadResult<AssetPriceSample[]>;
+/**
+ * Fetch historical price data for a specific asset.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useAssetPriceHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useAssetPriceHistory(args: Pausable<UseAssetPriceHistoryArgs>): PausableReadResult<AssetPriceSample[]>;
+type UseAssetSupplyHistoryArgs = AssetSupplyHistoryRequest;
+/**
+ * Fetch historical supply data for a specific asset.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAssetSupplyHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useAssetSupplyHistory(args: UseAssetSupplyHistoryArgs & Suspendable): SuspenseResult<AssetSupplySample[]>;
+/**
+ * Fetch historical supply data for a specific asset.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useAssetSupplyHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useAssetSupplyHistory(args: Pausable<UseAssetSupplyHistoryArgs> & Suspendable): PausableSuspenseResult<AssetSupplySample[]>;
+/**
+ * Fetch historical supply data for a specific asset.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAssetSupplyHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useAssetSupplyHistory(args: UseAssetSupplyHistoryArgs): ReadResult<AssetSupplySample[]>;
+/**
+ * Fetch historical supply data for a specific asset.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useAssetSupplyHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useAssetSupplyHistory(args: Pausable<UseAssetSupplyHistoryArgs>): PausableReadResult<AssetSupplySample[]>;
+type UseAssetBorrowHistoryArgs = AssetBorrowHistoryRequest;
+/**
+ * Fetch historical borrow data for a specific asset.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useAssetBorrowHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useAssetBorrowHistory(args: UseAssetBorrowHistoryArgs & Suspendable): SuspenseResult<AssetBorrowSample[]>;
+/**
+ * Fetch historical borrow data for a specific asset.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useAssetBorrowHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useAssetBorrowHistory(args: Pausable<UseAssetBorrowHistoryArgs> & Suspendable): PausableSuspenseResult<AssetBorrowSample[]>;
+/**
+ * Fetch historical borrow data for a specific asset.
+ *
+ * ```tsx
+ * const { data, error, loading } = useAssetBorrowHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useAssetBorrowHistory(args: UseAssetBorrowHistoryArgs): ReadResult<AssetBorrowSample[]>;
+/**
+ * Fetch historical borrow data for a specific asset.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useAssetBorrowHistory({
+ *   token: { chainId: chainId(1), address: evmAddress('0x123...') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useAssetBorrowHistory(args: Pausable<UseAssetBorrowHistoryArgs>): PausableReadResult<AssetBorrowSample[]>;
+
+type UseReserveArgs = Prettify<ReserveRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a specific reserve by reserve ID, spoke, and chain.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useReserve({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   user: evmAddress('0xabc...'),
+ *   suspense: true,
+ * });
+ * // data will be Reserve | null
+ * ```
+ */
+declare function useReserve(args: UseReserveArgs & Suspendable): SuspenseResult<Reserve | null>;
+/**
+ * Fetch a specific reserve by reserve ID, spoke, and chain.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useReserve({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useReserve(args: Pausable<UseReserveArgs> & Suspendable): PausableSuspenseResult<Reserve | null>;
+/**
+ * Fetch a specific reserve by reserve ID, spoke, and chain.
+ *
+ * ```tsx
+ * const { data, error, loading } = useReserve({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   user: evmAddress('0xabc...'),
+ * });
+ * // data will be Reserve | null
+ * ```
+ */
+declare function useReserve(args: UseReserveArgs): ReadResult<Reserve | null>;
+/**
+ * Fetch a specific reserve by reserve ID, spoke, and chain.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useReserve({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useReserve(args: Pausable<UseReserveArgs>): PausableReadResult<Reserve | null>;
+/**
+ * Low-level hook to execute a {@link reserve} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on the reserve.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useReserveAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   reserve: reserveId('SGVsbG8h'),
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Reserve | null
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useReserveAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ReserveRequest, Reserve | null, UnexpectedError>;
+type UseReservesArgs<T = Reserve[]> = Prettify<ReservesRequest & CurrencyQueryOptions & {
+    /**
+     * A function that maps the full list of reserves
+     * into a derived or narrowed value.
+     *
+     * Example: pick a single reserve based on a criteria.
+     *
+     * @experimental This is experimental and may be subject to breaking changes.
+     */
+    selector?: Selector<Reserve[], T>;
+}>;
+/**
+ * Fetch reserves based on specified criteria.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   filter: ReservesRequestFilter.All,
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ * });
+ * ```
+ *
+ * **Reserves with Highest Supply APY**
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   suspense: true,
+ *   selector: pickHighestSupplyApyReserve,
+ * });
+ * ```
+ *
+ * **Reserves with Lowest Borrow APY**
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   suspense: true,
+ *   selector: pickLowestBorrowApyReserve,
+ * });
+ * ```
+ */
+declare function useReserves<T = Reserve[]>(args: UseReservesArgs<T> & Suspendable): SuspenseResult<T>;
+/**
+ * Fetch reserves based on specified criteria.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>> & Suspendable): PausableSuspenseResult<T>;
+/**
+ * Fetch reserves based on specified criteria.
+ *
+ * ```tsx
+ * const { data, error, loading } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   filter: ReservesRequestFilter.All,
+ *   orderBy: { name: 'ASC' },
+ * });
+ * ```
+ *
+ * **Reserves with Highest Supply APY**
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   selector: pickHighestSupplyApyReserve,
+ * });
+ * ```
+ *
+ * **Reserves with Lowest Borrow APY**
+ * ```tsx
+ * const { data } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   selector: pickLowestBorrowApyReserve,
+ * });
+ * ```
+ */
+declare function useReserves<T = Reserve[]>(args: UseReservesArgs<T>): ReadResult<T>;
+/**
+ * Fetch reserves based on specified criteria.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useReserves({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x123...'),
+ *       chainId: chainId(1)
+ *     }
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useReserves<T = Reserve[]>(args: Pausable<UseReservesArgs<T>>): PausableReadResult<T>;
+/**
+ * Low-level hook to execute a {@link reserves} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on the reserves.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useReservesAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   query: {
+ *     spoke: {
+ *       address: evmAddress('0x1234…'),
+ *       chainId: chainId(1)
+ *     }
+ *   }
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Reserve[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * **Reserves with Highest Supply APY**
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useReservesAction();
+ *
+ * // …
+ *
+ * const result = await execute(…).map(pickHighestSupplyApyReserve);
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Reserve | null
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * **Reserves with Lowest Borrow APY**
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useReservesAction();
+ *
+ * // …
+ *
+ * const result = await execute(…).map(pickLowestBorrowApyReserve);
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // Reserve | null
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useReservesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ReservesRequest, Reserve[], UnexpectedError>;
+type UseBorrowApyHistoryArgs = BorrowAPYHistoryRequest;
+/**
+ * Fetch borrow APY history for a specific reserve over time.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useBorrowApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+/**
+ * Fetch borrow APY history for a specific reserve over time.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useBorrowApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs> & Suspendable): PausableSuspenseResult<APYSample[]>;
+/**
+ * Fetch borrow APY history for a specific reserve over time.
+ *
+ * ```tsx
+ * const { data, error, loading } = useBorrowApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useBorrowApyHistory(args: UseBorrowApyHistoryArgs): ReadResult<APYSample[]>;
+/**
+ * Fetch borrow APY history for a specific reserve over time.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useBorrowApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useBorrowApyHistory(args: Pausable<UseBorrowApyHistoryArgs>): PausableReadResult<APYSample[]>;
+type UseSupplyApyHistoryArgs = SupplyAPYHistoryRequest;
+/**
+ * Fetch supply APY history for a specific reserve over time.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSupplyApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs & Suspendable): SuspenseResult<APYSample[]>;
+/**
+ * Fetch supply APY history for a specific reserve over time.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSupplyApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs> & Suspendable): PausableSuspenseResult<APYSample[]>;
+/**
+ * Fetch supply APY history for a specific reserve over time.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSupplyApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ * });
+ * ```
+ */
+declare function useSupplyApyHistory(args: UseSupplyApyHistoryArgs): ReadResult<APYSample[]>;
+/**
+ * Fetch supply APY history for a specific reserve over time.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSupplyApyHistory({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   window: TimeWindow.LastWeek,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSupplyApyHistory(args: Pausable<UseSupplyApyHistoryArgs>): PausableReadResult<APYSample[]>;
+
+type UseSpokeArgs = SpokeRequest;
+/**
+ * Fetch a specific spoke.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   suspense: true,
+ * });
+ * // data will be Spoke | null
+ * ```
+ */
+declare function useSpoke(args: UseSpokeArgs & Suspendable): SuspenseResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpoke(args: Pausable<UseSpokeArgs> & Suspendable): PausableSuspenseResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ * });
+ * // data will be Spoke | null
+ * ```
+ */
+declare function useSpoke(args: UseSpokeArgs): ReadResult<Spoke | null>;
+/**
+ * Fetch a specific spoke.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpoke({
+ *   query: { spokeId: spokeId('SGVsbG8h') },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpoke(args: Pausable<UseSpokeArgs>): PausableReadResult<Spoke | null>;
+type UseSpokesArgs = SpokesRequest;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSpokes(args: UseSpokesArgs & Suspendable): SuspenseResult<Spoke[]>;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokes(args: Pausable<UseSpokesArgs> & Suspendable): PausableSuspenseResult<Spoke[]>;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ * });
+ * ```
+ */
+declare function useSpokes(args: UseSpokesArgs): ReadResult<Spoke[]>;
+/**
+ * Fetch spokes based on specified criteria.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpokes({
+ *   query: { chainIds: [chainId(1)] },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokes(args: Pausable<UseSpokesArgs>): PausableReadResult<Spoke[]>;
+type UseSpokePositionManagersArgs = SpokePositionManagersRequest;
+/**
+ * Fetches all the positions manager for a specific spoke.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpokePositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSpokePositionManagers(args: UseSpokePositionManagersArgs & Suspendable): SuspenseResult<PaginatedSpokePositionManagerResult>;
+/**
+ * Fetches all the positions manager for a specific spoke.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpokePositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokePositionManagers(args: Pausable<UseSpokePositionManagersArgs> & Suspendable): PausableSuspenseResult<PaginatedSpokePositionManagerResult>;
+/**
+ * Fetches all the positions manager for a specific spoke.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpokePositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ * });
+ * ```
+ */
+declare function useSpokePositionManagers(args: UseSpokePositionManagersArgs): ReadResult<PaginatedSpokePositionManagerResult>;
+/**
+ * Fetches all the positions manager for a specific spoke.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpokePositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokePositionManagers(args: Pausable<UseSpokePositionManagersArgs>): PausableReadResult<PaginatedSpokePositionManagerResult>;
+type UseSpokeUserPositionManagersArgs = SpokeUserPositionManagersRequest;
+/**
+ * Fetches all the position managers of a user for a specific spoke
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSpokeUserPositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSpokeUserPositionManagers(args: UseSpokeUserPositionManagersArgs & Suspendable): SuspenseResult<PaginatedSpokeUserPositionManagerResult>;
+/**
+ * Fetches all the position managers of a user for a specific spoke
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSpokeUserPositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokeUserPositionManagers(args: Pausable<UseSpokeUserPositionManagersArgs> & Suspendable): PausableSuspenseResult<PaginatedSpokeUserPositionManagerResult>;
+/**
+ * Fetches all the position managers of a user for a specific spoke
+ *
+ * ```tsx
+ * const { data, error, loading } = useSpokeUserPositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
+ * });
+ * ```
+ */
+declare function useSpokeUserPositionManagers(args: UseSpokeUserPositionManagersArgs): ReadResult<PaginatedSpokeUserPositionManagerResult>;
+/**
+ * Fetches all the position managers of a user for a specific spoke
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSpokeUserPositionManagers({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   user: evmAddress('0x123...'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSpokeUserPositionManagers(args: Pausable<UseSpokeUserPositionManagersArgs>): PausableReadResult<PaginatedSpokeUserPositionManagerResult>;
+
+type UseSwapQuoteArgs = Prettify<SwapQuoteRequest & CurrencyQueryOptions>;
+/**
+ * @internal
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSwapQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSwapQuote(args: UseSwapQuoteArgs & Suspendable): SuspenseResult<SwapQuote>;
+/**
+ * @internal
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSwapQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ *   from: evmAddress('0x742d35cc...'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs> & Suspendable): PausableSuspenseResult<SwapQuote>;
+/**
+ * @internal
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSwapQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ * });
+ * ```
+ */
+declare function useSwapQuote(args: UseSwapQuoteArgs): ReadResult<SwapQuote>;
+/**
+ * @internal
+ * Fetch a swap quote for the specified trade parameters.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSwapQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ *   from: evmAddress('0x742d35cc...'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwapQuote(args: Pausable<UseSwapQuoteArgs>): PausableReadResult<SwapQuote>;
+/**
+ * @internal
+ * Low-level hook to execute a swap quote action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on the swap quote.
+ * Use this hook to retrieve quotes on demand as part of a larger workflow
+ * (e.g., in an event handler to get a fresh quote before executing a swap).
+ *
+ * ```ts
+ * const [getQuote, { called, data, error, loading }] = useSwapQuoteAction();
+ *
+ * // …
+ *
+ * const result = await getQuote({
+ *   chainId: chainId(1),
+ *   buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *   sell: { erc20: evmAddress('0x6B175474E...') },
+ *   amount: bigDecimal('1000'),
+ *   kind: SwapKind.SELL,
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log('Swap quote:', result.value);
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useSwapQuoteAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<SwapQuoteRequest, SwapQuote, UnexpectedError$1>;
+type UseSwappableTokensArgs = SwappableTokensRequest;
+/**
+ * @internal
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: UseSwappableTokensArgs & Suspendable): SuspenseResult<Token[]>;
+/**
+ * @internal
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs> & Suspendable): PausableSuspenseResult<Token[]>;
+/**
+ * @internal
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * ```tsx
+ * const { data, error, loading } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: UseSwappableTokensArgs): ReadResult<Token[]>;
+/**
+ * @internal
+ * Fetch the list of tokens available for swapping on a specific chain.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useSwappableTokens({
+ *   query: { chainIds: [chainId(1)] },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useSwappableTokens(args: Pausable<UseSwappableTokensArgs>): PausableReadResult<Token[]>;
+type UseUserSwapsArgs = Prettify<UserSwapsRequest & CurrencyQueryOptions>;
+/**
+ * @internal
+ * Fetch the user's swap history for a specific chain.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: UseUserSwapsArgs & Suspendable): SuspenseResult<PaginatedUserSwapsResult>;
+/**
+ * @internal
+ * Fetch the user's swap history for a specific chain.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: Pausable<UseUserSwapsArgs> & Suspendable): PausableSuspenseResult<PaginatedUserSwapsResult>;
+/**
+ * @internal
+ * Fetch the user's swap history for a specific chain.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: UseUserSwapsArgs): ReadResult<PaginatedUserSwapsResult>;
+/**
+ * @internal
+ * Fetch the user's swap history for a specific chain.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserSwaps({
+ *   chainId: chainId(1),
+ *   user: evmAddress('0x742d35cc...'),
+ *   filterBy: [SwapStatusFilter.FULFILLED, SwapStatusFilter.OPEN],
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSwaps(args: Pausable<UseUserSwapsArgs>): PausableReadResult<PaginatedUserSwapsResult>;
+type UseSwapTokensRequest = Prettify<PrepareSwapRequest & CurrencyQueryOptions>;
+type SwapIntent = SwapByIntentTypedData | SwapByIntentWithApprovalRequired | SwapTransactionRequest | SwapApprovalRequired;
+type SwapHandlerOptions = {
+    cancel: CancelOperation;
+};
+type SwapHandler = (intent: SwapIntent, options: SwapHandlerOptions) => ResultAsync<ERC20PermitSignature | SwapReceipt, SendTransactionError | PendingTransactionError>;
+/**
+ * @internal
+ * Orchestrate the swap execution plan.
+ *
+ * ```tsx
+ * const [sendTransaction, sending] = useSendTransaction(wallet);
+ * const [signSwapByIntentWith, signing] = useSignSwapByIntentWith(wallet);
+ *
+ * const [swap, swapping] = useSwapTokens((plan) => {
+ *   switch (plan.__typename) {
+ *     case 'SwapByIntentTypedData':
+ *       return signSwapByIntentWith(plan);
+ *
+ *     case 'SwapApprovalRequired':
+ *     case 'SwapByIntentWithApprovalRequired':
+ *       return sendTransaction(plan.transaction);
+ *
+ *     case 'SwapTransactionRequest':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * const result = await swap({
+ *   market: {
+ *     chainId: chainId(1),
+ *     buy: { erc20: evmAddress('0xA0b86a33E6...') },
+ *     sell: { erc20: evmAddress('0x6B175474E...') },
+ *     amount: bigDecimal('1000'),
+ *     kind: SwapKind.SELL,
+ *     user: evmAddress('0x742d35cc...'),
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapReceipt
+ * ```
+ */
+declare function useSwapTokens(handler: SwapHandler): UseAsyncTask<PrepareSwapRequest, SwapReceipt, SendTransactionError | PendingTransactionError | ValidationError<InsufficientBalanceError>>;
+type CancelSwapHandler = (data: CancelSwapTypedData | TransactionRequest) => ResultAsync<ERC20PermitSignature | PendingTransaction, SigningError | UnexpectedError$1>;
+declare class CannotCancelSwapError extends ResultAwareError {
+    name: "CannotCancelSwapError";
+}
+type CancelSwapError = CancelError | CannotCancelSwapError | SigningError | TimeoutError | TransactionError | UnexpectedError$1;
+/**
+ * @internal
+ * Executes the complete swap cancellation workflow combining preparation and execution.
+ *
+ * ```tsx
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [signSwapCancelWith] = useSignSwapCancelWith(wallet);
+ *
+ * const [cancelSwap, {loading, error}] = useCancelSwap((plan: CancelSwapTypedData | TransactionRequest) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *
+ *     case 'CancelSwapTypedData':
+ *       return signSwapCancelWith(plan);
+ *   }
+ * });
+ *
+ * const result = await cancelSwap({
+ *   id: swapId('123...'),
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * // result.value: SwapCancelled
+ * console.log('Swap cancelled:', result.value);
+ * ```
+ */
+declare function useCancelSwap(handler: CancelSwapHandler): UseAsyncTask<PrepareSwapCancelRequest, SwapCancelled, CancelSwapError>;
+
+/**
+ * A hook that provides a way to supply assets to an Aave reserve.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [supply, { loading, error }] = useSupply((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * // …
+ *
+ * const result = await supply({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useSupply(handler: TransactionHandler): UseAsyncTask<SupplyRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+/**
+ * A hook that provides a way to borrow assets from an Aave reserve.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [borrow, { loading, error }] = useBorrow((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * // …
+ *
+ * const result = await borrow({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useBorrow(handler: TransactionHandler): UseAsyncTask<BorrowRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+/**
+ * A hook that provides a way to repay borrowed assets to an Aave reserve.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [repay, { loading, error }] = useRepay((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * // …
+ *
+ * const result = await repay({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useRepay(handler: TransactionHandler): UseAsyncTask<RepayRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+/**
+ * A hook that provides a way to withdraw supplied assets from an Aave reserve.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [withdraw, { loading, error }] = useWithdraw((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * // …
+ *
+ * const result = await withdraw({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useWithdraw(handler: TransactionHandler): UseAsyncTask<WithdrawRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+/**
+ * A hook that provides a way to renounce a position manager of a user for a specific spoke.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [renounceSpokeUserPositionManager, { loading, error }] = useRenounceSpokeUserPositionManager(sendTransaction);
+ *
+ * // …
+ *
+ * const result = await renounceSpokeUserPositionManager({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useRenounceSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<RenounceSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * A hook that provides a way to update the user risk premium for a spoke.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [updateUserRiskPremium, { loading, error }] = useUpdateUserRiskPremium((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
+ *
+ * // …
+ *
+ * const result = await updateUserRiskPremium({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useUpdateUserRiskPremium(handler: TransactionHandler): UseAsyncTask<UpdateUserRiskPremiumRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * A hook that provides a way to update the user dynamic configuration for a spoke.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [updateUserDynamicConfig, { loading, error }] = useUpdateUserDynamicConfig((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
+ *
+ * // …
+ *
+ * const result = await updateUserDynamicConfig({ ... });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useUpdateUserDynamicConfig(handler: TransactionHandler): UseAsyncTask<UpdateUserDynamicConfigRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * Hook for setting whether a user's supply should be used as collateral.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [setUserSupplyAsCollateral, { loading, error }] = useSetUserSupplyAsCollateral((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
+ *
+ * const result = await setUserSupplyAsCollateral({
+ *   reserve: reserveId('SGVsbG8h'),
+ *   sender: evmAddress('0x456...'),
+ *   enableCollateral: true,
+ * });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useSetUserSupplyAsCollateral(handler: TransactionHandler): UseAsyncTask<SetUserSupplyAsCollateralRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * A hook that provides a way to liquidate a user's position.
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [liquidatePosition, { loading, error }] = useLiquidatePosition((plan, { cancel }) => {
+ *   switch (plan.__typename) {
+ *     case 'TransactionRequest':
+ *       return sendTransaction(plan);
+ *     case 'Erc20ApprovalRequired':
+ *     case 'PreContractActionRequired':
+ *       return sendTransaction(plan.transaction);
+ *   }
+ * });
+ *
+ * // …
+ *
+ * const result = await liquidatePosition({
+ *   collateral: reserveId('SGVsbG8h'),
+ *   debt: reserveId('Q2lhbyE= '),
+ *   amount: amount,
+ *   liquidator: liquidator,
+ *   borrower: borrower,
+ * });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'ValidationError':
+ *       console.error(`Insufficient balance: ${result.error.cause.required.value} required.`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transactions.
+ */
+declare function useLiquidatePosition(handler: TransactionHandler): UseAsyncTask<LiquidatePositionRequest, TxHash, SendTransactionError | PendingTransactionError | ValidationError$1<InsufficientBalanceError>>;
+/**
+ * A hook that provides a way to set or remove a position manager for a user on a specific spoke.
+ *
+ * **Position managers** can perform transactions on behalf of other users, including:
+ * - Supply assets
+ * - Borrow assets
+ * - Withdraw assets
+ * - Enable/disable collateral
+ *
+ * The `signature` parameter is an **ERC712 signature** that must be signed by the **user**
+ * (the account granting permissions) to authorize the position manager. The signature contains:
+ * - `value`: The actual cryptographic signature
+ * - `deadline`: Unix timestamp when the authorization expires
+ *
+ * ```ts
+ * const [sendTransaction] = useSendTransaction(wallet);
+ * const [setSpokeUserPositionManager, { loading, error }] = useSetSpokeUserPositionManager((transaction, { cancel }) => {
+ *   return sendTransaction(transaction);
+ * });
+ *
+ * const result = await setSpokeUserPositionManager({
+ *   spoke: spokeId('SGVsbG8h'),
+ *   manager: evmAddress('0x9abc…'), // Address that will become the position manager
+ *   approve: true, // true to approve, false to remove the manager
+ *   user: evmAddress('0xdef0…'), // User granting the permission (must sign the signature)
+ *   signature: {
+ *     value: '0x1234...', // ERC712 signature signed by the user
+ *     deadline: 1735689600, // Unix timestamp when signature expires
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   switch (result.error.name) {
+ *     case 'CancelError':
+ *       // The user cancelled the operation
+ *       return;
+ *
+ *     case 'SigningError':
+ *       console.error(`Failed to sign the transaction: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TimeoutError':
+ *       console.error(`Transaction timed out: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'TransactionError':
+ *       console.error(`Transaction failed: ${result.error.message}`);
+ *       break;
+ *
+ *     case 'UnexpectedError':
+ *       console.error(result.error.message);
+ *       break;
+ *   }
+ *   return;
+ * }
+ *
+ * console.log('Transaction sent with hash:', result.value);
+ * ```
+ *
+ * @param handler - The handler that will be used to handle the transaction.
+ */
+declare function useSetSpokeUserPositionManager(handler: TransactionHandler): UseAsyncTask<SetSpokeUserPositionManagerRequest, TxHash, SendTransactionError | PendingTransactionError>;
+/**
+ * Preview the impact of a potential action on a user's position.
+ *
+ * ```tsx
+ * const [getPreview, previewing] = usePreviewAction();
+ *
+ * const loading = previewing.loading;
+ * const error = previewing.error;
+ *
+ * // …
+ *
+ * const result = await getPreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           value: '1000',
+ *         },
+ *       },
+ *       sender: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Preview result:', result.value);
+ * ```
+ */
+declare function usePreviewAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<PreviewRequest, PreviewUserPosition, UnexpectedError>;
+type UsePreviewArgs = Prettify<PreviewRequest & CurrencyQueryOptions>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: UsePreviewArgs & Suspendable): SuspenseResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: Pausable<UsePreviewArgs> & Suspendable): PausableSuspenseResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * ```tsx
+ * const { data, error, loading } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function usePreview(args: UsePreviewArgs): ReadResult<PreviewUserPosition>;
+/**
+ * Fetch a preview of the impact of a potential action on a user's position.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = usePreview({
+ *   action: {
+ *     supply: {
+ *       reserve: reserveId('SGVsbG8h'),
+ *       amount: {
+ *         erc20: {
+ *           currency: evmAddress('0x5678…'),
+ *           value: '1000',
+ *         },
+ *       },
+ *       supplier: evmAddress('0x9abc…'),
+ *     },
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function usePreview(args: Pausable<UsePreviewArgs>): PausableReadResult<PreviewUserPosition>;
+type UseActivitiesArgs = Prettify<ActivitiesRequest & CurrencyQueryOptions>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
+ *
+ * // data.items: ActivityItem[]
+ * ```
+ */
+declare function useActivities(args: UseActivitiesArgs & Suspendable): SuspenseResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ *
+ * // data?.items: ActivityItem[] | undefined
+ * ```
+ */
+declare function useActivities(args: Pausable<UseActivitiesArgs> & Suspendable): PausableSuspenseResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ * ```
+ */
+declare function useActivities(args: UseActivitiesArgs): ReadResult<PaginatedActivitiesResult>;
+/**
+ * Fetch paginated list of activities.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading } = useActivities({
+ *   query: {
+ *     chainId: chainId(1),
+ *   },
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
+ * });
+ *
+ * // data?.items: ActivityItem[] | undefined
+ * // error: UnexpectedError | undefined
+ * // loading: boolean | undefined
+ * ```
+ */
+declare function useActivities(args: Pausable<UseActivitiesArgs>): PausableReadResult<PaginatedActivitiesResult>;
+/**
+ * Low-level hook to execute a {@link activities} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook does not actively watch for updates. Use it to fetch activities on demand
+ * (e.g., in an event handler when paginating or refining filters).
+ *
+ * @param options - The query options.
+ * @returns The user history.
+ */
+declare function useActivitiesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<ActivitiesRequest, PaginatedActivitiesResult, UnexpectedError>;
+
+type UseUserSuppliesArgs = Prettify<UserSuppliesRequest & CurrencyQueryOptions>;
+/**
+ * Fetch all user supply positions.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserSupplies({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserSupplies(args: UseUserSuppliesArgs & Suspendable): SuspenseResult<UserSupplyItem[]>;
+/**
+ * Fetch all user supply positions.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserSupplies({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ *
+ * // data?.length: number | undefined
+ * ```
+ */
+declare function useUserSupplies(args: Pausable<UseUserSuppliesArgs> & Suspendable): PausableSuspenseResult<UserSupplyItem[]>;
+/**
+ * Fetch all user supply positions.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserSupplies({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ * });
+ * ```
+ */
+declare function useUserSupplies(args: UseUserSuppliesArgs): ReadResult<UserSupplyItem[]>;
+/**
+ * Fetch all user supply positions.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserSupplies({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   pause: true,
+ * });
+ *
+ * // data?.length: number | undefined
+ * // error: UnexpectedError | undefined
+ * // loading: boolean | undefined
+ * // paused: boolean
+ * ```
+ */
+declare function useUserSupplies(args: Pausable<UseUserSuppliesArgs>): PausableReadResult<UserSupplyItem[]>;
+/**
+ * Low-level hook to execute a {@link userSupplies} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on user supplies.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserSuppliesAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserSupplyItem[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useUserSuppliesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<UserSuppliesRequest, UserSupplyItem[], UnexpectedError>;
+type UseUserBorrowsArgs = Prettify<UserBorrowsRequest & CurrencyQueryOptions>;
+/**
+ * Fetch all user borrow positions.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserBorrows({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: UseUserBorrowsArgs & Suspendable): SuspenseResult<UserBorrowItem[]>;
+/**
+ * Fetch all user borrow positions.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserBorrows({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: Pausable<UseUserBorrowsArgs> & Suspendable): PausableSuspenseResult<UserBorrowItem[]>;
+/**
+ * Fetch all user borrow positions.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserBorrows({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: UseUserBorrowsArgs): ReadResult<UserBorrowItem[]>;
+/**
+ * Fetch all user borrow positions.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserBorrows({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserBorrows(args: Pausable<UseUserBorrowsArgs>): PausableReadResult<UserBorrowItem[]>;
+/**
+ * Low-level hook to execute a {@link userBorrows} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on user borrows.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserBorrowsAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   query: {
+ *     userSpoke: {
+ *       spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *       user: evmAddress('0x742d35cc…'),
+ *     },
+ *   },
+ *   orderBy: { name: 'ASC' },
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserBorrowItem[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useUserBorrowsAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<UserBorrowsRequest, UserBorrowItem[], UnexpectedError>;
+type UseUserSummaryArgs = Prettify<UserSummaryRequest & TimeWindowQueryOptions & CurrencyQueryOptions>;
+/**
+ * Fetch a user's financial summary.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserSummary({
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *   },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserSummary(args: UseUserSummaryArgs & Suspendable): SuspenseResult<UserSummary>;
+/**
+ * Fetch a user's financial summary.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserSummary({
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *   },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSummary(args: Pausable<UseUserSummaryArgs> & Suspendable): PausableSuspenseResult<UserSummary>;
+/**
+ * Fetch a user's financial summary.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserSummary({
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *   },
+ * });
+ * ```
+ */
+declare function useUserSummary(args: UseUserSummaryArgs): ReadResult<UserSummary>;
+/**
+ * Fetch a user's financial summary.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserSummary({
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     spoke: { address: evmAddress('0x87870bca…'), chainId: chainId(1) },
+ *   },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSummary(args: Pausable<UseUserSummaryArgs>): PausableReadResult<UserSummary>;
+type UseUserPositionsArgs = Prettify<UserPositionsRequest & UserPositionQueryOptions>;
+/**
+ * Fetch all user positions across specified chains.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserPositions({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   orderBy: { balance: 'DESC' },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserPositions(args: UseUserPositionsArgs & Suspendable): SuspenseResult<UserPosition[]>;
+/**
+ * Fetch all user positions across specified chains.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserPositions({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   orderBy: { balance: 'DESC' },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserPositions(args: Pausable<UseUserPositionsArgs> & Suspendable): PausableSuspenseResult<UserPosition[]>;
+/**
+ * Fetch all user positions across specified chains.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserPositions({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   orderBy: { balance: 'DESC' },
+ * });
+ * ```
+ */
+declare function useUserPositions(args: UseUserPositionsArgs): ReadResult<UserPosition[]>;
+/**
+ * Fetch all user positions across specified chains.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserPositions({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   orderBy: { balance: 'DESC' },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserPositions(args: Pausable<UseUserPositionsArgs>): PausableReadResult<UserPosition[]>;
+/**
+ * Low-level hook to execute a {@link userPositions} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on user positions.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserPositionsAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     chainIds: [chainId(1), chainId(137)]
+ *   },
+ *   orderBy: { balance: 'DESC' },
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserPosition[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useUserPositionsAction(options?: UserPositionQueryOptions): UseAsyncTask<UserPositionsRequest, UserPosition[], UnexpectedError>;
+type UseUserPositionArgs = Prettify<UserPositionRequest & UserPositionQueryOptions>;
+/**
+ * Fetch a specific user position by ID.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserPosition({
+ *   id: userPositionId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserPosition(args: UseUserPositionArgs & Suspendable): SuspenseResult<UserPosition>;
+/**
+ * Fetch a specific user position by ID.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserPosition({
+ *   id: userPositionId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserPosition(args: Pausable<UseUserPositionArgs> & Suspendable): PausableSuspenseResult<UserPosition>;
+/**
+ * Fetch a specific user position by ID.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserPosition({
+ *   id: userPositionId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
+ * });
+ * ```
+ */
+declare function useUserPosition(args: UseUserPositionArgs): ReadResult<UserPosition>;
+/**
+ * Fetch a specific user position by ID.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserPosition({
+ *   id: userPositionId('SGVsbG8h'),
+ *   user: evmAddress('0x742d35cc…'),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserPosition(args: Pausable<UseUserPositionArgs>): PausableReadResult<UserPosition>;
+type UseUserBalancesArgs = Prettify<UserBalancesRequest & CurrencyQueryOptions>;
+/**
+ * Fetch all user balances across specified chains.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserBalances({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserBalances(args: UseUserBalancesArgs & Suspendable): SuspenseResult<UserBalance[]>;
+/**
+ * Fetch all user balances across specified chains.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserBalances({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserBalances(args: Pausable<UseUserBalancesArgs> & Suspendable): PausableSuspenseResult<UserBalance[]>;
+/**
+ * Fetch all user balances across specified chains.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserBalances({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ * });
+ * ```
+ */
+declare function useUserBalances(args: UseUserBalancesArgs): ReadResult<UserBalance[]>;
+/**
+ * Fetch all user balances across specified chains.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserBalances({
+ *   user: evmAddress('0x742d35cc…'),
+ *   chainIds: [chainId(1), chainId(137)],
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserBalances(args: Pausable<UseUserBalancesArgs>): PausableReadResult<UserBalance[]>;
+/**
+ * Low-level hook to execute a {@link userBalances} action directly.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ * @remarks
+ * This hook **does not** actively watch for updated data on user balances.
+ * Use this hook to retrieve data on demand as part of a larger workflow
+ * (e.g., in an event handler in order to move to the next step).
+ *
+ * ```ts
+ * const [execute, { called, data, error, loading }] = useUserBalancesAction();
+ *
+ * // …
+ *
+ * const result = await execute({
+ *   user: evmAddress('0x742d35cc…'),
+ *   filter: {
+ *     chainIds: [chainId(1), chainId(137)]
+ *   },
+ * });
+ *
+ * if (result.isOk()) {
+ *   console.log(result.value); // UserBalance[]
+ * } else {
+ *   console.error(result.error);
+ * }
+ * ```
+ */
+declare function useUserBalancesAction(options?: Required<CurrencyQueryOptions>): UseAsyncTask<UserBalancesRequest, UserBalance[], UnexpectedError>;
+type UseUserSummaryHistoryArgs = Prettify<UserSummaryHistoryRequest & CurrencyQueryOptions>;
+/**
+ * Fetch user summary history over time.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useUserSummaryHistory({
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useUserSummaryHistory(args: UseUserSummaryHistoryArgs & Suspendable): SuspenseResult<UserSummaryHistoryItem[]>;
+/**
+ * Fetch user summary history over time.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useUserSummaryHistory({
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: { chainIds: [chainId(1)] },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSummaryHistory(args: Pausable<UseUserSummaryHistoryArgs> & Suspendable): PausableSuspenseResult<UserSummaryHistoryItem[]>;
+/**
+ * Fetch user summary history over time.
+ *
+ * ```tsx
+ * const { data, error, loading } = useUserSummaryHistory({
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: { chainIds: [chainId(1)] },
+ * });
+ * ```
+ */
+declare function useUserSummaryHistory(args: UseUserSummaryHistoryArgs): ReadResult<UserSummaryHistoryItem[]>;
+/**
+ * Fetch user summary history over time.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useUserSummaryHistory({
+ *   user: evmAddress('0x742d35cc…'),
+ *   window: TimeWindow.LastWeek,
+ *   filter: { chainIds: [chainId(1)] },
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useUserSummaryHistory(args: Pausable<UseUserSummaryHistoryArgs>): PausableReadResult<UserSummaryHistoryItem[]>;
+
+export { AaveProvider, type AaveProviderProps, type CancelSwapError, type CancelSwapHandler, CannotCancelSwapError, SendTransactionError, type SwapHandler, type SwapHandlerOptions, type SwapIntent, type UseActivitiesArgs, type UseAssetArgs, type UseAssetBorrowHistoryArgs, type UseAssetPriceHistoryArgs, type UseAssetSupplyHistoryArgs, UseAsyncTask, type UseBorrowApyHistoryArgs, type UseHubArgs, type UseHubAssetsArgs, type UseHubsArgs, type UsePreviewArgs, type UseReserveArgs, type UseReservesArgs, type UseSpokeArgs, type UseSpokePositionManagersArgs, type UseSpokeUserPositionManagersArgs, type UseSpokesArgs, type UseSupplyApyHistoryArgs, type UseSwapQuoteArgs, type UseSwapTokensRequest, type UseSwappableTokensArgs, type UseUserBalancesArgs, type UseUserBorrowsArgs, type UseUserPositionArgs, type UseUserPositionsArgs, type UseUserSummaryArgs, type UseUserSummaryHistoryArgs, type UseUserSuppliesArgs, type UseUserSwapsArgs, useAaveClient, useActivities, useActivitiesAction, useAsset, useAssetBorrowHistory, useAssetPriceHistory, useAssetSupplyHistory, useBorrow, useBorrowApyHistory, useCancelSwap, useHub, useHubAssets, useHubs, useHubsAction, useLiquidatePosition, usePermitTypedDataAction, usePreview, usePreviewAction, useRenounceSpokeUserPositionManager, useRepay, useReserve, useReserveAction, useReserves, useReservesAction, useSetSpokeUserPositionManager, useSetUserSupplyAsCollateral, useSpoke, useSpokePositionManagers, useSpokeUserPositionManagers, useSpokes, useSupply, useSupplyApyHistory, useSwapQuote, useSwapQuoteAction, useSwapTokens, useSwappableTokens, useUpdateUserDynamicConfig, useUpdateUserRiskPremium, useUserBalances, useUserBalancesAction, useUserBorrows, useUserBorrowsAction, useUserPosition, useUserPositions, useUserPositionsAction, useUserSummary, useUserSummaryHistory, useUserSupplies, useUserSuppliesAction, useUserSwaps, useWithdraw };