@tanstack/react-query 5.0.0-alpha.3 → 5.0.0-alpha.31

package/build/codemods/v4/__testfixtures__/replace-import-specifier.output.tsx

@@ -0,0 +1,10 @@
+// React Query
+import { useQuery, useQueryClient } from '@tanstack/react-query'
+import { useQuery as RenamedUseQuery, useQueryClient as RenamedUseQueryClient } from '@tanstack/react-query'
+import DefaultReactQuery from '@tanstack/react-query'
+import * as NamespacedReactQuery from '@tanstack/react-query'
+// Devtools
+import { ReactQueryDevtools } from '@tanstack/react-query-devtools'
+import { ReactQueryDevtools as RenamedReactQueryDevtools } from '@tanstack/react-query-devtools'
+import DefaultReactQueryDevtools from '@tanstack/react-query-devtools'
+import * as NamespacedReactQueryDevtools from '@tanstack/react-query-devtools'

package/build/codemods/v4/__testfixtures__/type-arguments.input.tsx

@@ -0,0 +1,25 @@
+import * as React from 'react'
+import { useQueries, useQuery, useQueryClient } from 'react-query'
+
+type Todos = {
+  items: readonly {
+    id: string
+    text: string
+  }[]
+  ts: number
+}
+
+export const Examples = () => {
+  useQuery<Todos>('todos')
+  useQueries<Array<Todos>>([query1, query2])
+  // QueryClient methods
+  // --- Instantiated hook call.
+  const queryClient = useQueryClient()
+  queryClient.getQueriesData<Todos>('todos')
+  queryClient.getQueriesData<Todos>({ queryKey: 'todos' })
+  // --- Direct hook call.
+  useQueryClient().getQueriesData<Todos>('todos')
+  useQueryClient().getQueriesData<Todos>({ queryKey: 'todos' })
+
+  return <div>Example Component</div>
+}

package/build/codemods/v4/__testfixtures__/type-arguments.output.tsx

@@ -0,0 +1,31 @@
+import * as React from 'react'
+import { useQueries, useQuery, useQueryClient } from 'react-query'
+
+type Todos = {
+  items: readonly {
+    id: string
+    text: string
+  }[]
+  ts: number
+}
+
+export const Examples = () => {
+  useQuery<Todos>(['todos'])
+  useQueries<Array<Todos>>({
+    queries: [query1, query2]
+  })
+  // QueryClient methods
+  // --- Instantiated hook call.
+  const queryClient = useQueryClient()
+  queryClient.getQueriesData<Todos>(['todos'])
+  queryClient.getQueriesData<Todos>({
+    queryKey: ['todos']
+  })
+  // --- Direct hook call.
+  useQueryClient().getQueriesData<Todos>(['todos'])
+  useQueryClient().getQueriesData<Todos>({
+    queryKey: ['todos']
+  })
+
+  return <div>Example Component</div>
+}

package/build/codemods/v4/__tests__/key-transformation.test.js

@@ -0,0 +1,32 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const defineTest = require('jscodeshift/dist/testUtils').defineTest
+
+defineTest(__dirname, 'key-transformation', null, 'default-import', {
+  parser: 'tsx',
+})
+
+defineTest(__dirname, 'key-transformation', null, 'named-import', {
+  parser: 'tsx',
+})
+
+defineTest(__dirname, 'key-transformation', null, 'namespaced-import', {
+  parser: 'tsx',
+})
+
+defineTest(__dirname, 'key-transformation', null, 'parameter-is-identifier', {
+  parser: 'tsx',
+})
+
+defineTest(
+  __dirname,
+  'key-transformation',
+  null,
+  'parameter-is-object-expression',
+  {
+    parser: 'tsx',
+  },
+)
+
+defineTest(__dirname, 'key-transformation', null, 'type-arguments', {
+  parser: 'tsx',
+})

package/build/codemods/v4/__tests__/replace-import-specifier.test.js

