@wagmi/core 1.4.1 → 2.0.0-alpha.1

package/src/query/getConnectorClient.ts

@@ -0,0 +1,69 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetConnectorClientError,
+  type GetConnectorClientParameters,
+  type GetConnectorClientReturnType,
+  getConnectorClient,
+} from '../actions/getConnectorClient.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetConnectorClientOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<
+  ExactPartial<GetConnectorClientParameters<config, chainId>> &
+    ScopeKeyParameter
+>
+
+export function getConnectorClientQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(config: config, options: GetConnectorClientOptions<config, chainId> = {}) {
+  return {
+    gcTime: 0,
+    async queryFn({ queryKey }) {
+      const { connector } = options
+      const { connectorUid: _, scopeKey: _s, ...parameters } = queryKey[1]
+      return getConnectorClient(config, {
+        ...parameters,
+        connector,
+      }) as unknown as Promise<GetConnectorClientReturnType<config, chainId>>
+    },
+    queryKey: getConnectorClientQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetConnectorClientQueryFnData<config, chainId>,
+    GetConnectorClientError,
+    GetConnectorClientData<config, chainId>,
+    GetConnectorClientQueryKey<config, chainId>
+  >
+}
+
+export type GetConnectorClientQueryFnData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = GetConnectorClientReturnType<config, chainId>
+
+export type GetConnectorClientData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = GetConnectorClientQueryFnData<config, chainId>
+
+export function getConnectorClientQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(options: GetConnectorClientOptions<config, chainId> = {}) {
+  const { connector, ...parameters } = options
+  return [
+    'connectorClient',
+    { ...filterQueryOptions(parameters), connectorUid: connector?.uid },
+  ] as const
+}
+
+export type GetConnectorClientQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = ReturnType<typeof getConnectorClientQueryKey<config, chainId>>

package/src/query/getEnsAddress.ts

@@ -0,0 +1,49 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetEnsAddressError,
+  type GetEnsAddressParameters,
+  type GetEnsAddressReturnType,
+  getEnsAddress,
+} from '../actions/getEnsAddress.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetEnsAddressOptions<config extends Config> = Evaluate<
+  ExactPartial<GetEnsAddressParameters<config>> & ScopeKeyParameter
+>
+
+export function getEnsAddressQueryOptions<config extends Config>(
+  config: config,
+  options: GetEnsAddressOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getEnsAddress(config, { ...parameters, name })
+    },
+    queryKey: getEnsAddressQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetEnsAddressQueryFnData,
+    GetEnsAddressError,
+    GetEnsAddressData,
+    GetEnsAddressQueryKey<config>
+  >
+}
+
+export type GetEnsAddressQueryFnData = GetEnsAddressReturnType
+
+export type GetEnsAddressData = GetEnsAddressQueryFnData
+
+export function getEnsAddressQueryKey<config extends Config>(
+  options: GetEnsAddressOptions<config> = {},
+) {
+  return ['ensAddress', filterQueryOptions(options)] as const
+}
+
+export type GetEnsAddressQueryKey<config extends Config> = ReturnType<
+  typeof getEnsAddressQueryKey<config>
+>

package/src/query/getEnsAvatar.ts

@@ -0,0 +1,49 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetEnsAvatarError,
+  type GetEnsAvatarParameters,
+  type GetEnsAvatarReturnType,
+  getEnsAvatar,
+} from '../actions/getEnsAvatar.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetEnsAvatarOptions<config extends Config> = Evaluate<
+  ExactPartial<GetEnsAvatarParameters<config>> & ScopeKeyParameter
+>
+
+export function getEnsAvatarQueryOptions<config extends Config>(
+  config: config,
+  options: GetEnsAvatarOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getEnsAvatar(config, { ...parameters, name })
+    },
+    queryKey: getEnsAvatarQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetEnsAvatarQueryFnData,
+    GetEnsAvatarError,
+    GetEnsAvatarData,
+    GetEnsAvatarQueryKey<config>
+  >
+}
+
+export type GetEnsAvatarQueryFnData = GetEnsAvatarReturnType
+
+export type GetEnsAvatarData = GetEnsAvatarQueryFnData
+
+export function getEnsAvatarQueryKey<config extends Config>(
+  options: GetEnsAvatarOptions<config> = {},
+) {
+  return ['ensAvatar', filterQueryOptions(options)] as const
+}
+
+export type GetEnsAvatarQueryKey<config extends Config> = ReturnType<
+  typeof getEnsAvatarQueryKey<config>
+>

package/src/query/getEnsName.ts

