diff --git a/src/index.ts b/src/index.ts
index 780dcb1..0b7803b 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,13 +1,10 @@
 /* istanbul ignore file */
 
 export {
-  QueryClient,
   QueryObserver,
   QueriesObserver,
   InfiniteQueryObserver,
   MutationObserver,
-  QueryCache,
-  MutationCache,
   hydrate,
   dehydrate,
   focusManager,
diff --git a/src/vue/__tests__/mutationCache.test.ts b/src/vue/__tests__/mutationCache.test.ts
new file mode 100644
index 0000000..4c3746c
--- /dev/null
+++ b/src/vue/__tests__/mutationCache.test.ts
@@ -0,0 +1,44 @@
+import { ref } from "vue-demi";
+import { MutationCache as MutationCacheOrigin } from "react-query/core";
+
+import { MutationCache } from "../mutationCache";
+
+describe("MutationCache", () => {
+  beforeAll(() => {
+    jest.spyOn(MutationCacheOrigin.prototype, "find");
+    jest.spyOn(MutationCacheOrigin.prototype, "findAll");
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("find", () => {
+    test("should properly unwrap parameters", async () => {
+      const mutationCache = new MutationCache();
+
+      mutationCache.find({
+        mutationKey: ref("baz"),
+      });
+
+      expect(MutationCacheOrigin.prototype.find).toBeCalledWith({
+        exact: true,
+        mutationKey: "baz",
+      });
+    });
+  });
+
+  describe("findAll", () => {
+    test("should properly unwrap parameters", async () => {
+      const mutationCache = new MutationCache();
+
+      mutationCache.findAll({
+        mutationKey: ref("baz"),
+      });
+
+      expect(MutationCacheOrigin.prototype.findAll).toBeCalledWith({
+        mutationKey: "baz",
+      });
+    });
+  });
+});
diff --git a/src/vue/__tests__/queryCache.test.ts b/src/vue/__tests__/queryCache.test.ts
new file mode 100644
index 0000000..2df7b29
--- /dev/null
+++ b/src/vue/__tests__/queryCache.test.ts
@@ -0,0 +1,58 @@
+import { ref } from "vue-demi";
+import { QueryCache as QueryCacheOrigin } from "react-query/core";
+
+import { QueryCache } from "../queryCache";
+
+describe("QueryCache", () => {
+  beforeAll(() => {
+    jest.spyOn(QueryCacheOrigin.prototype, "find");
+    jest.spyOn(QueryCacheOrigin.prototype, "findAll");
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("find", () => {
+    test("should properly unwrap parameters", async () => {
+      const queryCache = new QueryCache();
+
+      queryCache.find(["foo", ref("bar")], {
+        queryKey: ref("baz"),
+      });
+
+      expect(QueryCacheOrigin.prototype.find).toBeCalledWith(["foo", "bar"], {
+        queryKey: "baz",
+      });
+    });
+  });
+
+  describe("findAll", () => {
+    test("should properly unwrap two parameters", async () => {
+      const queryCache = new QueryCache();
+
+      queryCache.findAll(["foo", ref("bar")], {
+        queryKey: ref("baz"),
+      });
+
+      expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith(
+        ["foo", "bar"],
+        {
+          queryKey: "baz",
+        }
+      );
+    });
+
+    test("should properly unwrap one parameter", async () => {
+      const queryCache = new QueryCache();
+
+      queryCache.findAll({
+        queryKey: ref("baz"),
+      });
+
+      expect(QueryCacheOrigin.prototype.findAll).toBeCalledWith({
+        queryKey: "baz",
+      });
+    });
+  });
+});
diff --git a/src/vue/__tests__/queryClient.test.ts b/src/vue/__tests__/queryClient.test.ts
new file mode 100644
index 0000000..d1b04e5
--- /dev/null
+++ b/src/vue/__tests__/queryClient.test.ts
@@ -0,0 +1,550 @@
+import { ref } from "vue-demi";
+import { QueryClient as QueryClientOrigin } from "react-query/core";
+
+import { QueryClient } from "../queryClient";
+
+jest.mock("react-query/core");
+
+const queryKeyRef = ["foo", ref("bar")];
+const queryKeyUnref = ["foo", "bar"];
+
+const fn = () => {};
+
+describe("QueryCache", () => {
+  // beforeAll(() => {
+  //   jest.spyOn(QueryCacheOrigin.prototype, "find");
+  //   jest.spyOn(QueryCacheOrigin.prototype, "findAll");
+  // });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("isFetching", () => {
+    test("should properly unwrap 1 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.isFetching({
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.isFetching).toBeCalledWith({
+        queryKey: queryKeyUnref,
+      });
+    });
+
+    test("should properly unwrap 2 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.isFetching(queryKeyRef, {
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.isFetching).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        }
+      );
+    });
+  });
+
+  describe("isMutating", () => {
+    test("should properly unwrap 1 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.isMutating({
+        mutationKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.isMutating).toBeCalledWith({
+        mutationKey: queryKeyUnref,
+      });
+    });
+  });
+
+  describe("getQueryData", () => {
+    test("should properly unwrap 2 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.getQueryData(queryKeyRef, {
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.getQueryData).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        }
+      );
+    });
+  });
+
+  describe("getQueriesData", () => {
+    test("should properly unwrap queryKey param", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.getQueriesData(queryKeyRef);
+
+      expect(QueryClientOrigin.prototype.getQueriesData).toBeCalledWith(
+        queryKeyUnref
+      );
+    });
+
+    test("should properly unwrap filters param", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.getQueriesData({ queryKey: queryKeyRef });
+
+      expect(QueryClientOrigin.prototype.getQueriesData).toBeCalledWith({
+        queryKey: queryKeyUnref,
+      });
+    });
+  });
+
+  describe("setQueryData", () => {
+    test("should properly unwrap 3 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.setQueryData(queryKeyRef, fn, { updatedAt: ref(3) });
+
+      expect(QueryClientOrigin.prototype.setQueryData).toBeCalledWith(
+        queryKeyUnref,
+        fn,
+        { updatedAt: 3 }
+      );
+    });
+  });
+
+  describe("setQueriesData", () => {
+    test("should properly unwrap params with queryKey", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.setQueriesData(queryKeyRef, fn, { updatedAt: ref(3) });
+
+      expect(QueryClientOrigin.prototype.setQueriesData).toBeCalledWith(
+        queryKeyUnref,
+        fn,
+        { updatedAt: 3 }
+      );
+    });
+
+    test("should properly unwrap params with filters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.setQueriesData({ queryKey: queryKeyRef }, fn, {
+        updatedAt: ref(3),
+      });
+
+      expect(QueryClientOrigin.prototype.setQueriesData).toBeCalledWith(
+        { queryKey: queryKeyUnref },
+        fn,
+        { updatedAt: 3 }
+      );
+    });
+  });
+
+  describe("getQueryState", () => {
+    test("should properly unwrap 2 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.getQueryState(queryKeyRef, { queryKey: queryKeyRef });
+
+      expect(QueryClientOrigin.prototype.getQueryState).toBeCalledWith(
+        queryKeyUnref,
+        { queryKey: queryKeyUnref }
+      );
+    });
+  });
+
+  describe("removeQueries", () => {
+    test("should properly unwrap 1 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.removeQueries({
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.removeQueries).toBeCalledWith({
+        queryKey: queryKeyUnref,
+      });
+    });
+
+    test("should properly unwrap 2 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.removeQueries(queryKeyRef, {
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.removeQueries).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        }
+      );
+    });
+  });
+
+  describe("resetQueries", () => {
+    test("should properly unwrap 2 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.resetQueries(
+        {
+          queryKey: queryKeyRef,
+        },
+        { cancelRefetch: ref(false) }
+      );
+
+      expect(QueryClientOrigin.prototype.resetQueries).toBeCalledWith(
+        {
+          queryKey: queryKeyUnref,
+        },
+        { cancelRefetch: false }
+      );
+    });
+
+    test("should properly unwrap 3 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.resetQueries(
+        queryKeyRef,
+        {
+          queryKey: queryKeyRef,
+        },
+        { cancelRefetch: ref(false) }
+      );
+
+      expect(QueryClientOrigin.prototype.resetQueries).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        },
+        { cancelRefetch: false }
+      );
+    });
+  });
+
+  describe("cancelQueries", () => {
+    test("should properly unwrap 2 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.cancelQueries(
+        {
+          queryKey: queryKeyRef,
+        },
+        { revert: ref(false) }
+      );
+
+      expect(QueryClientOrigin.prototype.cancelQueries).toBeCalledWith(
+        {
+          queryKey: queryKeyUnref,
+        },
+        { revert: false }
+      );
+    });
+
+    test("should properly unwrap 3 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.cancelQueries(
+        queryKeyRef,
+        {
+          queryKey: queryKeyRef,
+        },
+        { revert: ref(false) }
+      );
+
+      expect(QueryClientOrigin.prototype.cancelQueries).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        },
+        { revert: false }
+      );
+    });
+  });
+
+  describe("invalidateQueries", () => {
+    test("should properly unwrap 2 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.invalidateQueries(
+        {
+          queryKey: queryKeyRef,
+        },
+        { cancelRefetch: ref(false) }
+      );
+
+      expect(QueryClientOrigin.prototype.invalidateQueries).toBeCalledWith(
+        {
+          queryKey: queryKeyUnref,
+        },
+        { cancelRefetch: false }
+      );
+    });
+
+    test("should properly unwrap 3 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.invalidateQueries(
+        queryKeyRef,
+        {
+          queryKey: queryKeyRef,
+        },
+        { cancelRefetch: ref(false) }
+      );
+
+      expect(QueryClientOrigin.prototype.invalidateQueries).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        },
+        { cancelRefetch: false }
+      );
+    });
+  });
+
+  describe("refetchQueries", () => {
+    test("should properly unwrap 2 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.refetchQueries(
+        {
+          queryKey: queryKeyRef,
+        },
+        { cancelRefetch: ref(false) }
+      );
+
+      expect(QueryClientOrigin.prototype.refetchQueries).toBeCalledWith(
+        {
+          queryKey: queryKeyUnref,
+        },
+        { cancelRefetch: false }
+      );
+    });
+
+    test("should properly unwrap 3 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.refetchQueries(
+        queryKeyRef,
+        {
+          queryKey: queryKeyRef,
+        },
+        { cancelRefetch: ref(false) }
+      );
+
+      expect(QueryClientOrigin.prototype.refetchQueries).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        },
+        { cancelRefetch: false }
+      );
+    });
+  });
+
+  describe("fetchQuery", () => {
+    test("should properly unwrap 1 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.fetchQuery({
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.fetchQuery).toBeCalledWith({
+        queryKey: queryKeyUnref,
+      });
+    });
+
+    test("should properly unwrap 2 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.fetchQuery(queryKeyRef, {
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.fetchQuery).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        },
+        undefined
+      );
+    });
+
+    test("should properly unwrap 3 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.fetchQuery(queryKeyRef, fn, {
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.fetchQuery).toBeCalledWith(
+        queryKeyUnref,
+        fn,
+        {
+          queryKey: queryKeyUnref,
+        }
+      );
+    });
+  });
+
+  describe("prefetchQuery", () => {
+    test("should properly unwrap parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.prefetchQuery(queryKeyRef, fn, { queryKey: queryKeyRef });
+
+      expect(QueryClientOrigin.prototype.prefetchQuery).toBeCalledWith(
+        queryKeyUnref,
+        fn,
+        {
+          queryKey: queryKeyUnref,
+        }
+      );
+    });
+  });
+
+  describe("fetchInfiniteQuery", () => {
+    test("should properly unwrap 1 parameter", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.fetchInfiniteQuery({
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith({
+        queryKey: queryKeyUnref,
+      });
+    });
+
+    test("should properly unwrap 2 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.fetchInfiniteQuery(queryKeyRef, {
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith(
+        queryKeyUnref,
+        {
+          queryKey: queryKeyUnref,
+        },
+        undefined
+      );
+    });
+
+    test("should properly unwrap 3 parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.fetchInfiniteQuery(queryKeyRef, fn, {
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.fetchInfiniteQuery).toBeCalledWith(
+        queryKeyUnref,
+        fn,
+        {
+          queryKey: queryKeyUnref,
+        }
+      );
+    });
+  });
+
+  describe("prefetchInfiniteQuery", () => {
+    test("should properly unwrap parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.prefetchInfiniteQuery(queryKeyRef, fn, {
+        queryKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.prefetchInfiniteQuery).toBeCalledWith(
+        queryKeyUnref,
+        fn,
+        {
+          queryKey: queryKeyUnref,
+        }
+      );
+    });
+  });
+
+  describe("setDefaultOptions", () => {
+    test("should properly unwrap parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.setDefaultOptions({
+        queries: {
+          enabled: ref(false),
+        },
+      });
+
+      expect(QueryClientOrigin.prototype.setDefaultOptions).toBeCalledWith({
+        queries: {
+          enabled: false,
+        },
+      });
+    });
+  });
+
+  describe("setQueryDefaults", () => {
+    test("should properly unwrap parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.setQueryDefaults(queryKeyRef, {
+        enabled: ref(false),
+      });
+
+      expect(QueryClientOrigin.prototype.setQueryDefaults).toBeCalledWith(
+        queryKeyUnref,
+        {
+          enabled: false,
+        }
+      );
+    });
+  });
+
+  describe("getQueryDefaults", () => {
+    test("should properly unwrap parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.getQueryDefaults(queryKeyRef);
+
+      expect(QueryClientOrigin.prototype.getQueryDefaults).toBeCalledWith(
+        queryKeyUnref
+      );
+    });
+  });
+
+  describe("setMutationDefaults", () => {
+    test("should properly unwrap parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.setMutationDefaults(queryKeyRef, {
+        mutationKey: queryKeyRef,
+      });
+
+      expect(QueryClientOrigin.prototype.setMutationDefaults).toBeCalledWith(
+        queryKeyUnref,
+        {
+          mutationKey: queryKeyUnref,
+        }
+      );
+    });
+  });
+
+  describe("getMutationDefaults", () => {
+    test("should properly unwrap parameters", async () => {
+      const queryClient = new QueryClient();
+
+      queryClient.getMutationDefaults(queryKeyRef);
+
+      expect(QueryClientOrigin.prototype.getMutationDefaults).toBeCalledWith(
+        queryKeyUnref
+      );
+    });
+  });
+});
diff --git a/src/vue/index.ts b/src/vue/index.ts
index f5e23be..d253768 100644
--- a/src/vue/index.ts
+++ b/src/vue/index.ts
@@ -4,6 +4,9 @@ export { useQueryClient } from "./useQueryClient";
 export { useQueryProvider } from "./useQueryProvider";
 export { VueQueryPlugin } from "./vueQueryPlugin";
 
