fix(types): Fix type errors when using fully-typed inputs like QueryFilters<Data, Error>, and test all QueryClient methods to detect similar issues (#8375)

* Add test with failing types

* Tidy up

* Move tests to correct file

* Add initial fixes (some review and testing needed)

* Formatting

* Ensure T params are mandatory for new overloads

* Fix type issues

* Unnecessary DataTag

* Add typeless tests

* Fix some cases

* Fixing more cases

* Fix some typings

* Fix remaining issues

* Fix linting errors

* Fix one warning

* Revert unnecessary change to getQueryDefaults

* Remove mutation defaults todo

* Rename var

* Remove all additional overloads in favour of a single definition which supports all cases

* Change type tests to more idomatic api

Author: Nick-Lucas

packages/query-core/src/__tests__/queryClient.test-d.tsx

@@ -1,7 +1,20 @@
 import { describe, expectTypeOf, it } from 'vitest'
 import { QueryClient } from '../queryClient'
-import type { QueryState } from '../query'
-import type { DataTag, InfiniteData, QueryKey } from '../types'
+import type { MutationFilters, QueryFilters, Updater } from '../utils'
+import type { Mutation } from '../mutation'
+import type { Query, QueryState } from '../query'
+import type {
+  DataTag,
+  DefaultError,
+  DefaultedQueryObserverOptions,
+  EnsureQueryDataOptions,
+  FetchInfiniteQueryOptions,
+  InfiniteData,
+  MutationOptions,
+  OmitKeyof,
+  QueryKey,
+  QueryObserverOptions,
+} from '../types'
 
 describe('getQueryData', () => {
   it('should be typed if key is tagged', () => {
@@ -184,3 +197,307 @@ describe('defaultOptions', () => {
     })
   })
 })
+
+describe('fully typed usage', () => {
+  it('type-checks various methods with data & error included in the type', async () => {
+    const queryClient = new QueryClient()
+
+    type TData = { foo: string }
+    type TError = DefaultError & { bar: string }
+
+    //
+    // Construct typed arguments
+    //
+
+    const queryOptions: EnsureQueryDataOptions<TData, TError> = {
+      queryKey: ['key'] as any,
+    }
+    const fetchInfiniteQueryOptions: FetchInfiniteQueryOptions<TData, TError> =
+      {
+        queryKey: ['key'] as any,
+        pages: 5,
+        getNextPageParam: (lastPage) => {
+          expectTypeOf(lastPage).toEqualTypeOf<TData>()
+          return 0
+        },
+        initialPageParam: 0,
+      }
+    const mutationOptions: MutationOptions<TData, TError> = {}
+
+    const queryFilters: QueryFilters<
+      TData,
+      TError,
+      TData,
+      QueryKey & DataTag<unknown, TData, TError>
+    > = {
+      predicate(query) {
+        expectTypeOf(query).toEqualTypeOf<
+          Query<
+            TData,
+            TError,
+            TData,
+            QueryKey & DataTag<unknown, TData, TError>
+          >
+        >()
+        expectTypeOf(query.state.data).toEqualTypeOf<TData | undefined>()
+        expectTypeOf(query.state.error).toEqualTypeOf<TError | null>()
+        return false
+      },
+    }
+    const queryKey = queryFilters.queryKey!
+
+    const mutationFilters: MutationFilters<TData, TError> = {
+      predicate(mutation) {
+        expectTypeOf(mutation).toEqualTypeOf<Mutation<TData, TError>>()
+        expectTypeOf(mutation.state.data).toEqualTypeOf<TData | undefined>()
+        expectTypeOf(mutation.state.error).toEqualTypeOf<TError | null>()
+        return false
+      },
+    }
+    const mutationKey = mutationOptions.mutationKey!
+
+    //
+    // Method type tests
+    //
+
+    const state = queryClient.getQueryState(queryKey)
+    expectTypeOf(state).toEqualTypeOf<QueryState<TData, TError> | undefined>()
+
+    const queryData1 = queryClient.getQueryData(queryKey)
+    expectTypeOf(queryData1).toEqualTypeOf<TData | undefined>()
+
+    const queryData2 = await queryClient.ensureQueryData(queryOptions)
+    expectTypeOf(queryData2).toEqualTypeOf<TData>()
+
+    const queriesData = queryClient.getQueriesData(queryFilters)
+    expectTypeOf(queriesData).toEqualTypeOf<
+      Array<[QueryKey, TData | undefined]>
+    >()
+
+    const queryData3 = queryClient.setQueryData(queryKey, { foo: '' })
+    type SetQueryDataUpdaterArg = Parameters<
+      typeof queryClient.setQueryData<unknown, typeof queryKey>
+    >[1]
+
+    expectTypeOf<SetQueryDataUpdaterArg>().toEqualTypeOf<
+      Updater<TData | undefined, TData | undefined>
+    >()
+    expectTypeOf(queryData3).toEqualTypeOf<TData | undefined>()
+
+    const queriesData2 = queryClient.setQueriesData(queryFilters, { foo: '' }) // TODO: types here are wrong and coming up undefined
+    type SetQueriesDataUpdaterArg = Parameters<
+      typeof queryClient.setQueriesData<unknown, typeof queryFilters>
+    >[1]
+
+    expectTypeOf<SetQueriesDataUpdaterArg>().toEqualTypeOf<
+      Updater<TData | undefined, TData | undefined>
+    >()
+    expectTypeOf(queriesData2).toEqualTypeOf<
+      Array<[QueryKey, TData | undefined]>
+    >()
+
+    const queryState = queryClient.getQueryState(queryKey)
+    expectTypeOf(queryState).toEqualTypeOf<
+      QueryState<TData, TError> | undefined
+    >()
+
+    const fetchedQuery = await queryClient.fetchQuery(queryOptions)
+    expectTypeOf(fetchedQuery).toEqualTypeOf<TData>()
+
+    queryClient.prefetchQuery(queryOptions)
+
+    const infiniteQuery = await queryClient.fetchInfiniteQuery(
+      fetchInfiniteQueryOptions,
+    )
+    expectTypeOf(infiniteQuery).toEqualTypeOf<InfiniteData<TData, unknown>>()
+
+    const infiniteQueryData = await queryClient.ensureInfiniteQueryData(
+      fetchInfiniteQueryOptions,
+    )
+    expectTypeOf(infiniteQueryData).toEqualTypeOf<
+      InfiniteData<TData, unknown>
+    >()
+
+    const defaultQueryOptions = queryClient.defaultQueryOptions(queryOptions)
+    expectTypeOf(defaultQueryOptions).toEqualTypeOf<
+      DefaultedQueryObserverOptions<TData, TError, TData, TData, QueryKey>
+    >()
+
+    const mutationOptions2 = queryClient.defaultMutationOptions(mutationOptions)
+    expectTypeOf(mutationOptions2).toEqualTypeOf<
+      MutationOptions<TData, TError, void, unknown>
+    >()
+
+    queryClient.setMutationDefaults(mutationKey, {
+      onSettled(data, error, variables, context) {
+        expectTypeOf(data).toEqualTypeOf<unknown>()
+        expectTypeOf(error).toEqualTypeOf<DefaultError | null>()
+        expectTypeOf(variables).toEqualTypeOf<void>()
+        expectTypeOf(context).toEqualTypeOf<unknown>()
+      },
+    })
+
+    const queryDefaults = queryClient.getQueryDefaults(queryKey)
+    expectTypeOf(queryDefaults).toEqualTypeOf<
+      OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'>
+    >()
+
+    // Voids and Untyped returns
+    queryClient.invalidateQueries(queryFilters)
+    queryClient.isFetching(queryFilters)
+    queryClient.isMutating(mutationFilters)
+    queryClient.removeQueries(queryFilters)
+    queryClient.resetQueries(queryFilters)
+    queryClient.cancelQueries(queryFilters)
+    queryClient.invalidateQueries(queryFilters)
+    queryClient.refetchQueries(queryFilters)
+    queryClient.prefetchInfiniteQuery(fetchInfiniteQueryOptions)
+    queryClient.setQueryDefaults(queryKey, {} as any)
+    queryClient.getMutationDefaults(mutationKey)
+  })
+
+  it('type-checks various methods with untyped arguments', async () => {
+    const queryClient = new QueryClient()
+
+    //
+    // Construct typed arguments
+    //
+
+    const queryOptions: EnsureQueryDataOptions = {
+      queryKey: ['key'] as any,
+    }
+    const fetchInfiniteQueryOptions: FetchInfiniteQueryOptions = {
+      queryKey: ['key'] as any,
+      pages: 5,
+      getNextPageParam: (lastPage) => {
+        expectTypeOf(lastPage).toEqualTypeOf<unknown>()
+        return 0
+      },
+      initialPageParam: 0,
+    }
+    const mutationOptions: MutationOptions = {}
+
+    const queryFilters: QueryFilters = {
+      predicate(query) {
+        expectTypeOf(query).toEqualTypeOf<Query<unknown, DefaultError>>()
+        expectTypeOf(query.state.data).toEqualTypeOf<unknown>()
+        expectTypeOf(query.state.error).toEqualTypeOf<DefaultError | null>()
+        return false
+      },
+    }
+    const queryKey = queryFilters.queryKey!
+
+    const mutationFilters: MutationFilters = {
+      predicate(mutation) {
+        expectTypeOf(mutation).toEqualTypeOf<Mutation>()
+        expectTypeOf(mutation.state.data).toEqualTypeOf<unknown>()
+        expectTypeOf(mutation.state.error).toEqualTypeOf<DefaultError | null>()
+        return false
+      },
+    }
+    const mutationKey = mutationOptions.mutationKey!
+
+    //
+    // Method type tests
+    //
+
+    const state = queryClient.getQueryState(queryKey)
+    expectTypeOf(state).toEqualTypeOf<
+      QueryState<unknown, DefaultError> | undefined
+    >()
+
+    const queryData1 = queryClient.getQueryData(queryKey)
+    expectTypeOf(queryData1).toEqualTypeOf<unknown>()
+
+    const queryData2 = await queryClient.ensureQueryData(queryOptions)
+    expectTypeOf(queryData2).toEqualTypeOf<unknown>()
+
+    const queriesData = queryClient.getQueriesData(queryFilters)
+    expectTypeOf(queriesData).toEqualTypeOf<Array<[QueryKey, unknown]>>()
+
+    const queryData3 = queryClient.setQueryData(queryKey, { foo: '' })
+    type SetQueryDataUpdaterArg = Parameters<
+      typeof queryClient.setQueryData<unknown, typeof queryKey>
+    >[1]
+
+    expectTypeOf<SetQueryDataUpdaterArg>().toEqualTypeOf<
+      Updater<unknown, unknown>
+    >()
+    expectTypeOf(queryData3).toEqualTypeOf<unknown>()
+
+    const queriesData2 = queryClient.setQueriesData(queryFilters, { foo: '' }) // TODO: types here are wrong and coming up undefined
+    type SetQueriesDataUpdaterArg = Parameters<
+      typeof queryClient.setQueriesData<unknown, typeof queryFilters>
+    >[1]
+
+    expectTypeOf<SetQueriesDataUpdaterArg>().toEqualTypeOf<
+      Updater<unknown, unknown>
+    >()
+    expectTypeOf(queriesData2).toEqualTypeOf<Array<[QueryKey, unknown]>>()
+
+    const queryState = queryClient.getQueryState(queryKey)
+    expectTypeOf(queryState).toEqualTypeOf<
+      QueryState<unknown, DefaultError> | undefined
+    >()
+
+    const fetchedQuery = await queryClient.fetchQuery(queryOptions)
+    expectTypeOf(fetchedQuery).toEqualTypeOf<unknown>()
+
+    queryClient.prefetchQuery(queryOptions)
+
+    const infiniteQuery = await queryClient.fetchInfiniteQuery(
+      fetchInfiniteQueryOptions,
+    )
+    expectTypeOf(infiniteQuery).toEqualTypeOf<InfiniteData<unknown, unknown>>()
+
+    const infiniteQueryData = await queryClient.ensureInfiniteQueryData(
+      fetchInfiniteQueryOptions,
+    )
+    expectTypeOf(infiniteQueryData).toEqualTypeOf<
+      InfiniteData<unknown, unknown>
+    >()
+
+    const defaultQueryOptions = queryClient.defaultQueryOptions(queryOptions)
+    expectTypeOf(defaultQueryOptions).toEqualTypeOf<
+      DefaultedQueryObserverOptions<
+        unknown,
+        DefaultError,
+        unknown,
+        unknown,
+        QueryKey
+      >
+    >()
+
+    const mutationOptions2 = queryClient.defaultMutationOptions(mutationOptions)
+    expectTypeOf(mutationOptions2).toEqualTypeOf<
+      MutationOptions<unknown, DefaultError, void, unknown>
+    >()
+
+    queryClient.setMutationDefaults(mutationKey, {
+      onSettled(data, error, variables, context) {
+        expectTypeOf(data).toEqualTypeOf<unknown>()
+        expectTypeOf(error).toEqualTypeOf<DefaultError | null>()
+        expectTypeOf(variables).toEqualTypeOf<void>()
+        expectTypeOf(context).toEqualTypeOf<unknown>()
+      },
+    })
+
+    const queryDefaults = queryClient.getQueryDefaults(queryKey)
+    expectTypeOf(queryDefaults).toEqualTypeOf<
+      OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'>
+    >()
+
+    // Voids and Untyped returns
+    queryClient.invalidateQueries(queryFilters)
+    queryClient.isFetching(queryFilters)
+    queryClient.isMutating(mutationFilters)
+    queryClient.removeQueries(queryFilters)
+    queryClient.resetQueries(queryFilters)
+    queryClient.cancelQueries(queryFilters)
+    queryClient.invalidateQueries(queryFilters)
+    queryClient.refetchQueries(queryFilters)
+    queryClient.prefetchInfiniteQuery(fetchInfiniteQueryOptions)
+    queryClient.setQueryDefaults(queryKey, {} as any)
+    queryClient.getMutationDefaults(mutationKey)
+  })
+})

packages/query-core/src/__tests__/utils.test-d.tsx

@@ -1,13 +1,18 @@
 import { describe, expectTypeOf, it } from 'vitest'
 import { QueryClient } from '../queryClient'
 import type { QueryFilters } from '../utils'
-import type { DataTag } from '../types'
+import type { DataTag, QueryKey } from '../types'
 
 describe('QueryFilters', () => {
   it('should be typed if generics are passed', () => {
     type TData = { a: number; b: string }
 
-    const a: QueryFilters<TData> = {
+    const filters: QueryFilters<
+      TData,
+      Error,
+      TData,
+      QueryKey & DataTag<unknown, TData>
+    > = {
       predicate(query) {
         expectTypeOf(query.setData({ a: 1, b: '1' })).toEqualTypeOf<TData>()
         return true
@@ -17,18 +22,23 @@ describe('QueryFilters', () => {
 
     const queryClient = new QueryClient()
 
-    const data = queryClient.getQueryData(a.queryKey!)
+    const data = queryClient.getQueryData(filters.queryKey!)
     expectTypeOf(data).toEqualTypeOf<TData | undefined>()
 
-    const error = queryClient.getQueryState(a.queryKey!)?.error
+    const error = queryClient.getQueryState(filters.queryKey!)?.error
     expectTypeOf(error).toEqualTypeOf<Error | null | undefined>()
   })
 
   it('should be typed if generics are passed including an error type', () => {
     type TData = { a: number; b: string }
     type TError = Error & { message: string }
 
-    const a: QueryFilters<TData, TError> = {
+    const filters: QueryFilters<
+      TData,
+      TError,
+      TData,
+      QueryKey & DataTag<unknown, TData, TError>
+    > = {
       predicate(query) {
         expectTypeOf(query.setData({ a: 1, b: '1' })).toEqualTypeOf<TData>()
         return true
@@ -38,10 +48,10 @@ describe('QueryFilters', () => {
 
     const queryClient = new QueryClient()
 
-    const data = queryClient.getQueryData(a.queryKey!)
+    const data = queryClient.getQueryData(filters.queryKey!)
     expectTypeOf(data).toEqualTypeOf<TData | undefined>()
 
-    const error = queryClient.getQueryState(a.queryKey!)?.error
+    const error = queryClient.getQueryState(filters.queryKey!)?.error
     expectTypeOf(error).toEqualTypeOf<TError | null | undefined>()
   })
 

packages/query-core/src/queryClient.ts

@@ -106,12 +106,16 @@ export class QueryClient {
     this.#unsubscribeOnline = undefined
   }
 
-  isFetching(filters?: QueryFilters): number {
+  isFetching<
+    TQueryFilters extends QueryFilters<any, any, any, any> = QueryFilters,
+  >(filters?: TQueryFilters): number {
     return this.#queryCache.findAll({ ...filters, fetchStatus: 'fetching' })
       .length
   }
 
-  isMutating(filters?: MutationFilters): number {
+  isMutating<
+    TMutationFilters extends MutationFilters<any, any> = MutationFilters,
+  >(filters?: TMutationFilters): number {
     return this.#mutationCache.findAll({ ...filters, status: 'pending' }).length
   }
 
@@ -125,10 +129,12 @@ export class QueryClient {
     >
       ? TaggedValue
       : TQueryFnData,
-  >(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined
-  getQueryData(queryKey: QueryKey) {
+  >(queryKey: TTaggedQueryKey): TInferredQueryFnData | undefined {
     const options = this.defaultQueryOptions({ queryKey })
-    return this.#queryCache.get(options.queryHash)?.state.data
+
+    return this.#queryCache.get(options.queryHash)?.state.data as
+      | TInferredQueryFnData
+      | undefined
   }
 
   ensureQueryData<
@@ -141,8 +147,9 @@ export class QueryClient {
   ): Promise<TData> {
     const cachedData = this.getQueryData<TData>(options.queryKey)
 
-    if (cachedData === undefined) return this.fetchQuery(options)
-    else {
+    if (cachedData === undefined) {
+      return this.fetchQuery(options)
+    } else {
       const defaultedOptions = this.defaultQueryOptions(options)
       const query = this.#queryCache.build(this, defaultedOptions)
 
@@ -157,11 +164,27 @@ export class QueryClient {
     }
   }
 
-  getQueriesData<TQueryFnData = unknown>(
-    filters: QueryFilters,
-  ): Array<[QueryKey, TQueryFnData | undefined]> {
+  getQueriesData<
+    TQueryFnData = unknown,
+    TQueryFilters extends QueryFilters<
+      any,
+      any,
+      any,
+      any
+    > = QueryFilters<TQueryFnData>,
+    TInferredQueryFnData = TQueryFilters extends QueryFilters<
+      infer TData,
+      any,
+      any,
+      any
+    >
+      ? TData
+      : TQueryFnData,
+  >(
+    filters: TQueryFilters,
+  ): Array<[QueryKey, TInferredQueryFnData | undefined]> {
     return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {
-      const data = state.data as TQueryFnData | undefined
+      const data = state.data as TInferredQueryFnData | undefined
       return [queryKey, data]
     })
   }
@@ -207,17 +230,36 @@ export class QueryClient {
       .setData(data, { ...options, manual: true })
   }
 
-  setQueriesData<TQueryFnData>(
-    filters: QueryFilters,
-    updater: Updater<TQueryFnData | undefined, TQueryFnData | undefined>,
+  setQueriesData<
+    TQueryFnData,
+    TQueryFilters extends QueryFilters<
+      any,
+      any,
+      any,
+      any
+    > = QueryFilters<TQueryFnData>,
+    TInferredQueryFnData = TQueryFilters extends QueryFilters<
+      infer TData,
+      any,
+      any,
+      any
+    >
+      ? TData
+      : TQueryFnData,
+  >(
+    filters: TQueryFilters,
+    updater: Updater<
+      NoInfer<TInferredQueryFnData> | undefined,
+      NoInfer<TInferredQueryFnData> | undefined
+    >,
     options?: SetDataOptions,
-  ): Array<[QueryKey, TQueryFnData | undefined]> {
+  ): Array<[QueryKey, TInferredQueryFnData | undefined]> {
     return notifyManager.batch(() =>
       this.#queryCache
         .findAll(filters)
         .map(({ queryKey }) => [
           queryKey,
-          this.setQueryData<TQueryFnData>(queryKey, updater, options),
+          this.setQueryData<TInferredQueryFnData>(queryKey, updater, options),
         ]),
     )
   }
@@ -251,7 +293,9 @@ export class QueryClient {
     )?.state
   }
 
-  removeQueries(filters?: QueryFilters): void {
+  removeQueries<
+    TQueryFilters extends QueryFilters<any, any, any, any> = QueryFilters,
+  >(filters?: TQueryFilters): void {
     const queryCache = this.#queryCache
     notifyManager.batch(() => {
       queryCache.findAll(filters).forEach((query) => {
@@ -260,7 +304,9 @@ export class QueryClient {
     })
   }
 
-  resetQueries(filters?: QueryFilters, options?: ResetOptions): Promise<void> {
+  resetQueries<
+    TQueryFilters extends QueryFilters<any, any, any, any> = QueryFilters,
+  >(filters?: TQueryFilters, options?: ResetOptions): Promise<void> {
     const queryCache = this.#queryCache
 
     const refetchFilters: RefetchQueryFilters = {
@@ -276,10 +322,9 @@ export class QueryClient {
     })
   }
 
-  cancelQueries(
-    filters: QueryFilters = {},
-    cancelOptions: CancelOptions = {},
-  ): Promise<void> {
+  cancelQueries<
+    TQueryFilters extends QueryFilters<any, any, any, any> = QueryFilters,
+  >(filters?: TQueryFilters, cancelOptions: CancelOptions = {}): Promise<void> {
     const defaultedCancelOptions = { revert: true, ...cancelOptions }
 
     const promises = notifyManager.batch(() =>
@@ -291,33 +336,47 @@ export class QueryClient {
     return Promise.all(promises).then(noop).catch(noop)
   }
 
-  invalidateQueries(
-    filters: InvalidateQueryFilters = {},
+  invalidateQueries<
+    TInvalidateQueryFilters extends InvalidateQueryFilters<
+      any,
+      any,
+      any,
+      any
+    > = InvalidateQueryFilters,
+  >(
+    filters?: TInvalidateQueryFilters,
     options: InvalidateOptions = {},
   ): Promise<void> {
     return notifyManager.batch(() => {
       this.#queryCache.findAll(filters).forEach((query) => {
         query.invalidate()
       })
 
-      if (filters.refetchType === 'none') {
+      if (filters?.refetchType === 'none') {
         return Promise.resolve()
       }
       const refetchFilters: RefetchQueryFilters = {
         ...filters,
-        type: filters.refetchType ?? filters.type ?? 'active',
+        type: filters?.refetchType ?? filters?.type ?? 'active',
       }
       return this.refetchQueries(refetchFilters, options)
     })
   }
 
-  refetchQueries(
-    filters: RefetchQueryFilters = {},
-    options?: RefetchOptions,
+  refetchQueries<
+    TRefetchQueryFilters extends RefetchQueryFilters<
+      any,
+      any,
+      any,
+      any
+    > = RefetchQueryFilters,
+  >(
+    filters?: TRefetchQueryFilters,
+    options: RefetchOptions = {},
   ): Promise<void> {
     const fetchOptions = {
       ...options,
-      cancelRefetch: options?.cancelRefetch ?? true,
+      cancelRefetch: options.cancelRefetch ?? true,
     }
     const promises = notifyManager.batch(() =>
       this.#queryCache
@@ -494,14 +553,14 @@ export class QueryClient {
   ): OmitKeyof<QueryObserverOptions<any, any, any, any, any>, 'queryKey'> {
     const defaults = [...this.#queryDefaults.values()]
 
-    let result: OmitKeyof<
+    const result: OmitKeyof<
       QueryObserverOptions<any, any, any, any, any>,
       'queryKey'
     > = {}
 
     defaults.forEach((queryDefault) => {
       if (partialMatchKey(queryKey, queryDefault.queryKey)) {
-        result = { ...result, ...queryDefault.defaultOptions }
+        Object.assign(result, queryDefault.defaultOptions)
       }
     })
     return result

packages/query-core/src/utils.ts

@@ -1,5 +1,4 @@
 import type {
-  DataTag,
   DefaultError,
   Enabled,
   FetchStatus,
@@ -36,9 +35,7 @@ export interface QueryFilters<
   /**
    * Include queries matching this query key
    */
-  queryKey?: unknown extends TQueryFnData
-    ? QueryKey
-    : QueryKey & DataTag<unknown, TQueryFnData, TError>
+  queryKey?: TQueryKey
   /**
    * Include or exclude stale queries
    */
@@ -49,15 +46,22 @@ export interface QueryFilters<
   fetchStatus?: FetchStatus
 }
 
-export interface MutationFilters {
+export interface MutationFilters<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = unknown,
+  TContext = unknown,
+> {
   /**
    * Match mutation key exactly
    */
   exact?: boolean
   /**
    * Include mutations matching this predicate function
    */
-  predicate?: (mutation: Mutation<any, any, any>) => boolean
+  predicate?: (
+    mutation: Mutation<TData, TError, TVariables, TContext>,
+  ) => boolean
   /**
    * Include mutations matching this mutation key
    */