@@ -0,0 +1,49 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetEnsNameError,
+  type GetEnsNameParameters,
+  type GetEnsNameReturnType,
+  getEnsName,
+} from '../actions/getEnsName.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetEnsNameOptions<config extends Config> = Evaluate<
+  ExactPartial<GetEnsNameParameters<config>> & ScopeKeyParameter
+>
+
+export function getEnsNameQueryOptions<config extends Config>(
+  config: config,
+  options: GetEnsNameOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { address, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      return getEnsName(config, { ...parameters, address })
+    },
+    queryKey: getEnsNameQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetEnsNameQueryFnData,
+    GetEnsNameError,
+    GetEnsNameData,
+    GetEnsNameQueryKey<config>
+  >
+}
+
+export type GetEnsNameQueryFnData = GetEnsNameReturnType
+
+export type GetEnsNameData = GetEnsNameQueryFnData
+
+export function getEnsNameQueryKey<config extends Config>(
+  options: GetEnsNameOptions<config> = {},
+) {
+  return ['ensName', filterQueryOptions(options)] as const
+}
+
+export type GetEnsNameQueryKey<config extends Config> = ReturnType<
+  typeof getEnsNameQueryKey<config>
+>

package/src/query/getEnsResolver.ts

@@ -0,0 +1,49 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetEnsResolverError,
+  type GetEnsResolverParameters,
+  type GetEnsResolverReturnType,
+  getEnsResolver,
+} from '../actions/getEnsResolver.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetEnsResolverOptions<config extends Config> = Evaluate<
+  ExactPartial<GetEnsResolverParameters<config>> & ScopeKeyParameter
+>
+
+export function getEnsResolverQueryOptions<config extends Config>(
+  config: config,
+  options: GetEnsResolverOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { name, scopeKey: _, ...parameters } = queryKey[1]
+      if (!name) throw new Error('name is required')
+      return getEnsResolver(config, { ...parameters, name })
+    },
+    queryKey: getEnsResolverQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetEnsResolverQueryFnData,
+    GetEnsResolverError,
+    GetEnsResolverData,
+    GetEnsResolverQueryKey<config>
+  >
+}
+
+export type GetEnsResolverQueryFnData = GetEnsResolverReturnType
+
+export type GetEnsResolverData = GetEnsResolverQueryFnData
+
+export function getEnsResolverQueryKey<config extends Config>(
+  options: GetEnsResolverOptions<config> = {},
+) {
+  return ['ensResolver', filterQueryOptions(options)] as const
+}
+
+export type GetEnsResolverQueryKey<config extends Config> = ReturnType<
+  typeof getEnsResolverQueryKey<config>
+>

package/src/query/getToken.ts

@@ -0,0 +1,49 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetTokenError,
+  type GetTokenParameters,
+  type GetTokenReturnType,
+  getToken,
+} from '../actions/getToken.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetTokenOptions<config extends Config> = Evaluate<
+  ExactPartial<GetTokenParameters<config>> & ScopeKeyParameter
+>
+
+export function getTokenQueryOptions<config extends Config>(
+  config: config,
+  options: GetTokenOptions<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const { address, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      return getToken(config, { ...parameters, address })
+    },
+    queryKey: getTokenQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetTokenQueryFnData,
+    GetTokenError,
+    GetTokenData,
+    GetTokenQueryKey<config>
+  >
+}
+
+export type GetTokenQueryFnData = GetTokenReturnType
+
+export type GetTokenData = GetTokenQueryFnData
+
+export function getTokenQueryKey<config extends Config>(
+  options: GetTokenOptions<config> = {},
+) {
+  return ['token', filterQueryOptions(options)] as const
+}
+
+export type GetTokenQueryKey<config extends Config> = ReturnType<
+  typeof getTokenQueryKey<config>
+>

package/src/query/getTransaction.ts

