@tanstack/solid-query 5.71.7 → 5.71.9

package/build/dev.cjs

@@ -5,7 +5,7 @@ var solidJs = require('solid-js');
 var web = require('solid-js/web');
 var store = require('solid-js/store');
 
-// src/index.ts
+// src/useQuery.ts
 exports.QueryClientContext = solidJs.createContext(void 0);
 exports.useQueryClient = (queryClient) => {
   if (queryClient) {
@@ -305,21 +305,6 @@ function useQuery(options, queryClient) {
     queryClient
   );
 }
-
-// src/queryOptions.ts
-function queryOptions(options) {
-  return options;
-}
-function useIsFetching(filters, queryClient) {
-  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
-  const queryCache = solidJs.createMemo(() => client().getQueryCache());
-  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
-  const unsubscribe = queryCache().subscribe(() => {
-    setFetches(client().isFetching(filters?.()));
-  });
-  solidJs.onCleanup(unsubscribe);
-  return fetches;
-}
 function useInfiniteQuery(options, queryClient) {
   return useBaseQuery(
     solidJs.createMemo(() => options()),
@@ -327,11 +312,6 @@ function useInfiniteQuery(options, queryClient) {
     queryClient
   );
 }
-
-// src/infiniteQueryOptions.ts
-function infiniteQueryOptions(options) {
-  return options;
-}
 function useMutation(options, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const observer = new queryCore.MutationObserver(
@@ -369,43 +349,6 @@ function useMutation(options, queryClient) {
   solidJs.onCleanup(unsubscribe);
   return state;
 }
-function useIsMutating(filters, queryClient) {
-  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
-  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
-  const [mutations, setMutations] = solidJs.createSignal(
-    client().isMutating(filters?.())
-  );
-  const unsubscribe = mutationCache().subscribe((_result) => {
-    setMutations(client().isMutating(filters?.()));
-  });
-  solidJs.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 = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
-  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
-  const [result, setResult] = solidJs.createSignal(
-    getResult(mutationCache(), options())
-  );
-  solidJs.createEffect(() => {
-    const unsubscribe = mutationCache().subscribe(() => {
-      const nextResult = queryCore.replaceEqualDeep(
-        result(),
-        getResult(mutationCache(), options())
-      );
-      if (result() !== nextResult) {
-        setResult(nextResult);
-      }
-    });
-    solidJs.onCleanup(unsubscribe);
-  });
-  return result;
-}
 function useQueries(queriesOptions, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const isRestoring = exports.useIsRestoring();
@@ -523,11 +466,75 @@ function useQueries(queriesOptions, queryClient) {
   solidJs.createRenderEffect(() => setProxyState(getProxies()));
   return proxyState;
 }
+exports.QueryClient = class QueryClient extends queryCore.QueryClient {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+
+// src/queryOptions.ts
+function queryOptions(options) {
+  return options;
+}
+function useIsFetching(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const queryCache = solidJs.createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return fetches;
+}
 
+// src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
+  return options;
+}
+function useIsMutating(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = solidJs.createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  solidJs.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 = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [result, setResult] = solidJs.createSignal(
+    getResult(mutationCache(), options())
+  );
+  solidJs.createEffect(() => {
+    const unsubscribe = mutationCache().subscribe(() => {
+      const nextResult = queryCore.replaceEqualDeep(
+        result(),
+        getResult(mutationCache(), options())
+      );
+      if (result() !== nextResult) {
+        setResult(nextResult);
+      }
+    });
+    solidJs.onCleanup(unsubscribe);
+  });
+  return result;
+}
+
+// src/index.ts
+exports.createQuery = useQuery;
 exports.createInfiniteQuery = useInfiniteQuery;
 exports.createMutation = useMutation;
 exports.createQueries = useQueries;
-exports.createQuery = useQuery;
+
 exports.infiniteQueryOptions = infiniteQueryOptions;
 exports.queryOptions = queryOptions;
 exports.useInfiniteQuery = useInfiniteQuery;

package/build/dev.js

@@ -1,10 +1,10 @@
-import { 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
+// src/useQuery.ts
 var QueryClientContext = createContext(void 0);
 var useQueryClient = (queryClient) => {
   if (queryClient) {
@@ -304,21 +304,6 @@ function useQuery(options, queryClient) {
     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 useInfiniteQuery(options, queryClient) {
   return useBaseQuery(
     createMemo(() => options()),
@@ -326,11 +311,6 @@ function useInfiniteQuery(options, queryClient) {
     queryClient
   );
 }
-
-// src/infiniteQueryOptions.ts
-function infiniteQueryOptions(options) {
-  return options;
-}
 function useMutation(options, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const observer = new MutationObserver(
@@ -368,43 +348,6 @@ function useMutation(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 useQueries(queriesOptions, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const isRestoring = useIsRestoring();
@@ -522,5 +465,73 @@ function useQueries(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, QueryClientContext, QueryClientProvider, useInfiniteQuery as createInfiniteQuery, useMutation as createMutation, useQueries as createQueries, useQuery as createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };
+export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };

package/build/index.cjs

@@ -5,7 +5,7 @@ var solidJs = require('solid-js');
 var web = require('solid-js/web');
 var store = require('solid-js/store');
 
-// src/index.ts
+// src/useQuery.ts
 exports.QueryClientContext = solidJs.createContext(void 0);
 exports.useQueryClient = (queryClient) => {
   if (queryClient) {
@@ -296,21 +296,6 @@ function useQuery(options, queryClient) {
     queryClient
   );
 }
-
-// src/queryOptions.ts
-function queryOptions(options) {
-  return options;
-}
-function useIsFetching(filters, queryClient) {
-  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
-  const queryCache = solidJs.createMemo(() => client().getQueryCache());
-  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
-  const unsubscribe = queryCache().subscribe(() => {
-    setFetches(client().isFetching(filters?.()));
-  });
-  solidJs.onCleanup(unsubscribe);
-  return fetches;
-}
 function useInfiniteQuery(options, queryClient) {
   return useBaseQuery(
     solidJs.createMemo(() => options()),
@@ -318,11 +303,6 @@ function useInfiniteQuery(options, queryClient) {
     queryClient
   );
 }
-
-// src/infiniteQueryOptions.ts
-function infiniteQueryOptions(options) {
-  return options;
-}
 function useMutation(options, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const observer = new queryCore.MutationObserver(
@@ -360,43 +340,6 @@ function useMutation(options, queryClient) {
   solidJs.onCleanup(unsubscribe);
   return state;
 }
-function useIsMutating(filters, queryClient) {
-  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
-  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
-  const [mutations, setMutations] = solidJs.createSignal(
-    client().isMutating(filters?.())
-  );
-  const unsubscribe = mutationCache().subscribe((_result) => {
-    setMutations(client().isMutating(filters?.()));
-  });
-  solidJs.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 = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
-  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
-  const [result, setResult] = solidJs.createSignal(
-    getResult(mutationCache(), options())
-  );
-  solidJs.createEffect(() => {
-    const unsubscribe = mutationCache().subscribe(() => {
-      const nextResult = queryCore.replaceEqualDeep(
-        result(),
-        getResult(mutationCache(), options())
-      );
-      if (result() !== nextResult) {
-        setResult(nextResult);
-      }
-    });
-    solidJs.onCleanup(unsubscribe);
-  });
-  return result;
-}
 function useQueries(queriesOptions, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const isRestoring = exports.useIsRestoring();
@@ -514,11 +457,75 @@ function useQueries(queriesOptions, queryClient) {
   solidJs.createRenderEffect(() => setProxyState(getProxies()));
   return proxyState;
 }
+exports.QueryClient = class QueryClient extends queryCore.QueryClient {
+  constructor(config = {}) {
+    super(config);
+  }
+};
+
+// src/queryOptions.ts
+function queryOptions(options) {
+  return options;
+}
+function useIsFetching(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const queryCache = solidJs.createMemo(() => client().getQueryCache());
+  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(client().isFetching(filters?.()));
+  });
+  solidJs.onCleanup(unsubscribe);
+  return fetches;
+}
 
+// src/infiniteQueryOptions.ts
+function infiniteQueryOptions(options) {
+  return options;
+}
+function useIsMutating(filters, queryClient) {
+  const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [mutations, setMutations] = solidJs.createSignal(
+    client().isMutating(filters?.())
+  );
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(client().isMutating(filters?.()));
+  });
+  solidJs.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 = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
+  const mutationCache = solidJs.createMemo(() => client().getMutationCache());
+  const [result, setResult] = solidJs.createSignal(
+    getResult(mutationCache(), options())
+  );
+  solidJs.createEffect(() => {
+    const unsubscribe = mutationCache().subscribe(() => {
+      const nextResult = queryCore.replaceEqualDeep(
+        result(),
+        getResult(mutationCache(), options())
+      );
+      if (result() !== nextResult) {
+        setResult(nextResult);
+      }
+    });
+    solidJs.onCleanup(unsubscribe);
+  });
+  return result;
+}
+
+// src/index.ts
+exports.createQuery = useQuery;
 exports.createInfiniteQuery = useInfiniteQuery;
 exports.createMutation = useMutation;
 exports.createQueries = useQueries;
-exports.createQuery = useQuery;
+
 exports.infiniteQueryOptions = infiniteQueryOptions;
 exports.queryOptions = queryOptions;
 exports.useInfiniteQuery = useInfiniteQuery;

package/build/index.d.cts

@@ -1,8 +1,36 @@
-import { DefaultError, QueryKey, OmitKeyof, QueryObserverOptions, QueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, DefinedInfiniteQueryObserverResult, MutationObserverOptions, MutateFunction, Override, MutationObserverResult, DataTag, QueryClient, QueryFilters, InfiniteData, MutationFilters, MutationState, Mutation, QueryFunction, ThrowOnError, QueriesPlaceholderDataFunction } from '@tanstack/query-core';
+import { DefaultError, QueryKey, OmitKeyof, InfiniteQueryObserverOptions as InfiniteQueryObserverOptions$1, QueryClient as QueryClient$1, QueryClientConfig as QueryClientConfig$1, DefaultOptions as DefaultOptions$1, QueryObserverOptions as QueryObserverOptions$1, DefinedInfiniteQueryObserverResult, InfiniteQueryObserverResult, QueryObserverResult, DefinedQueryObserverResult, MutationObserverOptions, MutateFunction, Override, MutationObserverResult, DataTag, InfiniteData, QueryFunction, ThrowOnError, QueriesPlaceholderDataFunction, QueryFilters, MutationFilters, MutationState, Mutation } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
 import * as solid_js from 'solid-js';
 import { Accessor, JSX } from 'solid-js';
 
+interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface DefaultOptions<TError = DefaultError> extends DefaultOptions$1<TError> {
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
+}
+interface QueryClientConfig extends QueryClientConfig$1 {
+    defaultOptions?: DefaultOptions;
+}
+declare class QueryClient extends QueryClient$1 {
+    constructor(config?: QueryClientConfig);
+}
+
 interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
     /**
      * Only applicable while rendering queries on the server with streaming.
@@ -72,16 +100,6 @@ declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TDa
 declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
 declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
 
-declare const QueryClientContext: solid_js.Context<(() => QueryClient) | undefined>;
-declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
-type QueryClientProviderProps = {
-    client: QueryClient;
-    children?: JSX.Element;
-};
-declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
-
-declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
-
 type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam> & {
     initialData?: undefined;
 }>;
@@ -101,14 +119,6 @@ declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = I
 
 declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TError, TVariables, TContext>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TContext>;
 
-declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
-
-type MutationStateOptions<TResult = MutationState> = {
-    filters?: MutationFilters;
-    select?: (mutation: Mutation) => TResult;
-};
-declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
-
 type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
     placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
     /**
@@ -184,7 +194,66 @@ declare function useQueries<T extends Array<any>, TCombinedResult extends Querie
     combine?: (result: QueriesResults<T>) => TCombinedResult;
 }>, queryClient?: Accessor<QueryClient>): TCombinedResult;
 
+declare const QueryClientContext: solid_js.Context<(() => QueryClient) | undefined>;
+declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+type QueryClientProviderProps = {
+    client: QueryClient;
+    children?: JSX.Element;
+};
+declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
+
+declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+
+declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+
+type MutationStateOptions<TResult = MutationState> = {
+    filters?: MutationFilters;
+    select?: (mutation: Mutation) => TResult;
+};
+declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
+
 declare const useIsRestoring: () => Accessor<boolean>;
 declare const IsRestoringProvider: solid_js.ContextProviderComponent<Accessor<boolean>>;
 
-export { type UseBaseMutationResult as CreateBaseMutationResult, type UseBaseQueryOptions as CreateBaseQueryOptions, type UseBaseQueryResult as CreateBaseQueryResult, type UseInfiniteQueryOptions as CreateInfiniteQueryOptions, type UseInfiniteQueryResult as CreateInfiniteQueryResult, type UseMutateAsyncFunction as CreateMutateAsyncFunction, type UseMutateFunction as CreateMutateFunction, type UseMutationOptions as CreateMutationOptions, type UseMutationResult as CreateMutationResult, type UseQueryOptions as CreateQueryOptions, type UseQueryResult as CreateQueryResult, type DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult, type DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult, type DefinedUseQueryResult as DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseBaseQueryResult, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, IsRestoringProvider, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type SolidInfiniteQueryOptions, type SolidMutationOptions, type SolidQueryOptions, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, useInfiniteQuery as createInfiniteQuery, useMutation as createMutation, useQueries as createQueries, useQuery as createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };
+/** @deprecated Use UseQueryOptions instead */
+type CreateQueryOptions = UseQueryOptions;
+/** @deprecated Use UseBaseQueryResult instead */
+type CreateBaseQueryResult = UseBaseQueryResult;
+/** @deprecated Use UseQueryResult instead */
+type CreateQueryResult = UseQueryResult;
+/** @deprecated Use DefinedUseBaseQueryResult instead */
+type DefinedCreateBaseQueryResult = DefinedUseBaseQueryResult;
+/** @deprecated Use DefinedUseQueryResult instead */
+type DefinedCreateQueryResult = DefinedUseQueryResult;
+/** @deprecated Use UseInfiniteQueryOptions instead */
+type CreateInfiniteQueryOptions = UseInfiniteQueryOptions;
+/** @deprecated Use UseInfiniteQueryResult instead */
+type CreateInfiniteQueryResult = UseInfiniteQueryResult;
+/** @deprecated Use DefinedUseInfiniteQueryResult instead */
+type DefinedCreateInfiniteQueryResult = DefinedUseInfiniteQueryResult;
+/** @deprecated Use UseMutationOptions instead */
+type CreateMutationOptions = UseMutationOptions;
+/** @deprecated Use UseMutateFunction instead */
+type CreateMutateFunction = UseMutateFunction;
+/** @deprecated Use UseMutateAsyncFunction instead */
+type CreateMutateAsyncFunction = UseMutateAsyncFunction;
+/** @deprecated Use UseBaseMutationResult instead */
+type CreateBaseMutationResult = UseBaseMutationResult;
+/** @deprecated Use UseMutationResult instead */
+type CreateMutationResult = UseMutationResult;
+/** @deprecated Use UseBaseQueryOptions instead */
+type CreateBaseQueryOptions = UseBaseQueryOptions;
+
+/** @deprecated Use useQuery instead */
+declare const createQuery: typeof useQuery;
+
+/** @deprecated Use useInfiniteQuery instead */
+declare const createInfiniteQuery: typeof useInfiniteQuery;
+
+/** @deprecated Use useMutation instead */
+declare const createMutation: typeof useMutation;
+
+/** @deprecated Use useQueries instead */
+declare const createQueries: typeof useQueries;
+
+export { type CreateBaseMutationResult, type CreateBaseQueryOptions, type CreateBaseQueryResult, type CreateInfiniteQueryOptions, type CreateInfiniteQueryResult, type CreateMutateAsyncFunction, type CreateMutateFunction, type CreateMutationOptions, type CreateMutationResult, type CreateQueryOptions, type CreateQueryResult, type DefaultOptions, type DefinedCreateBaseQueryResult, type DefinedCreateInfiniteQueryResult, type DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseBaseQueryResult, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, type InfiniteQueryObserverOptions, IsRestoringProvider, QueryClient, type QueryClientConfig, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type QueryObserverOptions, type SolidInfiniteQueryOptions, type SolidMutationOptions, type SolidQueryOptions, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };

package/build/index.d.ts

@@ -1,8 +1,36 @@
-import { DefaultError, QueryKey, OmitKeyof, QueryObserverOptions, QueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, DefinedInfiniteQueryObserverResult, MutationObserverOptions, MutateFunction, Override, MutationObserverResult, DataTag, QueryClient, QueryFilters, InfiniteData, MutationFilters, MutationState, Mutation, QueryFunction, ThrowOnError, QueriesPlaceholderDataFunction } from '@tanstack/query-core';
+import { DefaultError, QueryKey, OmitKeyof, InfiniteQueryObserverOptions as InfiniteQueryObserverOptions$1, QueryClient as QueryClient$1, QueryClientConfig as QueryClientConfig$1, DefaultOptions as DefaultOptions$1, QueryObserverOptions as QueryObserverOptions$1, DefinedInfiniteQueryObserverResult, InfiniteQueryObserverResult, QueryObserverResult, DefinedQueryObserverResult, MutationObserverOptions, MutateFunction, Override, MutationObserverResult, DataTag, InfiniteData, QueryFunction, ThrowOnError, QueriesPlaceholderDataFunction, QueryFilters, MutationFilters, MutationState, Mutation } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
 import * as solid_js from 'solid-js';
 import { Accessor, JSX } from 'solid-js';
 
+interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface DefaultOptions<TError = DefaultError> extends DefaultOptions$1<TError> {
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
+}
+interface QueryClientConfig extends QueryClientConfig$1 {
+    defaultOptions?: DefaultOptions;
+}
+declare class QueryClient extends QueryClient$1 {
+    constructor(config?: QueryClientConfig);
+}
+
 interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
     /**
      * Only applicable while rendering queries on the server with streaming.
@@ -72,16 +100,6 @@ declare function queryOptions<TQueryFnData = unknown, TError = DefaultError, TDa
 declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
 declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
 
-declare const QueryClientContext: solid_js.Context<(() => QueryClient) | undefined>;
-declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
-type QueryClientProviderProps = {
-    client: QueryClient;
-    children?: JSX.Element;
-};
-declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
-
-declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
-
 type UndefinedInitialDataInfiniteOptions<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam> & {
     initialData?: undefined;
 }>;
@@ -101,14 +119,6 @@ declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = I
 
 declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TError, TVariables, TContext>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TContext>;
 
-declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
-
-type MutationStateOptions<TResult = MutationState> = {
-    filters?: MutationFilters;
-    select?: (mutation: Mutation) => TResult;
-};
-declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
-
 type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
     placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>;
     /**
@@ -184,7 +194,66 @@ declare function useQueries<T extends Array<any>, TCombinedResult extends Querie
     combine?: (result: QueriesResults<T>) => TCombinedResult;
 }>, queryClient?: Accessor<QueryClient>): TCombinedResult;
 
+declare const QueryClientContext: solid_js.Context<(() => QueryClient) | undefined>;
+declare const useQueryClient: (queryClient?: QueryClient) => QueryClient;
+type QueryClientProviderProps = {
+    client: QueryClient;
+    children?: JSX.Element;
+};
+declare const QueryClientProvider: (props: QueryClientProviderProps) => JSX.Element;
+
+declare function useIsFetching(filters?: Accessor<QueryFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+
+declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
+
+type MutationStateOptions<TResult = MutationState> = {
+    filters?: MutationFilters;
+    select?: (mutation: Mutation) => TResult;
+};
+declare function useMutationState<TResult = MutationState>(options?: Accessor<MutationStateOptions<TResult>>, queryClient?: Accessor<QueryClient>): Accessor<Array<TResult>>;
+
 declare const useIsRestoring: () => Accessor<boolean>;
 declare const IsRestoringProvider: solid_js.ContextProviderComponent<Accessor<boolean>>;
 
-export { type UseBaseMutationResult as CreateBaseMutationResult, type UseBaseQueryOptions as CreateBaseQueryOptions, type UseBaseQueryResult as CreateBaseQueryResult, type UseInfiniteQueryOptions as CreateInfiniteQueryOptions, type UseInfiniteQueryResult as CreateInfiniteQueryResult, type UseMutateAsyncFunction as CreateMutateAsyncFunction, type UseMutateFunction as CreateMutateFunction, type UseMutationOptions as CreateMutationOptions, type UseMutationResult as CreateMutationResult, type UseQueryOptions as CreateQueryOptions, type UseQueryResult as CreateQueryResult, type DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult, type DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult, type DefinedUseQueryResult as DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseBaseQueryResult, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, IsRestoringProvider, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type SolidInfiniteQueryOptions, type SolidMutationOptions, type SolidQueryOptions, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, useInfiniteQuery as createInfiniteQuery, useMutation as createMutation, useQueries as createQueries, useQuery as createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };
+/** @deprecated Use UseQueryOptions instead */
+type CreateQueryOptions = UseQueryOptions;
+/** @deprecated Use UseBaseQueryResult instead */
+type CreateBaseQueryResult = UseBaseQueryResult;
+/** @deprecated Use UseQueryResult instead */
+type CreateQueryResult = UseQueryResult;
+/** @deprecated Use DefinedUseBaseQueryResult instead */
+type DefinedCreateBaseQueryResult = DefinedUseBaseQueryResult;
+/** @deprecated Use DefinedUseQueryResult instead */
+type DefinedCreateQueryResult = DefinedUseQueryResult;
+/** @deprecated Use UseInfiniteQueryOptions instead */
+type CreateInfiniteQueryOptions = UseInfiniteQueryOptions;
+/** @deprecated Use UseInfiniteQueryResult instead */
+type CreateInfiniteQueryResult = UseInfiniteQueryResult;
+/** @deprecated Use DefinedUseInfiniteQueryResult instead */
+type DefinedCreateInfiniteQueryResult = DefinedUseInfiniteQueryResult;
+/** @deprecated Use UseMutationOptions instead */
+type CreateMutationOptions = UseMutationOptions;
+/** @deprecated Use UseMutateFunction instead */
+type CreateMutateFunction = UseMutateFunction;
+/** @deprecated Use UseMutateAsyncFunction instead */
+type CreateMutateAsyncFunction = UseMutateAsyncFunction;
+/** @deprecated Use UseBaseMutationResult instead */
+type CreateBaseMutationResult = UseBaseMutationResult;
+/** @deprecated Use UseMutationResult instead */
+type CreateMutationResult = UseMutationResult;
+/** @deprecated Use UseBaseQueryOptions instead */
+type CreateBaseQueryOptions = UseBaseQueryOptions;
+
+/** @deprecated Use useQuery instead */
+declare const createQuery: typeof useQuery;
+
+/** @deprecated Use useInfiniteQuery instead */
+declare const createInfiniteQuery: typeof useInfiniteQuery;
+
+/** @deprecated Use useMutation instead */
+declare const createMutation: typeof useMutation;
+
+/** @deprecated Use useQueries instead */
+declare const createQueries: typeof useQueries;
+
+export { type CreateBaseMutationResult, type CreateBaseQueryOptions, type CreateBaseQueryResult, type CreateInfiniteQueryOptions, type CreateInfiniteQueryResult, type CreateMutateAsyncFunction, type CreateMutateFunction, type CreateMutationOptions, type CreateMutationResult, type CreateQueryOptions, type CreateQueryResult, type DefaultOptions, type DefinedCreateBaseQueryResult, type DefinedCreateInfiniteQueryResult, type DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseBaseQueryResult, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, type InfiniteQueryObserverOptions, IsRestoringProvider, QueryClient, type QueryClientConfig, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type QueryObserverOptions, type SolidInfiniteQueryOptions, type SolidMutationOptions, type SolidQueryOptions, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };

package/build/index.js

@@ -1,10 +1,10 @@
-import { 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
+// src/useQuery.ts
 var QueryClientContext = createContext(void 0);
 var useQueryClient = (queryClient) => {
   if (queryClient) {
@@ -295,21 +295,6 @@ function useQuery(options, queryClient) {
     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 useInfiniteQuery(options, queryClient) {
   return useBaseQuery(
     createMemo(() => options()),
@@ -317,11 +302,6 @@ function useInfiniteQuery(options, queryClient) {
     queryClient
   );
 }
-
-// src/infiniteQueryOptions.ts
-function infiniteQueryOptions(options) {
-  return options;
-}
 function useMutation(options, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const observer = new MutationObserver(
@@ -359,43 +339,6 @@ function useMutation(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 useQueries(queriesOptions, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const isRestoring = useIsRestoring();
@@ -513,5 +456,73 @@ function useQueries(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, QueryClientContext, QueryClientProvider, useInfiniteQuery as createInfiniteQuery, useMutation as createMutation, useQueries as createQueries, useQuery as createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, 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.7",
+  "version": "5.71.9",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
   "author": "tannerlinsley",
   "license": "MIT",

package/src/QueryClient.ts

@@ -0,0 +1,85 @@
+import { QueryClient as QueryCoreClient } from '@tanstack/query-core'
+import type {
+  DefaultOptions as CoreDefaultOptions,
+  DefaultError,
+  OmitKeyof,
+  QueryClientConfig as QueryCoreClientConfig,
+  InfiniteQueryObserverOptions as QueryCoreInfiniteQueryObserverOptions,
+  QueryObserverOptions as QueryCoreObserverOptions,
+  QueryKey,
+} from '@tanstack/query-core'
+
+export interface QueryObserverOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = never,
+> extends OmitKeyof<
+    QueryCoreObserverOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryData,
+      TQueryKey,
+      TPageParam
+    >,
+    'structuralSharing'
+  > {
+  /**
+   * Set this to a reconciliation key to enable reconciliation between query results.
+   * Set this to `false` to disable reconciliation between query results.
+   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+   * Defaults reconciliation to false.
+   */
+  reconcile?:
+    | string
+    | false
+    | ((oldData: TData | undefined, newData: TData) => TData)
+}
+
+export interface InfiniteQueryObserverOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> extends OmitKeyof<
+    QueryCoreInfiniteQueryObserverOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryData,
+      TQueryKey,
+      TPageParam
+    >,
+    'structuralSharing'
+  > {
+  /**
+   * Set this to a reconciliation key to enable reconciliation between query results.
+   * Set this to `false` to disable reconciliation between query results.
+   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+   * Defaults reconciliation to false.
+   */
+  reconcile?:
+    | string
+    | false
+    | ((oldData: TData | undefined, newData: TData) => TData)
+}
+
+export interface DefaultOptions<TError = DefaultError>
+  extends CoreDefaultOptions<TError> {
+  queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>
+}
+
+export interface QueryClientConfig extends QueryCoreClientConfig {
+  defaultOptions?: DefaultOptions
+}
+
+export class QueryClient extends QueryCoreClient {
+  constructor(config: QueryClientConfig = {}) {
+    super(config)
+  }
+}

package/src/QueryClientProvider.tsx

@@ -4,8 +4,7 @@ import {
   onCleanup,
   useContext,
 } from 'solid-js'
-import type { QueryClient } from '@tanstack/query-core'
-
+import type { QueryClient } from './QueryClient'
 import type { JSX } from 'solid-js'
 
 export const QueryClientContext = createContext<

package/src/index.ts

@@ -1,5 +1,27 @@
 /* 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'
 
@@ -7,45 +29,65 @@ export * from '@tanstack/query-core'
 export * from './types'
 
 export type {
-  UseQueryOptions,
-  UseBaseQueryResult,
-  UseQueryResult,
   DefinedUseBaseQueryResult,
+  DefinedUseInfiniteQueryResult,
   DefinedUseQueryResult,
+  SolidInfiniteQueryOptions,
+  SolidMutationOptions,
+  SolidQueryOptions,
+  UseBaseMutationResult,
+  UseBaseQueryOptions,
+  UseBaseQueryResult,
   UseInfiniteQueryOptions,
   UseInfiniteQueryResult,
-  DefinedUseInfiniteQueryResult,
-  UseMutationOptions,
-  UseMutateFunction,
   UseMutateAsyncFunction,
-  UseBaseMutationResult,
+  UseMutateFunction,
+  UseMutationOptions,
   UseMutationResult,
-  UseBaseQueryOptions,
-  SolidQueryOptions,
-  SolidInfiniteQueryOptions,
-  SolidMutationOptions,
+  UseQueryOptions,
+  UseQueryResult,
 } from './types'
 
-// Compatibility types
-export type {
-  UseQueryOptions as CreateQueryOptions,
-  UseBaseQueryResult as CreateBaseQueryResult,
-  UseQueryResult as CreateQueryResult,
-  DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult,
-  DefinedUseQueryResult as DefinedCreateQueryResult,
-  UseInfiniteQueryOptions as CreateInfiniteQueryOptions,
-  UseInfiniteQueryResult as CreateInfiniteQueryResult,
-  DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult,
-  UseMutationOptions as CreateMutationOptions,
-  UseMutateFunction as CreateMutateFunction,
-  UseMutateAsyncFunction as CreateMutateAsyncFunction,
-  UseBaseMutationResult as CreateBaseMutationResult,
-  UseMutationResult as CreateMutationResult,
-  UseBaseQueryOptions as CreateBaseQueryOptions,
-} 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,
+  DefaultOptions,
+  QueryClientConfig,
+  InfiniteQueryObserverOptions,
+} from './QueryClient'
 export { useQuery } from './useQuery'
-export { useQuery as createQuery } from './useQuery'
+/** @deprecated Use useQuery instead */
+export const createQuery = useQuery
 export { queryOptions } from './queryOptions'
 export type {
   DefinedInitialDataOptions,
@@ -58,17 +100,20 @@ export {
 } from './QueryClientProvider'
 export type { QueryClientProviderProps } from './QueryClientProvider'
 export { useIsFetching } from './useIsFetching'
-export { useInfiniteQuery } from './useInfiniteQuery'
-export { useInfiniteQuery as createInfiniteQuery } from './useInfiniteQuery'
+export { useInfiniteQuery }
+/** @deprecated Use useInfiniteQuery instead */
+export const createInfiniteQuery = useInfiniteQuery
 export { infiniteQueryOptions } from './infiniteQueryOptions'
 export type {
   DefinedInitialDataInfiniteOptions,
   UndefinedInitialDataInfiniteOptions,
 } from './infiniteQueryOptions'
 export { useMutation } from './useMutation'
-export { useMutation as createMutation } from './useMutation'
+/** @deprecated Use useMutation instead */
+export const createMutation = useMutation
 export { useIsMutating } from './useIsMutating'
 export { useMutationState } from './useMutationState'
 export { useQueries } from './useQueries'
-export { useQueries as createQueries } from './useQueries'
+/** @deprecated Use useQueries instead */
+export const createQueries = useQueries
 export { useIsRestoring, IsRestoringProvider } from './isRestoring'

package/src/types.ts

@@ -4,7 +4,6 @@ import type {
   DefaultError,
   DefinedInfiniteQueryObserverResult,
   DefinedQueryObserverResult,
-  InfiniteQueryObserverOptions,
   InfiniteQueryObserverResult,
   MutateFunction,
   MutationObserverOptions,
@@ -12,10 +11,12 @@ import type {
   OmitKeyof,
   Override,
   QueryKey,
-  QueryObserverOptions,
   QueryObserverResult,
 } from '@tanstack/query-core'
-
+import type {
+  InfiniteQueryObserverOptions,
+  QueryObserverOptions,
+} from './QueryClient'
 import type { Accessor } from 'solid-js'
 
 export interface UseBaseQueryOptions<

package/src/useBaseQuery.ts

@@ -17,10 +17,9 @@ import { shouldThrowError } from './utils'
 import { useIsRestoring } from './isRestoring'
 import type { UseBaseQueryOptions } from './types'
 import type { Accessor, Signal } from 'solid-js'
-
+import type { QueryClient } from './QueryClient'
 import type {
   Query,
-  QueryClient,
   QueryKey,
   QueryObserver,
   QueryObserverResult,

package/src/useInfiniteQuery.ts

@@ -4,11 +4,10 @@ import { useBaseQuery } from './useBaseQuery'
 import type {
   DefaultError,
   InfiniteData,
-  QueryClient,
   QueryKey,
   QueryObserver,
 } from '@tanstack/query-core'
-
+import type { QueryClient } from './QueryClient'
 import type {
   DefinedUseInfiniteQueryResult,
   UseInfiniteQueryOptions,

package/src/useIsFetching.ts

@@ -1,6 +1,7 @@
 import { createMemo, createSignal, onCleanup } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
-import type { QueryClient, QueryFilters } from '@tanstack/query-core'
+import type { QueryFilters } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
 import type { Accessor } from 'solid-js'
 
 export function useIsFetching(

package/src/useIsMutating.ts

@@ -1,6 +1,7 @@
 import { createMemo, createSignal, onCleanup } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
-import type { MutationFilters, QueryClient } from '@tanstack/query-core'
+import type { MutationFilters } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
 import type { Accessor } from 'solid-js'
 
 export function useIsMutating(

package/src/useMutation.ts

@@ -3,7 +3,8 @@ import { createComputed, createMemo, on, onCleanup } from 'solid-js'
 import { createStore } from 'solid-js/store'
 import { useQueryClient } from './QueryClientProvider'
 import { noop, shouldThrowError } from './utils'
-import type { DefaultError, QueryClient } from '@tanstack/query-core'
+import type { DefaultError } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
 import type {
   UseMutateFunction,
   UseMutationOptions,

package/src/useMutationState.ts

@@ -6,9 +6,9 @@ import type {
   MutationCache,
   MutationFilters,
   MutationState,
-  QueryClient,
 } from '@tanstack/query-core'
 import type { Accessor } from 'solid-js'
+import type { QueryClient } from './QueryClient'
 
 type MutationStateOptions<TResult = MutationState> = {
   filters?: MutationFilters

package/src/useQueries.ts

@@ -16,12 +16,12 @@ import { useIsRestoring } from './isRestoring'
 import { noop } from './utils'
 import type { SolidQueryOptions, UseQueryResult } from './types'
 import type { Accessor } from 'solid-js'
+import type { QueryClient } from './QueryClient'
 import type {
   DefaultError,
   OmitKeyof,
   QueriesObserverOptions,
   QueriesPlaceholderDataFunction,
-  QueryClient,
   QueryFunction,
   QueryKey,
   QueryObserverOptions,

package/src/useQuery.ts

@@ -1,7 +1,8 @@
 import { QueryObserver } from '@tanstack/query-core'
 import { createMemo } from 'solid-js'
 import { useBaseQuery } from './useBaseQuery'
-import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'
+import type { DefaultError, QueryKey } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
 import type { Accessor } from 'solid-js'
 import type {
   DefinedUseQueryResult,