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

package/dist/misc-BkG5G4yl.d.cts

@@ -0,0 +1,377 @@
+import { UnexpectedError, CurrencyQueryOptions } from '@aave/client';
+import { UnexpectedError as UnexpectedError$1 } from '@aave/core';
+import { ChainRequest, Chain, ChainsFilter, ExchangeRateRequest, FiatAmount, ActivityItem, PreviewAction, NativeAmount } from '@aave/graphql';
+import { NullishDeep, Prettify } from '@aave/types';
+import { a as UseAsyncTask } from './writes-BXnwYgAQ.cjs';
+
+/**
+ * A read hook result that supports pausing.
+ */
+type PausableReadResult<T, E extends UnexpectedError = UnexpectedError> = {
+    data: T | undefined;
+    error: E | undefined;
+    loading: false;
+    paused: true;
+} | {
+    data: undefined;
+    error: undefined;
+    loading: true;
+    paused: false;
+} | {
+    data: T;
+    error: undefined;
+    loading: false;
+    paused: false;
+} | {
+    data: undefined;
+    error: E;
+    loading: false;
+    paused: false;
+};
+/**
+ * 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 extends UnexpectedError = UnexpectedError> = {
+    data: undefined;
+    error: undefined;
+    loading: true;
+} | {
+    data: T;
+    error: undefined;
+    loading: false;
+} | {
+    data: undefined;
+    error: E;
+    loading: false;
+};
+/**
+ * @internal
+ */
+declare const ReadResult: {
+    Loading: <T, E extends UnexpectedError = UnexpectedError>() => PausableReadResult<T, E>;
+    Success: <T, E extends UnexpectedError = UnexpectedError>(data: T) => PausableReadResult<T, E>;
+    Failure: <T, E extends UnexpectedError = UnexpectedError>(error: E) => PausableReadResult<T, E>;
+    Paused: <T, E extends UnexpectedError = UnexpectedError>(data: T | undefined, error: E | undefined) => PausableReadResult<T, E>;
+};
+/**
+ * A read hook result that supports React Suspense.
+ */
+type SuspenseResult<T> = {
+    data: T;
+};
+/**
+ * A read hook result that supports React Suspense and can be paused.
+ */
+type PausableSuspenseResult<T> = {
+    paused: true;
+    data: undefined;
+} | {
+    paused: false;
+    data: T;
+};
+
+type Selector<T, V> = (data: T) => V;
+type Pausable<T, WhenPaused = NullishDeep<T>> = Prettify<WhenPaused & {
+    /**
+     * Prevents the hook from automatically executing GraphQL query operations.
+     *
+     * @experimental This is an experimental feature and may change in the future.
+     *
+     * @remarks
+     * `pause` may be set to `true` to stop the query operation from executing
+     * automatically. The hook will stop receiving updates and won’t execute the query
+     * operation until it’s set to `false`.
+     */
+    pause: boolean;
+}>;
+type Suspendable = {
+    suspense: true;
+};
+
+type UseChainArgs = ChainRequest;
+/**
+ * Fetch a specific chain by chain ID.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useChain({
+ *   chainId: chainId(1),
+ *   suspense: true,
+ * });
+ * // data will be Chain | null
+ * ```
+ */
+declare function useChain(args: UseChainArgs & Suspendable): SuspenseResult<Chain | null>;
+/**
+ * Fetch a specific chain by chain ID.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useChain({
+ *   chainId: chainId(1),
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useChain(args: Pausable<UseChainArgs> & Suspendable): PausableSuspenseResult<Chain | null>;
+/**
+ * Fetch a specific chain by chain ID.
+ *
+ * ```tsx
+ * const { data, error, loading } = useChain({
+ *   chainId: chainId(1),
+ * });
+ * // data will be Chain | null
+ * ```
+ */
+declare function useChain(args: UseChainArgs): ReadResult<Chain | null>;
+/**
+ * Fetch a specific chain by chain ID.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useChain({
+ *   chainId: chainId(1),
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useChain(args: Pausable<UseChainArgs>): PausableReadResult<Chain | null>;
+type UseChainsArgs = {
+    filter: ChainsFilter;
+};
+/**
+ * Fetches the list of supported chains.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useChains({
+ *   filter: ChainsFilter.ALL,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useChains(args: UseChainsArgs & Suspendable): SuspenseResult<Chain[]>;
+/**
+ * Fetches the list of supported chains.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useChains({
+ *   filter: ChainsFilter.ALL,
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useChains(args: Pausable<UseChainsArgs> & Suspendable): PausableSuspenseResult<Chain[]>;
+/**
+ * Fetches the list of supported chains.
+ *
+ * ```tsx
+ * const { data, error, loading } = useChains({
+ *   filter: ChainsFilter.ALL,
+ * });
+ * ```
+ */
+declare function useChains(args?: UseChainsArgs): ReadResult<Chain[]>;
+/**
+ * Fetches the list of supported chains.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useChains({
+ *   filter: ChainsFilter.ALL,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useChains(args?: Pausable<UseChainsArgs>): PausableReadResult<Chain[]>;
+/**
+ * Fetches exchange rates between tokens and fiat currencies.
+ *
+ * ```tsx
+ * const [getExchangeRate, gettingRate] = useExchangeRateAction();
+ *
+ * const loading = gettingRate.loading;
+ * const error = gettingRate.error;
+ *
+ * // …
+ *
+ * const result = await getExchangeRate({
+ *   from: { erc20: { chainId: chainId(1), address: evmAddress('0xA0b86a33E6...') } },
+ *   to: Currency.Usd,
+ * });
+ *
+ * if (result.isErr()) {
+ *   console.error(result.error);
+ *   return;
+ * }
+ *
+ * console.log('Exchange rate:', result.value);
+ * ```
+ */
+declare function useExchangeRateAction(): UseAsyncTask<ExchangeRateRequest, FiatAmount, UnexpectedError$1>;
+type UseExchangeRateArgs = ExchangeRateRequest;
+/**
+ * Fetches exchange rates between tokens and fiat currencies with automatic polling.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useExchangeRate({
+ *   from: {
+ *     erc20: {
+ *       chainId: chainId(1),
+ *       address: evmAddress('0xA0b86a33E6...')
+ *     }
+ *   },
+ *   to: Currency.Usd,
+ *   suspense: true,
+ * });
+ * ```
+ */
+declare function useExchangeRate(args: UseExchangeRateArgs & Suspendable): SuspenseResult<FiatAmount>;
+/**
+ * Fetches exchange rates between tokens and fiat currencies with automatic polling.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data } = useExchangeRate({
+ *   from: {
+ *     erc20: {
+ *       chainId: chainId(1),
+ *       address: evmAddress('0xA0b86a33E6...')
+ *     }
+ *   },
+ *   to: Currency.Usd,
+ *   suspense: true,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useExchangeRate(args: Pausable<UseExchangeRateArgs> & Suspendable): PausableSuspenseResult<FiatAmount>;
+/**
+ * Fetches exchange rates between tokens and fiat currencies with automatic polling.
+ *
+ * ```tsx
+ * const { data, error, loading } = useExchangeRate({
+ *   from: {
+ *     erc20: {
+ *       chainId: chainId(1),
+ *       address: evmAddress('0xA0b86a33E6...')
+ *     }
+ *   },
+ *   to: Currency.Usd,
+ * });
+ *
+ * <Component value={somewhere} fxRate={data} />
+ * ```
+ */
+declare function useExchangeRate(args: UseExchangeRateArgs): ReadResult<FiatAmount>;
+/**
+ * Fetches exchange rates between tokens and fiat currencies with automatic polling.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useExchangeRate({
+ *   from: {
+ *     erc20: {
+ *       chainId: chainId(1),
+ *       address: evmAddress('0xA0b86a33E6...')
+ *     }
+ *   },
+ *   to: Currency.Usd,
+ *   pause: true,
+ * });
+ * ```
+ */
+declare function useExchangeRate(args: Pausable<UseExchangeRateArgs>): PausableReadResult<FiatAmount>;
+type UseNetworkFeeRequestQuery = {
+    activity: ActivityItem;
+} | {
+    estimate: PreviewAction;
+};
+type UseNetworkFeeArgs = Prettify<{
+    query: UseNetworkFeeRequestQuery;
+} & CurrencyQueryOptions>;
+type PausableUseNetworkFeeArgs = Partial<{
+    query: Partial<UseNetworkFeeRequestQuery>;
+} & CurrencyQueryOptions>;
+/**
+ * Fetch the network fee for an ActivityItem.
+ *
+ * @experimental This hook is experimental and may be subject to breaking changes.
+ */
+type UseNetworkFee<T extends NativeAmount = NativeAmount> = 
+/**
+ * Fetches the network fee for a past ActivityItem.
+ *
+ * This signature supports React Suspense:
+ *
+ * ```tsx
+ * const { data } = useNetworkFee({
+ *   query: { activity },
+ *   suspense: true,
+ * });
+ *
+ * data: NativeAmount
+ * ```
+ */
+((args: UseNetworkFeeArgs & Suspendable) => SuspenseResult<T>) & 
+/**
+ * Fetches the network fee for a past ActivityItem.
+ *
+ * Pausable suspense mode.
+ *
+ * ```tsx
+ * const { data, paused } = useNetworkFee({
+ *   query: { activity },
+ *   suspense: true,
+ *   pause: true,
+ * });
+ *
+ * data: NativeAmount | undefined
+ * ```
+ */
+((args: Pausable<UseNetworkFeeArgs, PausableUseNetworkFeeArgs> & Suspendable) => PausableSuspenseResult<T>) & 
+/**
+ * Fetches the network fee for a past ActivityItem.
+ *
+ * ```tsx
+ * const { data, error, loading } = useNetworkFee({
+ *   query: { activity },
+ * });
+ * ```
+ */
+((args: UseNetworkFeeArgs) => ReadResult<T>) & 
+/**
+ * Fetches the network fee for a past ActivityItem.
+ *
+ * Pausable loading state mode.
+ *
+ * ```tsx
+ * const { data, error, loading, paused } = useNetworkFee({
+ *   query: { activity },
+ *   pause: true,
+ * });
+ *
+ * data: NativeAmount | undefined
+ * ```
+ */
+((args: Pausable<UseNetworkFeeArgs, PausableUseNetworkFeeArgs>) => PausableReadResult<T>);
+
+export { type Pausable as P, ReadResult as R, type Suspendable as S, type UseNetworkFee as U, type SuspenseResult as a, type PausableSuspenseResult as b, type PausableReadResult as c, type Selector as d, type UseChainArgs as e, type UseChainsArgs as f, useChains as g, useExchangeRateAction as h, type UseExchangeRateArgs as i, useExchangeRate as j, type UseNetworkFeeRequestQuery as k, type UseNetworkFeeArgs as l, useChain as u };