@@ -0,0 +1,75 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetTransactionError,
+  type GetTransactionParameters,
+  type GetTransactionReturnType,
+  getTransaction,
+} from '../actions/getTransaction.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetTransactionOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<
+  ExactPartial<GetTransactionParameters<config, chainId>> & ScopeKeyParameter
+>
+
+export function getTransactionQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(config: config, options: GetTransactionOptions<config, chainId> = {}) {
+  return {
+    async queryFn({ queryKey }) {
+      const {
+        blockHash,
+        blockNumber,
+        blockTag,
+        hash,
+        index,
+        scopeKey: _,
+      } = queryKey[1]
+      if (!blockHash && !blockNumber && !blockTag && !hash)
+        throw new Error('blockHash, blockNumber, blockTag, or hash is required')
+      if (!hash && !index)
+        throw new Error(
+          'index is required for blockHash, blockNumber, or blockTag',
+        )
+      return getTransaction(
+        config,
+        queryKey[1] as GetTransactionParameters,
+      ) as unknown as Promise<GetTransactionQueryFnData<config, chainId>>
+    },
+    queryKey: getTransactionQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetTransactionQueryFnData<config, chainId>,
+    GetTransactionError,
+    GetTransactionData<config, chainId>,
+    GetTransactionQueryKey<config, chainId>
+  >
+}
+
+export type GetTransactionQueryFnData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = GetTransactionReturnType<config, chainId>
+
+export type GetTransactionData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = GetTransactionQueryFnData<config, chainId>
+
+export function getTransactionQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(options: GetTransactionOptions<config, chainId> = {}) {
+  return ['transaction', filterQueryOptions(options)] as const
+}
+
+export type GetTransactionQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = ReturnType<typeof getTransactionQueryKey<config, chainId>>

package/src/query/getWalletClient.ts

@@ -0,0 +1,65 @@
+import { type QueryOptions } from '@tanstack/query-core'
+
+import {
+  type GetWalletClientError,
+  type GetWalletClientParameters,
+  type GetWalletClientReturnType,
+  getWalletClient,
+} from '../actions/getWalletClient.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate, ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type GetWalletClientOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = Evaluate<
+  ExactPartial<GetWalletClientParameters<config, chainId>> & ScopeKeyParameter
+>
+
+export function getWalletClientQueryOptions<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(config: config, options: GetWalletClientOptions<config, chainId> = {}) {
+  return {
+    gcTime: 0,
+    async queryFn({ queryKey }) {
+      const { connector } = options
+      const { connectorUid: _, scopeKey: _s, ...parameters } = queryKey[1]
+      return getWalletClient(config, { ...parameters, connector })
+    },
+    queryKey: getWalletClientQueryKey(options),
+  } as const satisfies QueryOptions<
+    GetWalletClientQueryFnData<config, chainId>,
+    GetWalletClientError,
+    GetWalletClientData<config, chainId>,
+    GetWalletClientQueryKey<config, chainId>
+  >
+}
+
+export type GetWalletClientQueryFnData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = GetWalletClientReturnType<config, chainId>
+
+export type GetWalletClientData<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = GetWalletClientQueryFnData<config, chainId>
+
+export function getWalletClientQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+>(options: GetWalletClientOptions<config, chainId> = {}) {
+  const { connector, ...parameters } = options
+  return [
+    'walletClient',
+    { ...filterQueryOptions(parameters), connectorUid: connector?.uid },
+  ] as const
+}
+
+export type GetWalletClientQueryKey<
+  config extends Config,
+  chainId extends config['chains'][number]['id'],
+> = ReturnType<typeof getWalletClientQueryKey<config, chainId>>

package/src/query/readContract.ts

@@ -0,0 +1,88 @@
+import { type QueryOptions } from '@tanstack/query-core'
+import {
+  type Abi,
+  type ContractFunctionArgs,
+  type ContractFunctionName,
+} from 'viem'
+
+import {
+  type ReadContractError,
+  type ReadContractParameters,
+  type ReadContractReturnType,
+  readContract,
+} from '../actions/readContract.js'
+import type { Config } from '../createConfig.js'
+import type { UnionPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type ReadContractOptions<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  config extends Config,
+> = UnionPartial<ReadContractParameters<abi, functionName, args, config>> &
+  ScopeKeyParameter
+
+export function readContractQueryOptions<
+  config extends Config,
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+>(
+  config: Config,
+  options: ReadContractOptions<abi, functionName, args, config> = {} as any,
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const abi = options.abi as Abi
+      if (!abi) throw new Error('abi is required')
+      const { address, functionName, scopeKey: _, ...parameters } = queryKey[1]
+      if (!address) throw new Error('address is required')
+      if (!functionName) throw new Error('functionName is required')
+      const args = parameters.args as readonly unknown[]
+      return (await readContract(config, {
+        abi,
+        address,
+        functionName,
+        args,
+        ...parameters,
+      })) as ReadContractData<abi, functionName, args>
+    },
+    queryKey: readContractQueryKey(options),
+  } as const satisfies QueryOptions<
+    ReadContractQueryFnData<abi, functionName, args>,
+    ReadContractError,
+    ReadContractData<abi, functionName, args>,
+    ReadContractQueryKey<config, abi, functionName, args>
+  >
+}
+
+export type ReadContractQueryFnData<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = ReadContractReturnType<abi, functionName, args>
+
+export type ReadContractData<
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = ReadContractQueryFnData<abi, functionName, args>
+
+export function readContractQueryKey<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+  config extends Config,
+>(options: ReadContractOptions<abi, functionName, args, config> = {} as any) {
+  const { abi: _, ...rest } = options
+  return ['readContract', filterQueryOptions(rest)] as const
+}
+
+export type ReadContractQueryKey<
+  config extends Config,
+  abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi, 'pure' | 'view'>,
+  args extends ContractFunctionArgs<abi, 'pure' | 'view', functionName>,
+> = ReturnType<typeof readContractQueryKey<abi, functionName, args, config>>