@@ -0,0 +1,12 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const defineTest = require('jscodeshift/dist/testUtils').defineTest
+
+defineTest(
+  __dirname,
+  'replace-import-specifier',
+  null,
+  'replace-import-specifier',
+  {
+    parser: 'tsx',
+  },
+)

package/build/codemods/v4/key-transformation.js

@@ -0,0 +1,138 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const createUtilsObject = require('../utils')
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const createKeyReplacer = require('./utils/replacers/key-replacer')
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const createUseQueryLikeTransformer = require('../utils/transformers/use-query-like-transformer')
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const createQueryClientTransformer = require('../utils/transformers/query-client-transformer')
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const createQueryCacheTransformer = require('../utils/transformers/query-cache-transformer')
+
+const transformQueryClientUsages = ({ jscodeshift, utils, root, filePath }) => {
+  const transformer = createQueryClientTransformer({ jscodeshift, utils, root })
+  const replacer = createKeyReplacer({ jscodeshift, root, filePath })
+
+  transformer.execute(
+    [
+      // Not object syntax-aware methods.
+      'getMutationDefaults',
+      'getQueriesData',
+      'getQueryData',
+      'getQueryDefaults',
+      'getQueryState',
+      'isFetching',
+      'setMutationDefaults',
+      'setQueriesData',
+      'setQueryData',
+      'setQueryDefaults',
+      // Object syntax-aware methods.
+      'cancelQueries',
+      'fetchInfiniteQuery',
+      'fetchQuery',
+      'invalidateQueries',
+      'prefetchInfiniteQuery',
+      'prefetchQuery',
+      'refetchQueries',
+      'removeQueries',
+      'resetQueries',
+    ],
+    replacer,
+  )
+}
+
+const transformUseQueriesUsages = ({ jscodeshift, utils, root }) => {
+  const transformer = createUseQueryLikeTransformer({
+    jscodeshift,
+    utils,
+    root,
+  })
+  const replacer = ({ node }) => {
+    /**
+     * When the node doesn't have the 'original' property, that means the codemod has been already applied,
+     * so we don't need to do any changes.
+     */
+    if (!node.original) {
+      return node
+    }
+
+    const newCallExpression = jscodeshift.callExpression(node.original.callee, [
+      jscodeshift.objectExpression([
+        jscodeshift.property(
+          'init',
+          jscodeshift.identifier('queries'),
+          node.original.arguments[0],
+        ),
+      ]),
+    ])
+
+    // TODO: This should be part of one function!
+    if (node.typeParameters) {
+      newCallExpression.typeArguments = node.typeParameters
+    }
+
+    return newCallExpression
+  }
+
+  transformer.execute(['useQueries'], replacer)
+}
+
+const transformUseQueryLikeUsages = ({
+  jscodeshift,
+  utils,
+  root,
+  filePath,
+}) => {
+  const transformer = createUseQueryLikeTransformer({
+    jscodeshift,
+    utils,
+    root,
+  })
+
+  transformer.execute(
+    ['useQuery', 'useInfiniteQuery', 'useIsFetching', 'useIsMutating'],
+    createKeyReplacer({
+      jscodeshift,
+      root,
+      filePath,
+      keyName: 'queryKey',
+    }),
+  )
+  transformer.execute(
+    ['useMutation'],
+    createKeyReplacer({
+      jscodeshift,
+      root,
+      filePath,
+      keyName: 'mutationKey',
+    }),
+  )
+}
+
+const transformQueryCacheUsages = ({ jscodeshift, utils, root, filePath }) => {
+  const transformer = createQueryCacheTransformer({ jscodeshift, utils, root })
+  const replacer = createKeyReplacer({ jscodeshift, root, filePath })
+
+  transformer.execute(replacer)
+}
+
+module.exports = (file, api) => {
+  const jscodeshift = api.jscodeshift
+  const root = jscodeshift(file.source)
+
+  // TODO: Execute the transformers only when it contains a `react-query` import!
+
+  const utils = createUtilsObject({ root, jscodeshift })
+  const filePath = file.path
+
+  // This function transforms usages like `useQuery` and `useMutation`.
+  transformUseQueryLikeUsages({ jscodeshift, utils, root, filePath })
+  // This function transforms usages of `useQueries`.
+  transformUseQueriesUsages({ jscodeshift, utils, root })
+  // This function transforms usages of `QueryClient`.
+  transformQueryClientUsages({ jscodeshift, utils, root, filePath })
+  // This function transforms usages of `QueryCache`.
+  transformQueryCacheUsages({ jscodeshift, utils, root, filePath })
+
+  return root.toSource({ quote: 'single' })
+}

