@tanstack/solid-query 5.71.8 → 5.71.10

package/build/index.js

@@ -1,15 +1,10 @@
-import { QueryClient as QueryClient$1, MutationObserver, replaceEqualDeep, QueriesObserver, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
+import { MutationObserver, QueriesObserver, QueryClient as QueryClient$1, replaceEqualDeep, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
-import { createContext, useContext, createRenderEffect, onCleanup, createMemo, createSignal, createComputed, on, createEffect, mergeProps, createResource, batch, onMount } from 'solid-js';
+import { createContext, useContext, createRenderEffect, onCleanup, createMemo, createComputed, on, mergeProps, createResource, batch, onMount, createSignal, createEffect } from 'solid-js';
 import { createComponent, isServer } from 'solid-js/web';
 import { createStore, unwrap, reconcile } from 'solid-js/store';
 
-// src/index.ts
-var QueryClient = class extends QueryClient$1 {
-  constructor(config = {}) {
-    super(config);
-  }
-};
+// src/useQuery.ts
 var QueryClientContext = createContext(void 0);
 var useQueryClient = (queryClient) => {
   if (queryClient) {
@@ -49,7 +44,7 @@ var IsRestoringContext = createContext(() => false);
 var useIsRestoring = () => useContext(IsRestoringContext);
 var IsRestoringProvider = IsRestoringContext.Provider;
 
-// src/createBaseQuery.ts
+// src/useBaseQuery.ts
 function reconcileFn(store, result, reconcileOption, queryHash) {
   if (reconcileOption === false) return result;
   if (typeof reconcileOption === "function") {
@@ -86,7 +81,7 @@ var hydratableObserverResult = (query, result) => {
   };
   return obj;
 };
-function createBaseQuery(options, Observer, queryClient) {
+function useBaseQuery(options, Observer, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const isRestoring = useIsRestoring();
   let unsubscribeQueued = false;
@@ -292,42 +287,22 @@ function createBaseQuery(options, Observer, queryClient) {
   return new Proxy(state, handler);
 }
 
-// src/createQuery.ts
-function createQuery(options, queryClient) {
-  return createBaseQuery(
+// src/useQuery.ts
+function useQuery(options, queryClient) {
+  return useBaseQuery(
     createMemo(() => options()),
     QueryObserver,
     queryClient
   );
 }
-
-// src/queryOptions.ts
-function queryOptions(options) {
-  return options;
-}
-function useIsFetching(filters, queryClient) {
-  const client = createMemo(() => useQueryClient(queryClient?.()));
-  const queryCache = createMemo(() => client().getQueryCache());
-  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
-  const unsubscribe = queryCache().subscribe(() => {
-    setFetches(client().isFetching(filters?.()));
-  });
-  onCleanup(unsubscribe);
-  return fetches;
-}
-function createInfiniteQuery(options, queryClient) {
-  return createBaseQuery(
+function useInfiniteQuery(options, queryClient) {
+  return useBaseQuery(
     createMemo(() => options()),
     InfiniteQueryObserver,
     queryClient
   );
 }
-
-// src/infiniteQueryOptions.ts
-function infiniteQueryOptions(options) {
-  return options;
-}
-function createMutation(options, queryClient) {
+function useMutation(options, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const observer = new MutationObserver(
     client(),
@@ -364,44 +339,7 @@ function createMutation(options, queryClient) {
   onCleanup(unsubscribe);
   return state;
 }
-function useIsMutating(filters, queryClient) {
-  const client = createMemo(() => useQueryClient(queryClient?.()));
-  const mutationCache = createMemo(() => client().getMutationCache());
-  const [mutations, setMutations] = createSignal(
-    client().isMutating(filters?.())
-  );
-  const unsubscribe = mutationCache().subscribe((_result) => {
-    setMutations(client().isMutating(filters?.()));
-  });
-  onCleanup(unsubscribe);
-  return mutations;
-}
-function getResult(mutationCache, options) {
-  return mutationCache.findAll(options.filters).map(
-    (mutation) => options.select ? options.select(mutation) : mutation.state
-  );
-}
-function useMutationState(options = () => ({}), queryClient) {
-  const client = createMemo(() => useQueryClient(queryClient?.()));
-  const mutationCache = createMemo(() => client().getMutationCache());
-  const [result, setResult] = createSignal(
-    getResult(mutationCache(), options())
-  );
-  createEffect(() => {
-    const unsubscribe = mutationCache().subscribe(() => {
-      const nextResult = replaceEqualDeep(
-        result(),
-        getResult(mutationCache(), options())
-      );
-      if (result() !== nextResult) {
-        setResult(nextResult);
-      }
-    });
-    onCleanup(unsubscribe);
-  });
-  return result;
-}
-function createQueries(queriesOptions, queryClient) {
+function useQueries(queriesOptions, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const isRestoring = useIsRestoring();
   const defaultedQueries = createMemo(
@@ -518,5 +456,73 @@ function createQueries(queriesOptions, queryClient) {
   createRenderEffect(() => setProxyState(getProxies()));
   return proxyState;
 }
+var QueryClient = class extends QueryClient$1 {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+
+// src/queryOptions.ts
+function queryOptions(options) {
+  return options;
+}
+function useIsFetching(filters, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const queryCache = createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  onCleanup(unsubscribe);
+  return fetches;
+}
+
+// src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
+  return options;
+}
+function useIsMutating(filters, queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const mutationCache = createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  onCleanup(unsubscribe);
+  return mutations;
+}
+function getResult(mutationCache, options) {
+  return mutationCache.findAll(options.filters).map(
+    (mutation) => options.select ? options.select(mutation) : mutation.state
+  );
+}
+function useMutationState(options = () => ({}), queryClient) {
+  const client = createMemo(() => useQueryClient(queryClient?.()));
+  const mutationCache = createMemo(() => client().getMutationCache());
+  const [result, setResult] = createSignal(
+    getResult(mutationCache(), options())
+  );
+  createEffect(() => {
+    const unsubscribe = mutationCache().subscribe(() => {
+      const nextResult = replaceEqualDeep(
+        result(),
+        getResult(mutationCache(), options())
+      );
+      if (result() !== nextResult) {
+        setResult(nextResult);
+      }
+    });
+    onCleanup(unsubscribe);
+  });
+  return result;
+}
+
+// src/index.ts
+var createQuery = useQuery;
+var createInfiniteQuery = useInfiniteQuery;
+var createMutation = useMutation;
+var createQueries = useQueries;
 
-export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useIsFetching, useIsMutating, useIsRestoring, useMutationState, useQueryClient };
+export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-query",
-  "version": "5.71.8",
+  "version": "5.71.10",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -45,7 +45,7 @@
     "!src/__tests__"
   ],
   "dependencies": {
-    "@tanstack/query-core": "5.71.5"
+    "@tanstack/query-core": "5.71.10"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",

package/src/index.ts

@@ -1,10 +1,83 @@
 /* istanbul ignore file */
 
+import { useQuery } from './useQuery'
+import { useInfiniteQuery } from './useInfiniteQuery'
+import { useMutation } from './useMutation'
+import { useQueries } from './useQueries'
+
+import type {
+  DefinedUseBaseQueryResult,
+  DefinedUseInfiniteQueryResult,
+  DefinedUseQueryResult,
+  UseBaseMutationResult,
+  UseBaseQueryOptions,
+  UseBaseQueryResult,
+  UseInfiniteQueryOptions,
+  UseInfiniteQueryResult,
+  UseMutateAsyncFunction,
+  UseMutateFunction,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult,
+} from './types'
+
 // Re-export core
 export * from '@tanstack/query-core'
 
 // Solid Query
 export * from './types'
+
+export type {
+  DefinedUseBaseQueryResult,
+  DefinedUseInfiniteQueryResult,
+  DefinedUseQueryResult,
+  SolidInfiniteQueryOptions,
+  SolidMutationOptions,
+  SolidQueryOptions,
+  UseBaseMutationResult,
+  UseBaseQueryOptions,
+  UseBaseQueryResult,
+  UseInfiniteQueryOptions,
+  UseInfiniteQueryResult,
+  UseMutateAsyncFunction,
+  UseMutateFunction,
+  UseMutationOptions,
+  UseMutationResult,
+  UseQueryOptions,
+  UseQueryResult,
+} from './types'
+
+// Compatibility types (deprecated)
+/** @deprecated Use UseQueryOptions instead */
+export type CreateQueryOptions = UseQueryOptions
+/** @deprecated Use UseBaseQueryResult instead */
+export type CreateBaseQueryResult = UseBaseQueryResult
+/** @deprecated Use UseQueryResult instead */
+export type CreateQueryResult = UseQueryResult
+/** @deprecated Use DefinedUseBaseQueryResult instead */
+export type DefinedCreateBaseQueryResult = DefinedUseBaseQueryResult
+/** @deprecated Use DefinedUseQueryResult instead */
+export type DefinedCreateQueryResult = DefinedUseQueryResult
+/** @deprecated Use UseInfiniteQueryOptions instead */
+export type CreateInfiniteQueryOptions = UseInfiniteQueryOptions
+/** @deprecated Use UseInfiniteQueryResult instead */
+export type CreateInfiniteQueryResult = UseInfiniteQueryResult
+/** @deprecated Use DefinedUseInfiniteQueryResult instead */
+export type DefinedCreateInfiniteQueryResult = DefinedUseInfiniteQueryResult
+/** @deprecated Use UseMutationOptions instead */
+export type CreateMutationOptions = UseMutationOptions
+/** @deprecated Use UseMutateFunction instead */
+export type CreateMutateFunction = UseMutateFunction
+/** @deprecated Use UseMutateAsyncFunction instead */
+export type CreateMutateAsyncFunction = UseMutateAsyncFunction
+/** @deprecated Use UseBaseMutationResult instead */
+export type CreateBaseMutationResult = UseBaseMutationResult
+/** @deprecated Use UseMutationResult instead */
+export type CreateMutationResult = UseMutationResult
+/** @deprecated Use UseBaseQueryOptions instead */
+export type CreateBaseQueryOptions = UseBaseQueryOptions
+
 export { QueryClient } from './QueryClient'
 export type {
   QueryObserverOptions,
@@ -12,7 +85,9 @@ export type {
   QueryClientConfig,
   InfiniteQueryObserverOptions,
 } from './QueryClient'
-export { createQuery } from './createQuery'
+export { useQuery } from './useQuery'
+/** @deprecated Use useQuery instead */
+export const createQuery = useQuery
 export { queryOptions } from './queryOptions'
 export type {
   DefinedInitialDataOptions,
@@ -25,14 +100,20 @@ export {
 } from './QueryClientProvider'
 export type { QueryClientProviderProps } from './QueryClientProvider'
 export { useIsFetching } from './useIsFetching'
-export { createInfiniteQuery } from './createInfiniteQuery'
+export { useInfiniteQuery }
+/** @deprecated Use useInfiniteQuery instead */
+export const createInfiniteQuery = useInfiniteQuery
 export { infiniteQueryOptions } from './infiniteQueryOptions'
 export type {
   DefinedInitialDataInfiniteOptions,
   UndefinedInitialDataInfiniteOptions,
 } from './infiniteQueryOptions'
-export { createMutation } from './createMutation'
+export { useMutation } from './useMutation'
+/** @deprecated Use useMutation instead */
+export const createMutation = useMutation
 export { useIsMutating } from './useIsMutating'
 export { useMutationState } from './useMutationState'
-export { createQueries } from './createQueries'
+export { useQueries } from './useQueries'
+/** @deprecated Use useQueries instead */
+export const createQueries = useQueries
 export { useIsRestoring, IsRestoringProvider } from './isRestoring'

package/src/types.ts

@@ -19,7 +19,7 @@ import type {
 } from './QueryClient'
 import type { Accessor } from 'solid-js'
 
-export interface CreateBaseQueryOptions<
+export interface UseBaseQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -38,7 +38,7 @@ export interface CreateBaseQueryOptions<
   deferStream?: boolean
   /**
    * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
-   * The `data` property on createQuery is a SolidJS resource and will automatically suspend when the data is loading.
+   * The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
    * Setting `suspense` to `false` will be a no-op.
    */
   suspense?: boolean
@@ -49,7 +49,7 @@ export interface SolidQueryOptions<
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> extends CreateBaseQueryOptions<
+> extends UseBaseQueryOptions<
     TQueryFnData,
     TError,
     TData,
@@ -57,7 +57,7 @@ export interface SolidQueryOptions<
     TQueryKey
   > {}
 
-export type CreateQueryOptions<
+export type UseQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -66,25 +66,25 @@ export type CreateQueryOptions<
 
 /* --- Create Query and Create Base Query  Types --- */
 
-export type CreateBaseQueryResult<
+export type UseBaseQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = QueryObserverResult<TData, TError>
 
-export type CreateQueryResult<
+export type UseQueryResult<
   TData = unknown,
   TError = DefaultError,
-> = CreateBaseQueryResult<TData, TError>
+> = UseBaseQueryResult<TData, TError>
 
-export type DefinedCreateBaseQueryResult<
+export type DefinedUseBaseQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = DefinedQueryObserverResult<TData, TError>
 
-export type DefinedCreateQueryResult<
+export type DefinedUseQueryResult<
   TData = unknown,
   TError = DefaultError,
-> = DefinedCreateBaseQueryResult<TData, TError>
+> = DefinedUseBaseQueryResult<TData, TError>
 
 /* --- Create Infinite Queries Types --- */
 export interface SolidInfiniteQueryOptions<
@@ -115,13 +115,13 @@ export interface SolidInfiniteQueryOptions<
   deferStream?: boolean
   /**
    * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
-   * The `data` property on createInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
+   * The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
    * Setting `suspense` to `false` will be a no-op.
    */
   suspense?: boolean
 }
 
-export type CreateInfiniteQueryOptions<
+export type UseInfiniteQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -138,12 +138,12 @@ export type CreateInfiniteQueryOptions<
   >
 >
 
-export type CreateInfiniteQueryResult<
+export type UseInfiniteQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = InfiniteQueryObserverResult<TData, TError>
 
-export type DefinedCreateInfiniteQueryResult<
+export type DefinedUseInfiniteQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = DefinedInfiniteQueryObserverResult<TData, TError>
@@ -159,14 +159,14 @@ export interface SolidMutationOptions<
     '_defaulted'
   > {}
 
-export type CreateMutationOptions<
+export type UseMutationOptions<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 > = Accessor<SolidMutationOptions<TData, TError, TVariables, TContext>>
 
-export type CreateMutateFunction<
+export type UseMutateFunction<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
@@ -175,28 +175,28 @@ export type CreateMutateFunction<
   ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>
 ) => void
 
-export type CreateMutateAsyncFunction<
+export type UseMutateAsyncFunction<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 > = MutateFunction<TData, TError, TVariables, TContext>
 
-export type CreateBaseMutationResult<
+export type UseBaseMutationResult<
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
   TContext = unknown,
 > = Override<
   MutationObserverResult<TData, TError, TVariables, TContext>,
-  { mutate: CreateMutateFunction<TData, TError, TVariables, TContext> }
+  { mutate: UseMutateFunction<TData, TError, TVariables, TContext> }
 > & {
-  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>
+  mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>
 }
 
-export type CreateMutationResult<
+export type UseMutationResult<
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
   TContext = unknown,
-> = CreateBaseMutationResult<TData, TError, TVariables, TContext>
+> = UseBaseMutationResult<TData, TError, TVariables, TContext>

package/src/{createBaseQuery.ts → useBaseQuery.ts}

@@ -15,7 +15,7 @@ import { createStore, reconcile, unwrap } from 'solid-js/store'
 import { useQueryClient } from './QueryClientProvider'
 import { shouldThrowError } from './utils'
 import { useIsRestoring } from './isRestoring'
-import type { CreateBaseQueryOptions } from './types'
+import type { UseBaseQueryOptions } from './types'
 import type { Accessor, Signal } from 'solid-js'
 import type { QueryClient } from './QueryClient'
 import type {
@@ -101,7 +101,7 @@ const hydratableObserverResult = <
 }
 
 // Base Query Function that is used to create the query.
-export function createBaseQuery<
+export function useBaseQuery<
   TQueryFnData,
   TError,
   TData,
@@ -109,7 +109,7 @@ export function createBaseQuery<
   TQueryKey extends QueryKey,
 >(
   options: Accessor<
-    CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
+    UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
   >,
   Observer: typeof QueryObserver,
   queryClient?: Accessor<QueryClient>,

package/src/{createInfiniteQuery.ts → useInfiniteQuery.ts}

@@ -1,6 +1,6 @@
 import { InfiniteQueryObserver } from '@tanstack/query-core'
 import { createMemo } from 'solid-js'
-import { createBaseQuery } from './createBaseQuery'
+import { useBaseQuery } from './useBaseQuery'
 import type {
   DefaultError,
   InfiniteData,
@@ -9,9 +9,9 @@ import type {
 } from '@tanstack/query-core'
 import type { QueryClient } from './QueryClient'
 import type {
-  CreateInfiniteQueryOptions,
-  CreateInfiniteQueryResult,
-  DefinedCreateInfiniteQueryResult,
+  DefinedUseInfiniteQueryResult,
+  UseInfiniteQueryOptions,
+  UseInfiniteQueryResult,
 } from './types'
 import type { Accessor } from 'solid-js'
 import type {
@@ -19,7 +19,7 @@ import type {
   UndefinedInitialDataInfiniteOptions,
 } from './infiniteQueryOptions'
 
-export function createInfiniteQuery<
+export function useInfiniteQuery<
   TQueryFnData,
   TError = DefaultError,
   TData = InfiniteData<TQueryFnData>,
@@ -34,8 +34,8 @@ export function createInfiniteQuery<
     TPageParam
   >,
   queryClient?: Accessor<QueryClient>,
-): DefinedCreateInfiniteQueryResult<TData, TError>
-export function createInfiniteQuery<
+): DefinedUseInfiniteQueryResult<TData, TError>
+export function useInfiniteQuery<
   TQueryFnData,
   TError = DefaultError,
   TData = InfiniteData<TQueryFnData>,
@@ -50,16 +50,16 @@ export function createInfiniteQuery<
     TPageParam
   >,
   queryClient?: Accessor<QueryClient>,
-): CreateInfiniteQueryResult<TData, TError>
+): UseInfiniteQueryResult<TData, TError>
 
-export function createInfiniteQuery<
+export function useInfiniteQuery<
   TQueryFnData,
   TError = DefaultError,
   TData = InfiniteData<TQueryFnData>,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 >(
-  options: CreateInfiniteQueryOptions<
+  options: UseInfiniteQueryOptions<
     TQueryFnData,
     TError,
     TData,
@@ -67,10 +67,10 @@ export function createInfiniteQuery<
     TPageParam
   >,
   queryClient?: Accessor<QueryClient>,
-): CreateInfiniteQueryResult<TData, TError> {
-  return createBaseQuery(
+): UseInfiniteQueryResult<TData, TError> {
+  return useBaseQuery(
     createMemo(() => options()),
     InfiniteQueryObserver as typeof QueryObserver,
     queryClient,
-  ) as CreateInfiniteQueryResult<TData, TError>
+  ) as UseInfiniteQueryResult<TData, TError>
 }

package/src/{createMutation.ts → useMutation.ts}

@@ -6,22 +6,22 @@ import { noop, shouldThrowError } from './utils'
 import type { DefaultError } from '@tanstack/query-core'
 import type { QueryClient } from './QueryClient'
 import type {
-  CreateMutateFunction,
-  CreateMutationOptions,
-  CreateMutationResult,
+  UseMutateFunction,
+  UseMutationOptions,
+  UseMutationResult,
 } from './types'
 import type { Accessor } from 'solid-js'
 
 // HOOK
-export function createMutation<
+export function useMutation<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 >(
-  options: CreateMutationOptions<TData, TError, TVariables, TContext>,
+  options: UseMutationOptions<TData, TError, TVariables, TContext>,
   queryClient?: Accessor<QueryClient>,
-): CreateMutationResult<TData, TError, TVariables, TContext> {
+): UseMutationResult<TData, TError, TVariables, TContext> {
   const client = createMemo(() => useQueryClient(queryClient?.()))
 
   const observer = new MutationObserver<TData, TError, TVariables, TContext>(
@@ -29,7 +29,7 @@ export function createMutation<
     options(),
   )
 
-  const mutate: CreateMutateFunction<TData, TError, TVariables, TContext> = (
+  const mutate: UseMutateFunction<TData, TError, TVariables, TContext> = (
     variables,
     mutateOptions,
   ) => {
@@ -37,7 +37,7 @@ export function createMutation<
   }
 
   const [state, setState] = createStore<
-    CreateMutationResult<TData, TError, TVariables, TContext>
+    UseMutationResult<TData, TError, TVariables, TContext>
   >({
     ...observer.getCurrentResult(),
     mutate,