wagmi 3.3.4 → 3.4.0

package/src/hooks/useReconnect.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type { Connector, ReconnectErrorType } from '@wagmi/core'
 import type { Compute } from '@wagmi/core/internal'
@@ -7,28 +6,16 @@ import {
   type ReconnectData,
   type ReconnectMutate,
   type ReconnectMutateAsync,
+  type ReconnectOptions,
   type ReconnectVariables,
   reconnectMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseReconnectParameters<context = unknown> = Compute<
-  ConfigParameter & {
-    mutation?:
-      | UseMutationParameters<
-          ReconnectData,
-          ReconnectErrorType,
-          ReconnectVariables,
-          context
-        >
-      | undefined
-  }
+  ConfigParameter & ReconnectOptions<context>
 >
 
 export type UseReconnectReturnType<context = unknown> = Compute<
@@ -36,11 +23,12 @@ export type UseReconnectReturnType<context = unknown> = Compute<
     ReconnectData,
     ReconnectErrorType,
     ReconnectVariables,
-    context
+    context,
+    ReconnectMutate<context>,
+    ReconnectMutateAsync<context>
   > & {
+    /** @deprecated use `useConnectors` instead */
     connectors: readonly Connector[]
-    mutate: ReconnectMutate<context>
-    mutateAsync: ReconnectMutateAsync<context>
     /** @deprecated use `mutate` instead */
     reconnect: ReconnectMutate<context>
     /** @deprecated use `mutateAsync` instead */
@@ -53,12 +41,13 @@ export function useReconnect<context = unknown>(
   parameters: UseReconnectParameters<context> = {},
 ): UseReconnectReturnType<context> {
   const config = useConfig(parameters)
-  const mutationOptions = reconnectMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = reconnectMutationOptions(config, parameters)
+  const mutation = useMutation(options)
+  type Return = UseReconnectReturnType<context>
   return {
-    ...mutation,
+    ...(mutation as Return),
     connectors: config.connectors,
-    reconnect: mutation.mutate,
-    reconnectAsync: mutation.mutateAsync,
+    reconnect: mutation.mutate as Return['mutate'],
+    reconnectAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/hooks/useSendCalls.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type { Config, ResolvedRegister, SendCallsErrorType } from '@wagmi/core'
 import type { Compute } from '@wagmi/core/internal'
@@ -7,32 +6,18 @@ import {
   type SendCallsData,
   type SendCallsMutate,
   type SendCallsMutateAsync,
+  type SendCallsOptions,
   type SendCallsVariables,
   sendCallsMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSendCallsParameters<
   config extends Config = Config,
   context = unknown,
-> = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          SendCallsData,
-          SendCallsErrorType,
-          SendCallsVariables<config, config['chains'][number]['id']>,
-          context
-        >
-      | undefined
-  }
->
+> = Compute<ConfigParameter<config> & SendCallsOptions<config, context>>
 
 export type UseSendCallsReturnType<
   config extends Config = Config,
@@ -42,10 +27,10 @@ export type UseSendCallsReturnType<
     SendCallsData,
     SendCallsErrorType,
     SendCallsVariables<config, config['chains'][number]['id']>,
-    context
+    context,
+    SendCallsMutate<config, context>,
+    SendCallsMutateAsync<config, context>
   > & {
-    mutate: SendCallsMutate<config, context>
-    mutateAsync: SendCallsMutateAsync<config, context>
     /** @deprecated use `mutate` instead */
     sendCalls: SendCallsMutate<config, context>
     /** @deprecated use `mutateAsync` instead */
@@ -61,13 +46,11 @@ export function useSendCalls<
   parameters: UseSendCallsParameters<config, context> = {},
 ): UseSendCallsReturnType<config, context> {
   const config = useConfig(parameters)
-  const mutationOptions = sendCallsMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = sendCallsMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseSendCallsReturnType<config, context>
   return {
-    ...mutation,
-    mutate: mutation.mutate as Return['mutate'],
-    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
+    ...(mutation as Return),
     sendCalls: mutation.mutate as Return['mutate'],
     sendCallsAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/hooks/useSendCallsSync.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type {
   Config,
@@ -11,32 +10,18 @@ import {
   type SendCallsSyncData,
   type SendCallsSyncMutate,
   type SendCallsSyncMutateAsync,
+  type SendCallsSyncOptions,
   type SendCallsSyncVariables,
   sendCallsSyncMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSendCallsSyncParameters<
   config extends Config = Config,
   context = unknown,
-> = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          SendCallsSyncData,
-          SendCallsSyncErrorType,
-          SendCallsSyncVariables<config, config['chains'][number]['id']>,
-          context
-        >
-      | undefined
-  }
->
+> = Compute<ConfigParameter<config> & SendCallsSyncOptions<config, context>>
 
 export type UseSendCallsSyncReturnType<
   config extends Config = Config,
@@ -46,10 +31,10 @@ export type UseSendCallsSyncReturnType<
     SendCallsSyncData,
     SendCallsSyncErrorType,
     SendCallsSyncVariables<config, config['chains'][number]['id']>,
-    context
+    context,
+    SendCallsSyncMutate<config, context>,
+    SendCallsSyncMutateAsync<config, context>
   > & {
-    mutate: SendCallsSyncMutate<config, context>
-    mutateAsync: SendCallsSyncMutateAsync<config, context>
     /** @deprecated use `mutate` instead */
     sendCallsSync: SendCallsSyncMutate<config, context>
     /** @deprecated use `mutateAsync` instead */
@@ -65,13 +50,11 @@ export function useSendCallsSync<
   parameters: UseSendCallsSyncParameters<config, context> = {},
 ): UseSendCallsSyncReturnType<config, context> {
   const config = useConfig(parameters)
-  const mutationOptions = sendCallsSyncMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = sendCallsSyncMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseSendCallsSyncReturnType<config, context>
   return {
-    ...mutation,
-    mutate: mutation.mutate as Return['mutate'],
-    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
+    ...(mutation as Return),
     sendCallsSync: mutation.mutate as Return['mutate'],
     sendCallsSyncAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/hooks/useSendTransaction.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type {
   Config,
@@ -11,32 +10,18 @@ import {
   type SendTransactionData,
   type SendTransactionMutate,
   type SendTransactionMutateAsync,
+  type SendTransactionOptions,
   type SendTransactionVariables,
   sendTransactionMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSendTransactionParameters<
   config extends Config = Config,
   context = unknown,
-> = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          SendTransactionData,
-          SendTransactionErrorType,
-          SendTransactionVariables<config, config['chains'][number]['id']>,
-          context
-        >
-      | undefined
-  }
->
+> = Compute<ConfigParameter<config> & SendTransactionOptions<config, context>>
 
 export type UseSendTransactionReturnType<
   config extends Config = Config,
@@ -46,10 +31,10 @@ export type UseSendTransactionReturnType<
     SendTransactionData,
     SendTransactionErrorType,
     SendTransactionVariables<config, config['chains'][number]['id']>,
-    context
+    context,
+    SendTransactionMutate<config, context>,
+    SendTransactionMutateAsync<config, context>
   > & {
-    mutate: SendTransactionMutate<config, context>
-    mutateAsync: SendTransactionMutateAsync<config, context>
     /** @deprecated use `mutate` instead */
     sendTransaction: SendTransactionMutate<config, context>
     /** @deprecated use `mutateAsync` instead */
@@ -65,11 +50,11 @@ export function useSendTransaction<
   parameters: UseSendTransactionParameters<config, context> = {},
 ): UseSendTransactionReturnType<config, context> {
   const config = useConfig(parameters)
-  const mutationOptions = sendTransactionMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = sendTransactionMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseSendTransactionReturnType<config, context>
   return {
-    ...mutation,
+    ...(mutation as Return),
     sendTransaction: mutation.mutate as Return['mutate'],
     sendTransactionAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/hooks/useSendTransactionSync.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type {
   Config,
@@ -11,31 +10,19 @@ import {
   type SendTransactionSyncData,
   type SendTransactionSyncMutate,
   type SendTransactionSyncMutateAsync,
+  type SendTransactionSyncOptions,
   type SendTransactionSyncVariables,
   sendTransactionSyncMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSendTransactionSyncParameters<
   config extends Config = Config,
   context = unknown,
 > = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          SendTransactionSyncData,
-          SendTransactionSyncErrorType,
-          SendTransactionSyncVariables<config, config['chains'][number]['id']>,
-          context
-        >
-      | undefined
-  }
+  ConfigParameter<config> & SendTransactionSyncOptions<config, context>
 >
 
 export type UseSendTransactionSyncReturnType<
@@ -46,10 +33,10 @@ export type UseSendTransactionSyncReturnType<
     SendTransactionSyncData,
     SendTransactionSyncErrorType,
     SendTransactionSyncVariables<config, config['chains'][number]['id']>,
-    context
+    context,
+    SendTransactionSyncMutate<config, context>,
+    SendTransactionSyncMutateAsync<config, context>
   > & {
-    mutate: SendTransactionSyncMutate<config, context>
-    mutateAsync: SendTransactionSyncMutateAsync<config, context>
     /** @deprecated use `mutate` instead */
     sendTransactionSync: SendTransactionSyncMutate<config, context>
     /** @deprecated use `mutateAsync` instead */
@@ -65,11 +52,11 @@ export function useSendTransactionSync<
   parameters: UseSendTransactionSyncParameters<config, context> = {},
 ): UseSendTransactionSyncReturnType<config, context> {
   const config = useConfig(parameters)
-  const mutationOptions = sendTransactionSyncMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = sendTransactionSyncMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseSendTransactionSyncReturnType<config, context>
   return {
-    ...mutation,
+    ...(mutation as Return),
     sendTransactionSync: mutation.mutate as Return['mutate'],
     sendTransactionSyncAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/hooks/useShowCallsStatus.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type {
   Config,
@@ -11,42 +10,28 @@ import {
   type ShowCallsStatusData,
   type ShowCallsStatusMutate,
   type ShowCallsStatusMutateAsync,
+  type ShowCallsStatusOptions,
   type ShowCallsStatusVariables,
   showCallsStatusMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseShowCallsStatusParameters<
   config extends Config = Config,
   context = unknown,
-> = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          ShowCallsStatusData,
-          ShowCallsStatusErrorType,
-          ShowCallsStatusVariables,
-          context
-        >
-      | undefined
-  }
->
+> = Compute<ConfigParameter<config> & ShowCallsStatusOptions<context>>
 
 export type UseShowCallsStatusReturnType<context = unknown> = Compute<
   UseMutationReturnType<
     ShowCallsStatusData,
     ShowCallsStatusErrorType,
     ShowCallsStatusVariables,
-    context
+    context,
+    ShowCallsStatusMutate,
+    ShowCallsStatusMutateAsync
   > & {
-    mutate: ShowCallsStatusMutate
-    mutateAsync: ShowCallsStatusMutateAsync
     /** @deprecated use `mutate` instead */
     showCallsStatus: ShowCallsStatusMutate
     /** @deprecated use `mutateAsync` instead */
@@ -62,11 +47,11 @@ export function useShowCallsStatus<
   parameters: UseShowCallsStatusParameters<config, context> = {},
 ): UseShowCallsStatusReturnType<context> {
   const config = useConfig(parameters)
-  const mutationOptions = showCallsStatusMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = showCallsStatusMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseShowCallsStatusReturnType<context>
   return {
-    ...mutation,
+    ...(mutation as Return),
     showCallsStatus: mutation.mutate as Return['mutate'],
     showCallsStatusAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/hooks/useSignMessage.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type { SignMessageErrorType } from '@wagmi/core'
 import type { Compute } from '@wagmi/core/internal'
@@ -7,28 +6,16 @@ import {
   type SignMessageData,
   type SignMessageMutate,
   type SignMessageMutateAsync,
+  type SignMessageOptions,
   type SignMessageVariables,
   signMessageMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSignMessageParameters<context = unknown> = Compute<
-  ConfigParameter & {
-    mutation?:
-      | UseMutationParameters<
-          SignMessageData,
-          SignMessageErrorType,
-          SignMessageVariables,
-          context
-        >
-      | undefined
-  }
+  ConfigParameter & SignMessageOptions<context>
 >
 
 export type UseSignMessageReturnType<context = unknown> = Compute<
@@ -36,10 +23,10 @@ export type UseSignMessageReturnType<context = unknown> = Compute<
     SignMessageData,
     SignMessageErrorType,
     SignMessageVariables,
-    context
+    context,
+    SignMessageMutate<context>,
+    SignMessageMutateAsync<context>
   > & {
-    mutate: SignMessageMutate<context>
-    mutateAsync: SignMessageMutateAsync<context>
     /** @deprecated use `mutate` instead */
     signMessage: SignMessageMutate<context>
     /** @deprecated use `mutateAsync` instead */
@@ -52,11 +39,12 @@ export function useSignMessage<context = unknown>(
   parameters: UseSignMessageParameters<context> = {},
 ): UseSignMessageReturnType<context> {
   const config = useConfig(parameters)
-  const mutationOptions = signMessageMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = signMessageMutationOptions(config, parameters)
+  const mutation = useMutation(options)
+  type Return = UseSignMessageReturnType<context>
   return {
-    ...mutation,
-    signMessage: mutation.mutate,
-    signMessageAsync: mutation.mutateAsync,
+    ...(mutation as Return),
+    signMessage: mutation.mutate as Return['mutate'],
+    signMessageAsync: mutation.mutateAsync as Return['mutateAsync'],
   }
 }

package/src/hooks/useSignTypedData.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type { SignTypedDataErrorType } from '@wagmi/core'
 import type { Compute } from '@wagmi/core/internal'
@@ -7,28 +6,16 @@ import {
   type SignTypedDataData,
   type SignTypedDataMutate,
   type SignTypedDataMutateAsync,
+  type SignTypedDataOptions,
   type SignTypedDataVariables,
   signTypedDataMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSignTypedDataParameters<context = unknown> = Compute<
-  ConfigParameter & {
-    mutation?:
-      | UseMutationParameters<
-          SignTypedDataData,
-          SignTypedDataErrorType,
-          SignTypedDataVariables,
-          context
-        >
-      | undefined
-  }
+  ConfigParameter & SignTypedDataOptions<context>
 >
 
 export type UseSignTypedDataReturnType<context = unknown> = Compute<
@@ -36,10 +23,10 @@ export type UseSignTypedDataReturnType<context = unknown> = Compute<
     SignTypedDataData,
     SignTypedDataErrorType,
     SignTypedDataVariables,
-    context
+    context,
+    SignTypedDataMutate<context>,
+    SignTypedDataMutateAsync<context>
   > & {
-    mutate: SignTypedDataMutate<context>
-    mutateAsync: SignTypedDataMutateAsync<context>
     /** @deprecated use `mutate` instead */
     signTypedData: SignTypedDataMutate<context>
     /** @deprecated use `mutateAsync` instead */
@@ -52,13 +39,11 @@ export function useSignTypedData<context = unknown>(
   parameters: UseSignTypedDataParameters<context> = {},
 ): UseSignTypedDataReturnType<context> {
   const config = useConfig(parameters)
-  const mutationOptions = signTypedDataMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = signTypedDataMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseSignTypedDataReturnType<context>
   return {
-    ...mutation,
-    mutate: mutation.mutate as Return['mutate'],
-    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
+    ...(mutation as Return),
     signTypedData: mutation.mutate as Return['mutate'],
     signTypedDataAsync: mutation.mutateAsync as Return['mutateAsync'],
   }

package/src/hooks/useSimulateContract.ts

@@ -93,7 +93,6 @@ export function useSimulateContract<
     account: parameters.account ?? address,
     chainId: parameters.chainId ?? chainId,
     connector: parameters.connector ?? connector,
-    query: parameters.query,
   })
   return useQuery(options) as any
 }

package/src/hooks/useStorageAt.ts

@@ -35,7 +35,6 @@ export function useStorageAt<
   const options = getStorageAtQueryOptions(config, {
     ...parameters,
     chainId: parameters.chainId ?? chainId,
-    query: parameters.query,
   })
   return useQuery(options)
 }

package/src/hooks/useSwitchChain.ts

@@ -1,5 +1,4 @@
 'use client'
-
 import { useMutation } from '@tanstack/react-query'
 import type {
   Config,
@@ -11,33 +10,19 @@ import {
   type SwitchChainData,
   type SwitchChainMutate,
   type SwitchChainMutateAsync,
+  type SwitchChainOptions,
   type SwitchChainVariables,
   switchChainMutationOptions,
 } from '@wagmi/core/query'
-
 import type { ConfigParameter } from '../types/properties.js'
-import type {
-  UseMutationParameters,
-  UseMutationReturnType,
-} from '../utils/query.js'
+import type { UseMutationReturnType } from '../utils/query.js'
 import { useChains } from './useChains.js'
 import { useConfig } from './useConfig.js'
 
 export type UseSwitchChainParameters<
   config extends Config = Config,
   context = unknown,
-> = Compute<
-  ConfigParameter<config> & {
-    mutation?:
-      | UseMutationParameters<
-          SwitchChainData<config, config['chains'][number]['id']>,
-          SwitchChainErrorType,
-          SwitchChainVariables<config, config['chains'][number]['id']>,
-          context
-        >
-      | undefined
-  }
->
+> = Compute<ConfigParameter<config> & SwitchChainOptions<config, context>>
 
 export type UseSwitchChainReturnType<
   config extends Config = Config,
@@ -47,12 +32,12 @@ export type UseSwitchChainReturnType<
     SwitchChainData<config, config['chains'][number]['id']>,
     SwitchChainErrorType,
     SwitchChainVariables<config, config['chains'][number]['id']>,
-    context
+    context,
+    SwitchChainMutate<config, context>,
+    SwitchChainMutateAsync<config, context>
   > & {
     /** @deprecated use `useChains` instead */
     chains: config['chains']
-    mutate: SwitchChainMutate<config, context>
-    mutateAsync: SwitchChainMutateAsync<config, context>
     /** @deprecated use `mutate` instead */
     switchChain: SwitchChainMutate<config, context>
     /** @deprecated use `mutateAsync` instead */
@@ -68,13 +53,11 @@ export function useSwitchChain<
   parameters: UseSwitchChainParameters<config, context> = {},
 ): UseSwitchChainReturnType<config, context> {
   const config = useConfig(parameters)
-  const mutationOptions = switchChainMutationOptions(config)
-  const mutation = useMutation({ ...parameters.mutation, ...mutationOptions })
+  const options = switchChainMutationOptions(config, parameters)
+  const mutation = useMutation(options)
   type Return = UseSwitchChainReturnType<config, context>
   return {
-    ...mutation,
-    mutate: mutation.mutate as Return['mutate'],
-    mutateAsync: mutation.mutateAsync as Return['mutateAsync'],
+    ...(mutation as Return),
     chains: useChains({ config }) as unknown as config['chains'],
     switchChain: mutation.mutate as Return['mutate'],
     switchChainAsync: mutation.mutateAsync as Return['mutateAsync'],