package/src/query/readContracts.ts

@@ -0,0 +1,98 @@
+import { type QueryOptions } from '@tanstack/query-core'
+import {
+  type ContractFunctionParameters,
+  type MulticallParameters as viem_MulticallParameters,
+} from 'viem'
+
+import {
+  type ReadContractsError,
+  type ReadContractsReturnType,
+  readContracts,
+} from '../actions/readContracts.js'
+import type { Config } from '../createConfig.js'
+import type { ChainIdParameter } from '../types/properties.js'
+import type { ExactPartial } from '../types/utils.js'
+import type { ScopeKeyParameter } from './types.js'
+import { filterQueryOptions } from './utils.js'
+
+export type ReadContractsOptions<
+  config extends Config,
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ExactPartial<
+  viem_MulticallParameters<
+    contracts,
+    allowFailure,
+    { optional: true; properties: ChainIdParameter<config> }
+  >
+> &
+  ScopeKeyParameter
+
+export function readContractsQueryOptions<
+  config extends Config,
+  const contracts extends readonly unknown[],
+  allowFailure extends boolean = true,
+>(
+  config: Config,
+  options: ReadContractsOptions<config, contracts, allowFailure> &
+    ChainIdParameter<config> = {},
+) {
+  return {
+    async queryFn({ queryKey }) {
+      const contracts: ContractFunctionParameters[] = []
+      const length = queryKey[1].contracts.length
+      for (let i = 0; i < length; i++) {
+        const contract = queryKey[1].contracts[i]!
+        const abi = (options.contracts?.[i] as ContractFunctionParameters).abi
+        contracts.push({ ...contract, abi })
+      }
+      const { scopeKey: _, ...parameters } = queryKey[1]
+      return (await readContracts(config, {
+        ...parameters,
+        contracts,
+      })) as ReadContractsData<contracts, allowFailure>
+    },
+    queryKey: readContractsQueryKey(options as any),
+  } as const satisfies QueryOptions<
+    ReadContractsQueryFnData<contracts, allowFailure>,
+    ReadContractsError,
+    ReadContractsData<contracts, allowFailure>,
+    ReadContractsQueryKey<config, contracts, allowFailure>
+  >
+}
+
+export type ReadContractsQueryFnData<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ReadContractsReturnType<contracts, allowFailure>
+
+export type ReadContractsData<
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ReadContractsQueryFnData<contracts, allowFailure>
+
+export function readContractsQueryKey<
+  config extends Config,
+  const contracts extends readonly unknown[],
+  allowFailure extends boolean,
+>(
+  options: ReadContractsOptions<config, contracts, allowFailure> &
+    ChainIdParameter<config> = {},
+) {
+  const contracts = []
+  for (const contract of (options.contracts ??
+    []) as ContractFunctionParameters[]) {
+    const { abi: _, ...rest } = contract
+    contracts.push({ ...rest, chainId: options.chainId })
+  }
+  return [
+    'readContracts',
+    filterQueryOptions({ ...options, contracts }),
+  ] as const
+}
+
+export type ReadContractsQueryKey<
+  config extends Config,
+  contracts extends readonly unknown[],
+  allowFailure extends boolean,
+> = ReturnType<typeof readContractsQueryKey<config, contracts, allowFailure>>

package/src/query/reconnect.ts

@@ -0,0 +1,42 @@
+import type { MutationOptions } from '@tanstack/query-core'
+
+import {
+  type ReconnectError,
+  type ReconnectParameters,
+  type ReconnectReturnType,
+  reconnect,
+} from '../actions/reconnect.js'
+import type { Config } from '../createConfig.js'
+import type { Evaluate } from '../types/utils.js'
+import type { Mutate, MutateAsync } from './types.js'
+
+export function reconnectMutationOptions(config: Config) {
+  return {
+    mutationFn(variables) {
+      return reconnect(config, variables)
+    },
+    mutationKey: ['reconnect'],
+  } as const satisfies MutationOptions<
+    ReconnectData,
+    ReconnectError,
+    ReconnectVariables
+  >
+}
+
+export type ReconnectData = Evaluate<ReconnectReturnType>
+
+export type ReconnectVariables = ReconnectParameters | undefined
+
+export type ReconnectMutate<context = unknown> = Mutate<
+  ReconnectData,
+  ReconnectError,
+  ReconnectVariables,
+  context
+>
+
+export type ReconnectMutateAsync<context = unknown> = MutateAsync<
+  ReconnectData,
+  ReconnectError,
+  ReconnectVariables,
+  context
+>