package/build/codemods/v4/replace-import-specifier.js

@@ -0,0 +1,25 @@
+module.exports = (file, api) => {
+  const jscodeshift = api.jscodeshift
+  const root = jscodeshift(file.source)
+
+  const replacements = [
+    { from: 'react-query', to: '@tanstack/react-query' },
+    { from: 'react-query/devtools', to: '@tanstack/react-query-devtools' },
+  ]
+
+  replacements.forEach(({ from, to }) => {
+    root
+      .find(jscodeshift.ImportDeclaration, {
+        source: {
+          value: from,
+        },
+      })
+      .replaceWith(({ node }) => {
+        node.source.value = to
+
+        return node
+      })
+  })
+
+  return root.toSource({ quote: 'single' })
+}

package/build/codemods/v4/utils/replacers/key-replacer.js

@@ -0,0 +1,164 @@
+class UnprocessableKeyError extends Error {
+  constructor(message) {
+    super(message)
+    this.name = 'UnprocessableKeyError'
+  }
+}
+
+module.exports = ({ jscodeshift, root, filePath, keyName = 'queryKey' }) => {
+  const isArrayExpression = (node) =>
+    jscodeshift.match(node, { type: jscodeshift.ArrayExpression.name })
+
+  const isStringLiteral = (node) =>
+    jscodeshift.match(node, { type: jscodeshift.StringLiteral.name }) ||
+    jscodeshift.match(node, { type: jscodeshift.Literal.name })
+
+  const isTemplateLiteral = (node) =>
+    jscodeshift.match(node, { type: jscodeshift.TemplateLiteral.name })
+
+  const findVariableDeclaration = (node) => {
+    const declarations = root
+      .find(jscodeshift.VariableDeclarator, {
+        id: {
+          type: jscodeshift.Identifier.name,
+          name: node.name,
+        },
+      })
+      .paths()
+
+    return declarations.length > 0 ? declarations[0] : null
+  }
+
+  const createKeyValue = (node) => {
+    // When the node is a string literal we convert it into an array of strings.
+    if (isStringLiteral(node)) {
+      return jscodeshift.arrayExpression([
+        jscodeshift.stringLiteral(node.value),
+      ])
+    }
+
+    // When the node is a template literal we convert it into an array of template literals.
+    if (isTemplateLiteral(node)) {
+      return jscodeshift.arrayExpression([
+        jscodeshift.templateLiteral(node.quasis, node.expressions),
+      ])
+    }
+
+    if (jscodeshift.match(node, { type: jscodeshift.Identifier.name })) {
+      // When the node is an identifier at first, we try to find its declaration, because we will try
+      // to guess its type.
+      const variableDeclaration = findVariableDeclaration(node)
+
+      if (!variableDeclaration) {
+        throw new UnprocessableKeyError(
+          `In file ${filePath} at line ${node.loc.start.line} the type of identifier \`${node.name}\` couldn't be recognized, so the codemod couldn't be applied. Please migrate manually.`,
+        )
+      }
+
+      const initializer = variableDeclaration.value.init
+
+      // When it's a string, we just wrap it into an array expression.
+      if (isStringLiteral(initializer) || isTemplateLiteral(initializer)) {
+        return jscodeshift.arrayExpression([node])
+      }
+    }
+
+    throw new UnprocessableKeyError(
+      `In file ${filePath} at line ${node.loc.start.line} the type of the \`${keyName}\` couldn't be recognized, so the codemod couldn't be applied. Please migrate manually.`,
+    )
+  }
+
+  const createKeyProperty = (node) =>
+    jscodeshift.property(
+      'init',
+      jscodeshift.identifier(keyName),
+      createKeyValue(node),
+    )
+
+  const getPropertyFromObjectExpression = (objectExpression, propertyName) =>
+    objectExpression.properties.find(
+      (property) => property.key.name === propertyName,
+    ) ?? null
+
+  const buildWithTypeArguments = (node, builder) => {
+    const newNode = builder(node)
+
+    if (node.typeParameters) {
+      newNode.typeArguments = node.typeParameters
+    }
+
+    return newNode
+  }
+
+  return ({ node }) => {
+    // When the node doesn't have the 'original' property, that means the codemod has been already applied,
+    // so we don't need to do any changes.
+    if (!node.original) {
+      return node
+    }
+
+    const methodArguments = node.arguments
+
+    // The method call doesn't have any arguments, we have nothing to do in this case.
+    if (methodArguments.length === 0) {
+      return node
+    }
+
+    try {
+      const [firstArgument, ...restOfTheArguments] = methodArguments
+
+      if (
+        jscodeshift.match(firstArgument, {
+          type: jscodeshift.ObjectExpression.name,
+        })
+      ) {
+        const originalKey = getPropertyFromObjectExpression(
+          firstArgument,
+          keyName,
+        )
+
+        if (!originalKey) {
+          throw new UnprocessableKeyError(
+            `In file ${filePath} at line ${node.loc.start.line} the \`${keyName}\` couldn't be found. Did you forget to add it?`,
+          )
+        }
+
+        const restOfTheProperties = firstArgument.properties.filter(
+          (item) => item.key.name !== keyName,
+        )
+
+        return buildWithTypeArguments(node, (originalNode) =>
+          jscodeshift.callExpression(originalNode.original.callee, [
+            jscodeshift.objectExpression([
+              createKeyProperty(originalKey.value),
+              ...restOfTheProperties,
+            ]),
+            ...restOfTheArguments,
+          ]),
+        )
+      }
+
+      // When the node is an array expression we just simply return it because we want query keys to be arrays.
+      if (isArrayExpression(firstArgument)) {
+        return node
+      }
+
+      return buildWithTypeArguments(node, (originalNode) =>
+        jscodeshift.callExpression(originalNode.original.callee, [
+          createKeyValue(firstArgument),
+          ...restOfTheArguments,
+        ]),
+      )
+    } catch (error) {
+      if (error.name === 'UnprocessableKeyError') {
+        if (process.env.NODE_ENV !== 'test') {
+          console.warn(error.message)
+        }
+
+        return node
+      }
+
+      throw error
+    }
+  }
+}

