* Returns the `Query` instance stored under the given `queryHash`, or `undefined` if none * exists. Unlike {@link QueryCache#find}, this looks up b

* Removes all queries from the cache. * * @example * ```ts * const queryCache = queryClient.getQueryCache() * * queryCache.clear()

* Returns the query cache this client is connected to. * * @example * ```ts * import { QueryClient } from '@tanstack/query-core' * *

* A slightly more advanced method that can be used to get an existing query instance from the * cache. This instance not only contains all the stat

* Refetches the observed query and returns a promise that resolves with * the resulting `QueryObserverResult`. * * @example * ```ts * c

* Builds a new `Mutation` in the `MutationCache` using the observer's * current options, detaches this observer from any previously observed * m

* Returns the mutation cache this client is connected to. * * @example * ```ts * import { QueryClient } from '@tanstack/query-core' *

* Returns the most recently computed `QueryObserverResult` for the * observed query. This is a point-in-time read; to be notified of updates * a

@internal

* Cancels outgoing fetches for queries matching the given filters. Most useful when performing * optimistic updates, since any outgoing refetch tha

* Called by a framework adapter's `QueryClientProvider`-equivalent when it mounts, to start * listening for focus/online events and resume paused m

* Called by framework adapters (e.g. inside `useQuery`) to resolve the options passed by the * caller into their final, defaulted form: merging `qu

@internal

* Synchronous way to immediately update a query's cached data. If the updater (or the value * passed) resolves to `undefined`, the cache is left un

* Sets default options for queries whose query key partially matches the given `queryKey`. * * If several registered query defaults match a give

* Returns the existing `Query` instance for the given options' `queryKey`/`queryHash`, or * builds and adds a new one to the cache if none exists y

* Clears the query's garbage collection timeout and silently cancels any * in-flight fetch. Called by `QueryCache` when the query is removed from

* An even more advanced method that can be used to get existing query instances from the cache * that partially match a query key. If no queries ma

* Returns all queries within the cache. * * @example * ```ts * const queryCache = queryClient.getQueryCache() * * const queries = qu

* Computes the result the observer would produce for the given (already-defaulted) options * right now, building the underlying `Query` if it doesn

* Destroys the given `Query` and removes it from the cache, notifying subscribers with a * `'removed'` event. A no-op if the query is no longer the

* The inverse of {@link QueryClient#mount} — called by a framework adapter's * `QueryClientProvider`-equivalent when it unmounts. Only tears down t

* Merges the given partial state directly into this query's state, notifying observers. Used * by persistence and broadcast plugins to restore a st

* Returns the number of observers currently subscribed to this query. * * @example * ```ts * if (query.getObserversCount() === 0) { *

* Imperative (non-reactive) way to retrieve data for a QueryKey. * Should only be used in callbacks or functions where reading the latest data is n

* Marks queries matching the given filters as invalidated. Unlike * {@link QueryClient#removeQueries}, invalidated queries stay in the cache. *

* Refetches queries matching the given filters, regardless of whether they are stale. Without * filters, every query in the cache is refetched. Que

* @deprecated Use queryClient.query(options) instead. This method will be removed in the next major version.

* Resets queries matching the given filters back to their initial state (e.g. any * `initialData`), notifying subscribers rather than removing them

* Runs the mutation function for the given variables through a retryer, and * drives the mutation's state and lifecycle callbacks through to settle

* Imperative (non-reactive) way to retrieve the cached data of multiple queries at once. * Only queries matching the given filters are returned; if

* Imperative (non-reactive) way to retrieve an existing query's state. If the query does not * exist, `undefined` is returned. * * @example

* Removes queries from the cache that match the given filters. Unlike * {@link QueryClient#invalidateQueries} or {@link QueryClient#refetchQueries}

* Fetches the query, i.e. runs its `queryFn` (through any configured * retryer/behavior) and updates the query's state with the result. * - If a

* Recomputes and stores the current result from the current query/options, notifying listeners * if it changed. Framework adapters call this right

* Fetches the next page of the infinite query and returns a promise that * resolves with the resulting `InfiniteQueryObserverResult`. The page *

* Returns the number of queries in the cache that are currently fetching, optionally * matching a set of filters. This includes background-fetching

@internal