+export { QueryClient } from "./queryClient";
+export { QueryCache } from "./queryCache";
+export { MutationCache } from "./mutationCache";
 export { useQuery } from "./useQuery";
 export { useQueries } from "./useQueries";
 export { useInfiniteQuery } from "./useInfiniteQuery";
diff --git a/src/vue/mutationCache.ts b/src/vue/mutationCache.ts
new file mode 100644
index 0000000..48cbd29
--- /dev/null
+++ b/src/vue/mutationCache.ts
@@ -0,0 +1,17 @@
+import { MutationCache as MC } from "react-query/core";
+import type { Mutation } from "react-query/core";
+import type { MutationFilters } from "react-query/types/core/utils";
+import type { MaybeRefDeep } from "./types";
+import { cloneDeepUnref } from "./utils";
+
+export class MutationCache extends MC {
+  find<TData = unknown, TError = unknown, TVariables = any, TContext = unknown>(
+    filters: MaybeRefDeep<MutationFilters>
+  ): Mutation<TData, TError, TVariables, TContext> | undefined {
+    return super.find(cloneDeepUnref(filters) as MutationFilters);
+  }
+
+  findAll(filters: MaybeRefDeep<MutationFilters>): Mutation[] {
+    return super.findAll(cloneDeepUnref(filters) as MutationFilters);
+  }
+}
diff --git a/src/vue/queryCache.ts b/src/vue/queryCache.ts
new file mode 100644
index 0000000..2d4556a
--- /dev/null
+++ b/src/vue/queryCache.ts
@@ -0,0 +1,37 @@
+import { QueryCache as QC } from "react-query/core";
+import type { Query, QueryKey } from "react-query/core";
+import type { QueryFilters } from "react-query/types/core/utils";
+import type { MaybeRefDeep } from "./types";
+import { cloneDeepUnref, isQueryKey } from "./utils";
+
+export class QueryCache extends QC {
+  find<TQueryFnData = unknown, TError = unknown, TData = TQueryFnData>(
+    arg1: MaybeRefDeep<QueryKey>,
+    arg2?: MaybeRefDeep<QueryFilters>
+  ): Query<TQueryFnData, TError, TData> | undefined {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    const arg2Unreffed = cloneDeepUnref(arg2) as QueryFilters;
+    return super.find(arg1Unreffed, arg2Unreffed);
+  }
+
+  findAll(
+    queryKey?: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<QueryFilters>
+  ): Query[];
+  findAll(filters?: MaybeRefDeep<QueryFilters>): Query[];
+  findAll(
+    arg1?: MaybeRefDeep<QueryKey | QueryFilters>,
+    arg2?: MaybeRefDeep<QueryFilters>
+  ): Query[];
+  findAll(
+    arg1?: MaybeRefDeep<QueryKey> | MaybeRefDeep<QueryFilters>,
+    arg2?: MaybeRefDeep<QueryFilters>
+  ): Query[] {
+    const arg1Unreffed = cloneDeepUnref(arg1) as QueryKey | QueryFilters;
+    const arg2Unreffed = cloneDeepUnref(arg2) as QueryFilters;
+    if (isQueryKey(arg1Unreffed)) {
+      return super.findAll(arg1Unreffed, arg2Unreffed);
+    }
+    return super.findAll(arg1Unreffed);
+  }
+}
diff --git a/src/vue/queryClient.ts b/src/vue/queryClient.ts
new file mode 100644
index 0000000..dee2547
--- /dev/null
+++ b/src/vue/queryClient.ts
@@ -0,0 +1,569 @@
+import { QueryClient as QC } from "react-query/core";
+import type {
+  QueryKey,
+  QueryClientConfig,
+  SetDataOptions,
+  ResetQueryFilters,
+  ResetOptions,
+  CancelOptions,
+  InvalidateQueryFilters,
+  InvalidateOptions,
+  RefetchQueryFilters,
+  RefetchOptions,
+  FetchQueryOptions,
+  QueryFunction,
+  FetchInfiniteQueryOptions,
+  InfiniteData,
+  DefaultOptions,
+  QueryObserverOptions,
+  MutationKey,
+  MutationObserverOptions,
+} from "react-query/core";
+import type {
+  QueryFilters,
+  MutationFilters,
+  Updater,
+} from "react-query/types/core/utils";
+import type { QueryState } from "react-query/types/core/query";
+import type { MaybeRefDeep } from "./types";
+import { cloneDeepUnref, isQueryKey } from "./utils";
+import { QueryCache } from "./queryCache";
+import { MutationCache } from "./mutationCache";
+
+export class QueryClient extends QC {
+  constructor(config: MaybeRefDeep<QueryClientConfig> = {}) {
+    const unreffedConfig = cloneDeepUnref(config) as QueryClientConfig;
+    const vueQueryConfig: QueryClientConfig = {
+      defaultOptions: cloneDeepUnref(unreffedConfig.defaultOptions),
+      queryCache: unreffedConfig.queryCache || new QueryCache(),
+      mutationCache: unreffedConfig.mutationCache || new MutationCache(),
+    };
+    super(vueQueryConfig);
+  }
+
+  isFetching(filters?: MaybeRefDeep<QueryFilters>): number;
+  isFetching(
+    queryKey?: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<QueryFilters>
+  ): number;
+  isFetching(
+    arg1?: MaybeRefDeep<QueryFilters | QueryKey>,
+    arg2?: MaybeRefDeep<QueryFilters>
+  ): number {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    const arg2Unreffed = cloneDeepUnref(arg2) as QueryFilters;
+    if (isQueryKey(arg1Unreffed)) {
+      return super.isFetching(arg1Unreffed, arg2Unreffed);
+    }
+    return super.isFetching(arg1Unreffed as QueryFilters);
+  }
+
+  isMutating(filters?: MaybeRefDeep<MutationFilters>): number {
+    return super.isMutating(cloneDeepUnref(filters) as MutationFilters);
+  }
+
+  getQueryData<TData = unknown>(
+    queryKey: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<QueryFilters>
+  ): TData | undefined {
+    return super.getQueryData(
+      cloneDeepUnref(queryKey),
+      cloneDeepUnref(filters) as QueryFilters
+    );
+  }
+
+  getQueriesData<TData = unknown>(
+    queryKey: MaybeRefDeep<QueryKey>
+  ): [QueryKey, TData][];
+  getQueriesData<TData = unknown>(
+    filters: MaybeRefDeep<QueryFilters>
+  ): [QueryKey, TData][];
+  getQueriesData<TData = unknown>(
+    queryKeyOrFilters: MaybeRefDeep<QueryKey> | MaybeRefDeep<QueryFilters>
+  ): [QueryKey, TData][] {
+    const unreffed = cloneDeepUnref(queryKeyOrFilters);
+    if (isQueryKey(unreffed)) {
+      return super.getQueriesData(unreffed);
+    }
+    return super.getQueriesData(unreffed as QueryFilters);
+  }
+
+  setQueryData<TData>(
+    queryKey: MaybeRefDeep<QueryKey>,
+    updater: Updater<TData | undefined, TData>,
+    options?: MaybeRefDeep<SetDataOptions>
+  ): TData {
+    return super.setQueryData(
+      cloneDeepUnref(queryKey),
+      updater,
+      cloneDeepUnref(options) as SetDataOptions
+    );
+  }
+
+  setQueriesData<TData>(
+    queryKey: MaybeRefDeep<QueryKey>,
+    updater: Updater<TData | undefined, TData>,
+    options?: MaybeRefDeep<SetDataOptions>
+  ): [QueryKey, TData][];
+  setQueriesData<TData>(
+    filters: MaybeRefDeep<QueryFilters>,
+    updater: Updater<TData | undefined, TData>,
+    options?: MaybeRefDeep<SetDataOptions>
+  ): [QueryKey, TData][];
+  setQueriesData<TData>(
+    queryKeyOrFilters: MaybeRefDeep<QueryKey | QueryFilters>,
+    updater: Updater<TData | undefined, TData>,
+    options?: MaybeRefDeep<SetDataOptions>
+  ): [QueryKey, TData][] {
+    const arg1Unreffed = cloneDeepUnref(queryKeyOrFilters);
+    const arg3Unreffed = cloneDeepUnref(options) as SetDataOptions;
+    if (isQueryKey(arg1Unreffed)) {
+      return super.setQueriesData(arg1Unreffed, updater, arg3Unreffed);
+    }
+    return super.setQueriesData(
+      arg1Unreffed as QueryFilters,
+      updater,
+      arg3Unreffed
+    );
+  }
+
+  getQueryState<TData = unknown, TError = undefined>(
+    queryKey: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<QueryFilters>
+  ): QueryState<TData, TError> | undefined {
+    return super.getQueryState(
+      cloneDeepUnref(queryKey),
+      cloneDeepUnref(filters) as QueryFilters
+    );
+  }
+
+  removeQueries(filters?: MaybeRefDeep<QueryFilters>): void;
+  removeQueries(
+    queryKey?: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<QueryFilters>
+  ): void;
+  removeQueries(
+    arg1?: MaybeRefDeep<QueryKey | QueryFilters>,
+    arg2?: MaybeRefDeep<QueryFilters>
+  ): void {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    if (isQueryKey(arg1Unreffed)) {
+      return super.removeQueries(
+        arg1Unreffed,
+        cloneDeepUnref(arg2) as QueryFilters
+      );
+    }
+    return super.removeQueries(arg1Unreffed as QueryFilters);
+  }
+
+  resetQueries<TPageData = unknown>(
+    filters?: MaybeRefDeep<ResetQueryFilters<TPageData>>,
+    options?: MaybeRefDeep<ResetOptions>
+  ): Promise<void>;
+  resetQueries<TPageData = unknown>(
+    queryKey?: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<ResetQueryFilters<TPageData>>,
+    options?: MaybeRefDeep<ResetOptions>
+  ): Promise<void>;
+  resetQueries<TPageData = unknown>(
+    arg1?: MaybeRefDeep<QueryKey | ResetQueryFilters<TPageData>>,
+    arg2?: MaybeRefDeep<ResetQueryFilters<TPageData> | ResetOptions>,
+    arg3?: MaybeRefDeep<ResetOptions>
+  ): Promise<void> {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    const arg2Unreffed = cloneDeepUnref(arg2);
+    if (isQueryKey(arg1Unreffed)) {
+      return super.resetQueries(
+        arg1Unreffed,
+        arg2Unreffed as ResetQueryFilters<TPageData> | undefined,
+        cloneDeepUnref(arg3) as ResetOptions
+      );
+    }
+    return super.resetQueries(
+      arg1Unreffed as ResetQueryFilters<TPageData>,
+      arg2Unreffed as ResetOptions
+    );
+  }
+
+  cancelQueries(
+    filters?: MaybeRefDeep<QueryFilters>,
+    options?: MaybeRefDeep<CancelOptions>
+  ): Promise<void>;
+  cancelQueries(
+    queryKey?: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<QueryFilters>,
+    options?: MaybeRefDeep<CancelOptions>
+  ): Promise<void>;
+  cancelQueries(
+    arg1?: MaybeRefDeep<QueryKey | QueryFilters>,
+    arg2?: MaybeRefDeep<QueryFilters | CancelOptions>,
+    arg3?: MaybeRefDeep<CancelOptions>
+  ): Promise<void> {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    const arg2Unreffed = cloneDeepUnref(arg2);
+    if (isQueryKey(arg1Unreffed)) {
+      return super.cancelQueries(
+        arg1Unreffed,
+        arg2Unreffed as QueryFilters | undefined,
+        cloneDeepUnref(arg3) as CancelOptions
+      );
+    }
+    return super.cancelQueries(
+      arg1Unreffed as QueryFilters,
+      arg2Unreffed as CancelOptions
+    );
+  }
+
+  invalidateQueries<TPageData = unknown>(
+    filters?: MaybeRefDeep<InvalidateQueryFilters<TPageData>>,
+    options?: MaybeRefDeep<InvalidateOptions>
+  ): Promise<void>;
+  invalidateQueries<TPageData = unknown>(
+    queryKey?: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<InvalidateQueryFilters<TPageData>>,
+    options?: MaybeRefDeep<InvalidateOptions>
+  ): Promise<void>;
+  invalidateQueries<TPageData = unknown>(
+    arg1?: MaybeRefDeep<QueryKey | InvalidateQueryFilters<TPageData>>,
+    arg2?: MaybeRefDeep<InvalidateQueryFilters<TPageData> | InvalidateOptions>,
+    arg3?: MaybeRefDeep<InvalidateOptions>
+  ): Promise<void> {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    const arg2Unreffed = cloneDeepUnref(arg2);
+    if (isQueryKey(arg1Unreffed)) {
+      return super.invalidateQueries(
+        arg1Unreffed,
+        arg2Unreffed as InvalidateQueryFilters | undefined,
+        cloneDeepUnref(arg3) as InvalidateOptions
+      );
+    }
+    return super.invalidateQueries(
+      arg1Unreffed as InvalidateQueryFilters<TPageData>,
+      arg2Unreffed as InvalidateOptions
+    );
+  }
+
+  refetchQueries<TPageData = unknown>(
+    filters?: MaybeRefDeep<RefetchQueryFilters<TPageData>>,
+    options?: MaybeRefDeep<RefetchOptions>
+  ): Promise<void>;
+  refetchQueries<TPageData = unknown>(
+    queryKey?: MaybeRefDeep<QueryKey>,
+    filters?: MaybeRefDeep<RefetchQueryFilters<TPageData>>,
+    options?: MaybeRefDeep<RefetchOptions>
+  ): Promise<void>;
+  refetchQueries<TPageData = unknown>(
+    arg1?: MaybeRefDeep<QueryKey | RefetchQueryFilters<TPageData>>,
+    arg2?: MaybeRefDeep<RefetchQueryFilters<TPageData> | RefetchOptions>,
+    arg3?: MaybeRefDeep<RefetchOptions>
+  ): Promise<void> {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    const arg2Unreffed = cloneDeepUnref(arg2);
+    if (isQueryKey(arg1Unreffed)) {
+      return super.refetchQueries(
+        arg1Unreffed,
+        arg2Unreffed as RefetchQueryFilters | undefined,
+        cloneDeepUnref(arg3) as RefetchOptions
+      );
+    }
+    return super.refetchQueries(
+      arg1Unreffed as RefetchQueryFilters<TPageData>,
+      arg2Unreffed as RefetchOptions
+    );
+  }
+
+  fetchQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    options: MaybeRefDeep<
+      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<TData>;
+  fetchQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    queryKey: MaybeRefDeep<TQueryKey>,
+    options?: MaybeRefDeep<
+      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<TData>;
+  fetchQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    queryKey: MaybeRefDeep<TQueryKey>,
+    queryFn: QueryFunction<TQueryFnData, TQueryKey>,
+    options?: MaybeRefDeep<
+      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<TData>;
+  fetchQuery<
+    TQueryFnData,
+    TError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    arg1:
+      | MaybeRefDeep<TQueryKey>
+      | MaybeRefDeep<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>>,
+    arg2?:
+      | QueryFunction<TQueryFnData, TQueryKey>
+      | MaybeRefDeep<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>>,
+    arg3?: MaybeRefDeep<
+      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<TData> {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    const arg2Unreffed = cloneDeepUnref(arg2);
+    if (isQueryKey(arg1Unreffed)) {
+      return super.fetchQuery(
+        arg1Unreffed as TQueryKey,
+        arg2Unreffed as QueryFunction<TQueryFnData, TQueryKey>,
+        cloneDeepUnref(arg3) as FetchQueryOptions<
+          TQueryFnData,
+          TError,
+          TData,
+          TQueryKey
+        >
+      );
+    }
+    return super.fetchQuery(
+      arg1Unreffed as FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    );
+  }
+
+  prefetchQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    options: MaybeRefDeep<
+      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<void>;
+  prefetchQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    queryKey: MaybeRefDeep<TQueryKey>,
+    options?: MaybeRefDeep<
+      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<void>;
+  prefetchQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    queryKey: MaybeRefDeep<TQueryKey>,
+    queryFn: QueryFunction<TQueryFnData, TQueryKey>,
+    options?: MaybeRefDeep<
+      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<void>;
+  prefetchQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    arg1: MaybeRefDeep<
+      TQueryKey | FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >,
+    arg2?:
+      | QueryFunction<TQueryFnData, TQueryKey>
+      | MaybeRefDeep<FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>>,
+    arg3?: MaybeRefDeep<
+      FetchQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<void> {
+    return super.prefetchQuery(
+      cloneDeepUnref(arg1) as any,
+      cloneDeepUnref(arg2) as any,
+      cloneDeepUnref(arg3) as any
+    );
+  }
+
+  fetchInfiniteQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    options: MaybeRefDeep<
+      FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<InfiniteData<TData>>;
+  fetchInfiniteQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    queryKey: MaybeRefDeep<TQueryKey>,
+    options?: MaybeRefDeep<
+      FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<InfiniteData<TData>>;
+  fetchInfiniteQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    queryKey: MaybeRefDeep<TQueryKey>,
+    queryFn: QueryFunction<TQueryFnData, TQueryKey>,
+    options?: MaybeRefDeep<
+      FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<InfiniteData<TData>>;
+  fetchInfiniteQuery<
+    TQueryFnData,
+    TError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    arg1: MaybeRefDeep<
+      | TQueryKey
+      | FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >,
+    arg2?:
+      | QueryFunction<TQueryFnData, TQueryKey>
+      | MaybeRefDeep<
+          FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+        >,
+    arg3?: MaybeRefDeep<
+      FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<InfiniteData<TData>> {
+    const arg1Unreffed = cloneDeepUnref(arg1);
+    const arg2Unreffed = cloneDeepUnref(arg2);
+    if (isQueryKey(arg1Unreffed)) {
+      return super.fetchInfiniteQuery(
+        arg1Unreffed as TQueryKey,
+        arg2Unreffed as QueryFunction<TQueryFnData, TQueryKey>,
+        cloneDeepUnref(arg3) as FetchInfiniteQueryOptions<
+          TQueryFnData,
+          TError,
+          TData,
+          TQueryKey
+        >
+      );
+    }
+    return super.fetchInfiniteQuery(
+      arg1Unreffed as FetchInfiniteQueryOptions<
+        TQueryFnData,
+        TError,
+        TData,
+        TQueryKey
+      >
+    );
+  }
+
+  prefetchInfiniteQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    options: MaybeRefDeep<
+      FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<void>;
+  prefetchInfiniteQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    queryKey: MaybeRefDeep<TQueryKey>,
+    options?: MaybeRefDeep<
+      FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<void>;
+  prefetchInfiniteQuery<
+    TQueryFnData = unknown,
+    TError = unknown,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    queryKey: MaybeRefDeep<TQueryKey>,
+    queryFn: QueryFunction<TQueryFnData, TQueryKey>,
+    options?: MaybeRefDeep<
+      FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<void>;
+  prefetchInfiniteQuery<
+    TQueryFnData,
+    TError,
+    TData = TQueryFnData,
+    TQueryKey extends QueryKey = QueryKey
+  >(
+    arg1: MaybeRefDeep<
+      | TQueryKey
+      | FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >,
+    arg2?:
+      | QueryFunction<TQueryFnData, TQueryKey>
+      | MaybeRefDeep<
+          FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+        >,
+    arg3?: MaybeRefDeep<
+      FetchInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey>
+    >
+  ): Promise<void> {
+    return super.prefetchInfiniteQuery(
+      cloneDeepUnref(arg1) as any,
+      cloneDeepUnref(arg2) as any,
+      cloneDeepUnref(arg3) as any
+    );
+  }
+
+  setDefaultOptions(options: MaybeRefDeep<DefaultOptions>): void {
+    super.setDefaultOptions(cloneDeepUnref(options) as DefaultOptions);
+  }
+
+  setQueryDefaults(
+    queryKey: MaybeRefDeep<QueryKey>,
+    options: MaybeRefDeep<QueryObserverOptions<any, any, any, any>>
+  ): void {
+    super.setQueryDefaults(
+      cloneDeepUnref(queryKey),
+      cloneDeepUnref(options) as any
+    );
+  }
+
+  getQueryDefaults(
+    queryKey?: MaybeRefDeep<QueryKey>
+  ): QueryObserverOptions<any, any, any, any, any> | undefined {
+    return super.getQueryDefaults(cloneDeepUnref(queryKey));
+  }
+
+  setMutationDefaults(
+    mutationKey: MaybeRefDeep<MutationKey>,
+    options: MaybeRefDeep<MutationObserverOptions<any, any, any, any>>
+  ): void {
+    super.setMutationDefaults(
+      cloneDeepUnref(mutationKey),
+      cloneDeepUnref(options) as any
+    );
+  }
+
+  getMutationDefaults(
+    mutationKey?: MaybeRefDeep<MutationKey>
+  ): MutationObserverOptions<any, any, any, any> | undefined {
+    return super.getMutationDefaults(cloneDeepUnref(mutationKey));
+  }
+}
diff --git a/src/vue/types.ts b/src/vue/types.ts
index d483849..56cec7a 100644
--- a/src/vue/types.ts
+++ b/src/vue/types.ts
@@ -6,6 +6,13 @@ import type {
 import { Ref } from "vue-demi";
 
 export type MaybeRef<T> = Ref<T> | T;
+export type MaybeRefDeep<T> = MaybeRef<
+  T extends object
+    ? {
+        [Property in keyof T]: MaybeRefDeep<T[Property]>;
+      }
+    : T
+>;
 
 export type WithQueryClientKey<T> = T & { queryClientKey?: string };