package/build/codemods/v5/remove-overloads/__testfixtures__/default-import.input.tsx

@@ -0,0 +1,199 @@
+import * as React from 'react'
+import {
+  useIsFetching,
+  useIsMutating,
+  useQueryClient,
+} from '@tanstack/react-query'
+import { queryKeysFromAnotherModule } from '../another/module'
+
+export const WithKnownParameters = () => {
+  useIsFetching(['foo', 'bar'])
+  useIsFetching(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  useIsFetching(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true }, { context: undefined })
+  useIsFetching(['foo', 'bar'], { type: 'all', exact: true })
+  useIsFetching(['foo', 'bar'], { type: 'all', exact: true }, { context: undefined })
+  useIsFetching({ queryKey: ['foo', 'bar'], type: 'all', exact: true })
+  useIsFetching({ queryKey: ['foo', 'bar'], type: 'all', exact: true }, { context: undefined })
+
+  useIsMutating(['foo', 'bar'])
+  useIsMutating(['foo', 'bar'], { exact: true })
+  useIsMutating(['foo', 'bar'], { exact: true }, { context: undefined })
+  useIsMutating({ mutationKey: ['foo', 'bar'], exact: true })
+  useIsMutating({ mutationKey: ['foo', 'bar'], exact: true }, { context: undefined })
+
+  // QueryClient methods
+  // --- Instantiated hook call.
+  const queryClient = useQueryClient()
+  queryClient.cancelQueries(['foo', 'bar'])
+  queryClient.cancelQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  queryClient.cancelQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true }, { silent: true })
+  queryClient.cancelQueries(['foo', 'bar'], { type: 'all', exact: true })
+  queryClient.cancelQueries(['foo', 'bar'], { type: 'all', exact: true }, { silent: true })
+  queryClient.cancelQueries({ queryKey: ['foo', 'bar'], type: 'all', exact: true })
+  queryClient.cancelQueries({ queryKey: ['foo', 'bar'], type: 'all', exact: true }, { silent: true })
+
+  queryClient.getQueriesData(['foo', 'bar'])
+  queryClient.getQueriesData({ queryKey: ['foo', 'bar'], type: 'all', exact: true })
+
+  queryClient.invalidateQueries(['foo', 'bar'])
+  queryClient.invalidateQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  queryClient.invalidateQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true }, { cancelRefetch: false, throwOnError: true })
+  queryClient.invalidateQueries(['foo', 'bar'], { type: 'all', exact: true })
+  queryClient.invalidateQueries(['foo', 'bar'], { type: 'all', exact: true }, { cancelRefetch: false, throwOnError: true })
+  queryClient.invalidateQueries({ queryKey: ['foo', 'bar'], type: 'all', exact: true })
+  queryClient.invalidateQueries({ queryKey: ['foo', 'bar'], type: 'all', exact: true }, { cancelRefetch: false, throwOnError: true })
+
+  queryClient.isFetching(['foo', 'bar'])
+  queryClient.isFetching(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  queryClient.isFetching(['foo', 'bar'], { type: 'all', exact: true })
+  queryClient.isFetching({ queryKey: ['foo', 'bar'], type: 'all', exact: true })
+
+  queryClient.refetchQueries(['foo', 'bar'])
+  queryClient.refetchQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  queryClient.refetchQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true }, { cancelRefetch: false, throwOnError: true })
+  queryClient.refetchQueries(['foo', 'bar'], { type: 'all', exact: true })
+  queryClient.refetchQueries(['foo', 'bar'], { type: 'all', exact: true }, { cancelRefetch: false, throwOnError: true })
+  queryClient.refetchQueries({ queryKey: ['foo', 'bar'], type: 'all', exact: true })
+  queryClient.refetchQueries({ queryKey: ['foo', 'bar'], type: 'all', exact: true }, { cancelRefetch: false, throwOnError: true })
+
+  queryClient.removeQueries(['foo', 'bar'])
+  queryClient.removeQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  queryClient.removeQueries({ queryKey: ['foo', 'bar'], type: 'all', exact: true })
+
+  queryClient.resetQueries(['foo', 'bar'])
+  queryClient.resetQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  queryClient.resetQueries(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true }, { cancelRefetch: false, throwOnError: true })
+  queryClient.resetQueries(['foo', 'bar'], { type: 'all', exact: true })
+  queryClient.resetQueries(['foo', 'bar'], { type: 'all', exact: true }, { cancelRefetch: false, throwOnError: true })
+  queryClient.resetQueries({ queryKey: ['foo', 'bar'], exact: true })
+  queryClient.resetQueries({ queryKey: ['foo', 'bar'], exact: true }, { cancelRefetch: false, throwOnError: true })
+
+  queryClient.setQueriesData(['foo', 'bar'], null)
+  queryClient.setQueriesData(['foo', 'bar'], null, { updatedAt: 1000 })
+  queryClient.setQueriesData({ queryKey: ['foo', 'bar'] }, null)
+  queryClient.setQueriesData({ queryKey: ['foo', 'bar'] }, null, { updatedAt: 1000 })
+
+  queryClient.fetchQuery(['foo', 'bar'])
+  queryClient.fetchQuery(['foo', 'bar'], { queryKey: ['todos'], staleTime: 1000 })
+  queryClient.fetchQuery(['foo', 'bar'], { queryKey: ['todos'], queryFn: () => 'data', staleTime: 1000 })
+  queryClient.fetchQuery(['foo', 'bar'], () => 'data', { queryKey: ['todos'], staleTime: 1000 })
+  queryClient.fetchQuery(['foo', 'bar'], function myFn() { return 'data' }, { queryKey: ['todos'], staleTime: 1000 })
+  queryClient.fetchQuery({ queryKey: ['foo', 'bar'], queryFn: () => 'data', retry: true })
+
+  const queryCache = queryClient.getQueryCache()
+
+  queryCache.find(['foo', 'bar'])
+  queryCache.find(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  queryCache.find(['foo', 'bar'], { type: 'all', exact: true })
+
+  queryCache.findAll(['foo', 'bar'])
+  queryCache.findAll(['foo', 'bar'], { type: 'all', exact: true })
+  queryCache.findAll(['foo', 'bar'], { queryKey: ['todos'], type: 'all', exact: true })
+  queryCache.findAll({ queryKey: ['foo', 'bar'], type: 'all', exact: true })
+
+  return <div>Example Component</div>
+}
+
+const globalQueryKey = ['module', 'level']
+
+export const WithIdentifiers = () => {
+  const queryKey = ['foo', 'bar']
+  const mutationKey = ['posts', 'articles']
+  const filters = { type: 'all', exact: true } as const
+  const options = { context: undefined } as const
+  const mutationOptions = { exact: true, fetching: false } as const
+  const cancelOptions = { silent: true } as const
+  const invalidateOptions = { cancelRefetch: true, throwOnError: true } as const
+  const refetchOptions = { cancelRefetch: false, throwOnError: true } as const
+  const resetOptions = { cancelRefetch: false, throwOnError: true } as const
+  const fetchOptions = { queryFn: () => 'data', retry: true } as const
+  const queryFn = () => 'data'
+
+  useIsFetching(queryKey)
+  useIsFetching(queryKey, filters)
+  useIsFetching(queryKey, filters, options)
+  useIsFetching(queryKey, { type: 'all', exact: true })
+  useIsFetching(queryKey, { type: 'all', exact: true }, { context: undefined })
+  useIsFetching(queryKey, { queryKey: ['todos'], ...filters }, options)
+  useIsFetching({ queryKey: queryKey, ...filters })
+  useIsFetching({ queryKey: queryKey, ...filters }, { context: undefined })
+
+  useIsMutating(mutationKey)
+  useIsMutating(mutationKey, { exact: true, status: 'idle' })
+  useIsMutating(mutationKey, { ...mutationOptions, exact: false })
+  useIsMutating({ mutationKey, ...mutationOptions })
+  useIsMutating({ mutationKey: ['foo', 'bar'], exact: true, status: 'idle' })
+
+  // QueryClient methods
+  // --- Instantiated hook call.
+  const queryClient = useQueryClient()
+  queryClient.cancelQueries(queryKey)
+  queryClient.cancelQueries(queryKey, filters)
+  queryClient.cancelQueries(queryKey, filters, cancelOptions)
+  queryClient.cancelQueries(queryKey, { type: 'all', exact: true })
+  queryClient.cancelQueries(queryKey, { type: 'all', exact: true }, { revert: true })
+  queryClient.cancelQueries(queryKey, { queryKey: ['todos'], ...filters }, cancelOptions)
+  queryClient.cancelQueries({ queryKey: queryKey, type: 'all', exact: true })
+  queryClient.cancelQueries({ queryKey: ['foo', 'bar'], ...filters }, cancelOptions)
+
+  queryClient.getQueriesData(globalQueryKey)
+  queryClient.getQueriesData({ queryKey: globalQueryKey, ...filters })
+  queryClient.getQueriesData({ queryKey: ['foo', 'bar'], type: 'all' })
+
+  queryClient.invalidateQueries(queryKey)
+  queryClient.invalidateQueries(queryKey, filters)
+  queryClient.invalidateQueries(queryKey, filters, invalidateOptions)
+  queryClient.invalidateQueries(queryKey, { queryKey: ['todos'], stale: true, ...filters })
+  queryClient.invalidateQueries(queryKey, { queryKey: ['todos'], stale: true, ...filters }, invalidateOptions)
+  queryClient.invalidateQueries({ queryKey: globalQueryKey, ...filters, stale: true })
+  queryClient.invalidateQueries({ queryKey: globalQueryKey, ...filters, stale: true }, invalidateOptions)
+
+  queryClient.isFetching(globalQueryKey)
+  queryClient.isFetching(globalQueryKey, filters)
+  queryClient.isFetching(globalQueryKey, { queryKey: ['todos'], type: 'all', exact: true })
+  queryClient.isFetching(globalQueryKey, { queryKey: ['todos'], ...filters })
+  queryClient.isFetching({ queryKey: globalQueryKey, ...filters, stale: true })
+  // Stays as it is because the code couldn't infer the type of the "queryKeysFromAnotherModule" identifier.
+  queryClient.isFetching(queryKeysFromAnotherModule)
+
+  queryClient.refetchQueries(queryKey)
+  queryClient.refetchQueries(queryKey, filters)
+  queryClient.refetchQueries(queryKey, filters, refetchOptions)
+  queryClient.refetchQueries(queryKey, { queryKey: ['todos'], ...filters }, { ...refetchOptions, cancelRefetch: true })
+  queryClient.refetchQueries({ queryKey: queryKey, ...filters })
+  queryClient.refetchQueries({ queryKey: queryKey, ...filters }, { ...refetchOptions, cancelRefetch: true })
+  // Stays as it is because the code couldn't infer the type of the "queryKeysFromAnotherModule" identifier.
+  queryClient.refetchQueries(queryKeysFromAnotherModule)
+  queryClient.refetchQueries(queryKeysFromAnotherModule, filters)
+  queryClient.refetchQueries(queryKeysFromAnotherModule, filters, refetchOptions)
+
+  queryClient.removeQueries(queryKey)
+  queryClient.removeQueries(queryKey, filters)
+  queryClient.removeQueries(queryKey, { queryKey: ['todos'], ...filters, stale: true })
+  queryClient.removeQueries({ queryKey, ...filters, stale: true })
+  // Stays as it is because the code couldn't infer the type of the "queryKeysFromAnotherModule" identifier.
+  queryClient.removeQueries(queryKeysFromAnotherModule)
+  queryClient.removeQueries(queryKeysFromAnotherModule, filters)
+
+  queryClient.resetQueries(queryKey)
+  queryClient.resetQueries(queryKey, filters)
+  queryClient.resetQueries(queryKey, filters, resetOptions)
+  queryClient.resetQueries(queryKey, { queryKey: ['todos'], ...filters, stale: true })
+  queryClient.resetQueries(queryKey, { queryKey: ['todos'], ...filters, stale: true }, resetOptions)
+  queryClient.resetQueries({ queryKey, ...filters, stale: true })
+  queryClient.resetQueries({ queryKey, ...filters, stale: true }, resetOptions)
+  // Stays as it is because the code couldn't infer the type of the "queryKeysFromAnotherModule" identifier.
+  queryClient.resetQueries(queryKeysFromAnotherModule)
+  queryClient.resetQueries(queryKeysFromAnotherModule, filters)
+  queryClient.resetQueries(queryKeysFromAnotherModule, filters, resetOptions)
+
+  queryClient.fetchQuery(queryKey)
+  queryClient.fetchQuery(queryKey, fetchOptions)
+  queryClient.fetchQuery(queryKey, { networkMode: 'always', ...fetchOptions })
+  queryClient.fetchQuery(queryKey, queryFn, fetchOptions)
+  queryClient.fetchQuery(queryKey, () => 'data', { networkMode: 'always', ...fetchOptions })
+  // Stays as it is because the code couldn't infer the type of the "queryKeysFromAnotherModule" identifier.
+  queryClient.fetchQuery(queryKeysFromAnotherModule)
+  queryClient.fetchQuery(queryKeysFromAnotherModule, fetchOptions)
+  queryClient.fetchQuery(queryKeysFromAnotherModule, queryFn, fetchOptions)
+}