@tanstack/query-core 5.103.2 → 5.104.0

package/build/modern/subscribable.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"subscribable.cjs","names":[],"sources":["../../src/subscribable.ts"],"sourcesContent":["export class Subscribable<TListener extends Function> {\n  protected listeners = new Set<TListener>()\n\n  constructor() {\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  subscribe(listener: TListener): () => void {\n    this.listeners.add(listener)\n\n    this.onSubscribe()\n\n    return () => {\n      this.listeners.delete(listener)\n      this.onUnsubscribe()\n    }\n  }\n\n  hasListeners(): boolean {\n    return this.listeners.size > 0\n  }\n\n  protected onSubscribe(): void {\n    // Do nothing\n  }\n\n  protected onUnsubscribe(): void {\n    // Do nothing\n  }\n}\n"],"mappings":";;AAAA,IAAa,eAAb,MAAsD;CAGpD,cAAc;EAFQ,KAAA,4BAAA,IAAI,IAAe;EAGvC,KAAK,YAAY,KAAK,UAAU,KAAK,IAAI;CAC3C;CAEA,UAAU,UAAiC;EACzC,KAAK,UAAU,IAAI,QAAQ;EAE3B,KAAK,YAAY;EAEjB,aAAa;GACX,KAAK,UAAU,OAAO,QAAQ;GAC9B,KAAK,cAAc;EACrB;CACF;CAEA,eAAwB;EACtB,OAAO,KAAK,UAAU,OAAO;CAC/B;CAEA,cAA8B,CAE9B;CAEA,gBAAgC,CAEhC;AACF"}
+{"version":3,"file":"subscribable.cjs","names":[],"sources":["../../src/subscribable.ts"],"sourcesContent":["/**\n * The base class behind everything in Query that you can subscribe to: `QueryCache`, `MutationCache`,\n * the observers, and the `FocusManager`/`OnlineManager` behind `focusManager` and `onlineManager`.\n * Subclasses decide what a listener receives and when it is called.\n */\nexport class Subscribable<TListener extends Function> {\n  protected listeners = new Set<TListener>()\n\n  constructor() {\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  /**\n   * Registers a listener to be called on every update this object notifies about. Returns a function\n   * that removes the listener again — call it to stop listening. The base class never drops a listener\n   * on its own, though some subclasses clear all of theirs in `destroy()`.\n   * @param listener - Called on each update, with whatever the subclass passes to its subscribers.\n   * @example\n   * ```ts\n   * const unsubscribe = subscribable.subscribe(() => {\n   *   // react to the update\n   * })\n   *\n   * unsubscribe()\n   * ```\n   */\n  subscribe(listener: TListener): () => void {\n    this.listeners.add(listener)\n\n    this.onSubscribe()\n\n    return () => {\n      this.listeners.delete(listener)\n      this.onUnsubscribe()\n    }\n  }\n\n  /**\n   * Returns `true` while at least one listener is registered, `false` once they have all unsubscribed.\n   */\n  hasListeners(): boolean {\n    return this.listeners.size > 0\n  }\n\n  protected onSubscribe(): void {\n    // Do nothing\n  }\n\n  protected onUnsubscribe(): void {\n    // Do nothing\n  }\n}\n"],"mappings":";;;;;;;AAKA,IAAa,eAAb,MAAsD;CAGpD,cAAc;EAFQ,KAAA,4BAAA,IAAI,IAAe;EAGvC,KAAK,YAAY,KAAK,UAAU,KAAK,IAAI;CAC3C;;;;;;;;;;;;;;;CAgBA,UAAU,UAAiC;EACzC,KAAK,UAAU,IAAI,QAAQ;EAE3B,KAAK,YAAY;EAEjB,aAAa;GACX,KAAK,UAAU,OAAO,QAAQ;GAC9B,KAAK,cAAc;EACrB;CACF;;;;CAKA,eAAwB;EACtB,OAAO,KAAK,UAAU,OAAO;CAC/B;CAEA,cAA8B,CAE9B;CAEA,gBAAgC,CAEhC;AACF"}

package/build/modern/subscribable.d.cts

@@ -1,2 +1,2 @@
-import { t as Subscribable } from "./subscribable-CbifVTKz.cjs";
+import { t as Subscribable } from "./subscribable-CysQ0tne.cjs";
 export { Subscribable };

package/build/modern/subscribable.d.ts

@@ -1,2 +1,2 @@
-import { t as Subscribable } from "./subscribable-CbifVTKz.js";
+import { t as Subscribable } from "./subscribable-CysQ0tne.js";
 export { Subscribable };

package/build/modern/subscribable.js

@@ -1,9 +1,28 @@
 //#region src/subscribable.ts
+/**
+* The base class behind everything in Query that you can subscribe to: `QueryCache`, `MutationCache`,
+* the observers, and the `FocusManager`/`OnlineManager` behind `focusManager` and `onlineManager`.
+* Subclasses decide what a listener receives and when it is called.
+*/
 var Subscribable = class {
 	constructor() {
 		this.listeners = /* @__PURE__ */ new Set();
 		this.subscribe = this.subscribe.bind(this);
 	}
+	/**
+	* Registers a listener to be called on every update this object notifies about. Returns a function
+	* that removes the listener again — call it to stop listening. The base class never drops a listener
+	* on its own, though some subclasses clear all of theirs in `destroy()`.
+	* @param listener - Called on each update, with whatever the subclass passes to its subscribers.
+	* @example
+	* ```ts
+	* const unsubscribe = subscribable.subscribe(() => {
+	*   // react to the update
+	* })
+	*
+	* unsubscribe()
+	* ```
+	*/
 	subscribe(listener) {
 		this.listeners.add(listener);
 		this.onSubscribe();
@@ -12,6 +31,9 @@ var Subscribable = class {
 			this.onUnsubscribe();
 		};
 	}
+	/**
+	* Returns `true` while at least one listener is registered, `false` once they have all unsubscribed.
+	*/
 	hasListeners() {
 		return this.listeners.size > 0;
 	}

package/build/modern/subscribable.js.map

@@ -1 +1 @@
-{"version":3,"file":"subscribable.js","names":[],"sources":["../../src/subscribable.ts"],"sourcesContent":["export class Subscribable<TListener extends Function> {\n  protected listeners = new Set<TListener>()\n\n  constructor() {\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  subscribe(listener: TListener): () => void {\n    this.listeners.add(listener)\n\n    this.onSubscribe()\n\n    return () => {\n      this.listeners.delete(listener)\n      this.onUnsubscribe()\n    }\n  }\n\n  hasListeners(): boolean {\n    return this.listeners.size > 0\n  }\n\n  protected onSubscribe(): void {\n    // Do nothing\n  }\n\n  protected onUnsubscribe(): void {\n    // Do nothing\n  }\n}\n"],"mappings":";AAAA,IAAa,eAAb,MAAsD;CAGpD,cAAc;EAFQ,KAAA,4BAAA,IAAI,IAAe;EAGvC,KAAK,YAAY,KAAK,UAAU,KAAK,IAAI;CAC3C;CAEA,UAAU,UAAiC;EACzC,KAAK,UAAU,IAAI,QAAQ;EAE3B,KAAK,YAAY;EAEjB,aAAa;GACX,KAAK,UAAU,OAAO,QAAQ;GAC9B,KAAK,cAAc;EACrB;CACF;CAEA,eAAwB;EACtB,OAAO,KAAK,UAAU,OAAO;CAC/B;CAEA,cAA8B,CAE9B;CAEA,gBAAgC,CAEhC;AACF"}
+{"version":3,"file":"subscribable.js","names":[],"sources":["../../src/subscribable.ts"],"sourcesContent":["/**\n * The base class behind everything in Query that you can subscribe to: `QueryCache`, `MutationCache`,\n * the observers, and the `FocusManager`/`OnlineManager` behind `focusManager` and `onlineManager`.\n * Subclasses decide what a listener receives and when it is called.\n */\nexport class Subscribable<TListener extends Function> {\n  protected listeners = new Set<TListener>()\n\n  constructor() {\n    this.subscribe = this.subscribe.bind(this)\n  }\n\n  /**\n   * Registers a listener to be called on every update this object notifies about. Returns a function\n   * that removes the listener again — call it to stop listening. The base class never drops a listener\n   * on its own, though some subclasses clear all of theirs in `destroy()`.\n   * @param listener - Called on each update, with whatever the subclass passes to its subscribers.\n   * @example\n   * ```ts\n   * const unsubscribe = subscribable.subscribe(() => {\n   *   // react to the update\n   * })\n   *\n   * unsubscribe()\n   * ```\n   */\n  subscribe(listener: TListener): () => void {\n    this.listeners.add(listener)\n\n    this.onSubscribe()\n\n    return () => {\n      this.listeners.delete(listener)\n      this.onUnsubscribe()\n    }\n  }\n\n  /**\n   * Returns `true` while at least one listener is registered, `false` once they have all unsubscribed.\n   */\n  hasListeners(): boolean {\n    return this.listeners.size > 0\n  }\n\n  protected onSubscribe(): void {\n    // Do nothing\n  }\n\n  protected onUnsubscribe(): void {\n    // Do nothing\n  }\n}\n"],"mappings":";;;;;;AAKA,IAAa,eAAb,MAAsD;CAGpD,cAAc;EAFQ,KAAA,4BAAA,IAAI,IAAe;EAGvC,KAAK,YAAY,KAAK,UAAU,KAAK,IAAI;CAC3C;;;;;;;;;;;;;;;CAgBA,UAAU,UAAiC;EACzC,KAAK,UAAU,IAAI,QAAQ;EAE3B,KAAK,YAAY;EAEjB,aAAa;GACX,KAAK,UAAU,OAAO,QAAQ;GAC9B,KAAK,cAAc;EACrB;CACF;;;;CAKA,eAAwB;EACtB,OAAO,KAAK,UAAU,OAAO;CAC/B;CAEA,cAA8B,CAE9B;CAEA,gBAAgC,CAEhC;AACF"}

package/build/modern/timeoutManager.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"timeoutManager.cjs","names":["#providerCalled","#provider"],"sources":["../../src/timeoutManager.ts"],"sourcesContent":["/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n *\n * Timers are performance-sensitive: short-lived timers (delays under a few seconds) tend to be\n * latency-sensitive, while long-lived ones may benefit more from coalescing — batching timers\n * with similar deadlines together — which the default provider (backed by the platform's global\n * `setTimeout`/`setInterval`) does not do. A custom provider can implement coalescing, and can\n * also support delays longer than the ~24-day maximum of the global `setTimeout`.\n */\nexport type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =\n  {\n    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearInterval: (intervalId: TTimerId | undefined) => void\n  }\n\ntype SystemTimerId = ReturnType<typeof setTimeout>\n\nexport const defaultTimeoutProvider: TimeoutProvider = {\n  // We need the wrapper function syntax below instead of direct references to\n  // global setTimeout etc.\n  //\n  // BAD: `setTimeout: setTimeout`\n  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n  //\n  // If we use direct references here, then anything that wants to spy on or\n  // replace the global setTimeout (like tests) won't work since we'll already\n  // have a hard reference to the original implementation at the time when this\n  // file was imported.\n  setTimeout: (callback, delay) => setTimeout(callback, delay),\n  clearTimeout: (timeoutId) =>\n    clearTimeout(timeoutId as SystemTimerId | undefined),\n\n  setInterval: (callback, delay) => setInterval(callback, delay),\n  clearInterval: (intervalId) =>\n    clearInterval(intervalId as SystemTimerId | undefined),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit<TimeoutProvider, 'name'> {\n  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete\n  // type at app boot; and if we leave that type, then any new timer provider\n  // would need to support the default provider's concrete timer ID, which is\n  // infeasible across environments.\n  //\n  // We settle for type safety for the TimeoutProvider type, and accept that\n  // this class is unsafe internally to allow for extension.\n  #provider: TimeoutProvider<any> = defaultTimeoutProvider\n  #providerCalled = false\n\n  /**\n   * `setTimeoutProvider` can be used to set a custom implementation of the\n   * `setTimeout`, `clearTimeout`, `setInterval`, `clearInterval` functions,\n   * called a `TimeoutProvider`.\n   *\n   * This may be useful if you notice event loop performance issues with\n   * thousands of queries. A custom TimeoutProvider could also support timer\n   * delays longer than the global `setTimeout` maximum delay value of about\n   * 24 days.\n   *\n   * It is important to call `setTimeoutProvider` before creating a\n   * QueryClient or queries, so that the same provider is used consistently\n   * for all timers in the application, since different TimeoutProviders\n   * cannot cancel each others' timers.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager, QueryClient } from '@tanstack/query-core'\n   * import { CustomTimeoutProvider } from './CustomTimeoutProvider'\n   *\n   * timeoutManager.setTimeoutProvider(new CustomTimeoutProvider())\n   *\n   * export const queryClient = new QueryClient()\n   * ```\n   */\n  setTimeoutProvider<TTimerId extends ManagedTimerId>(\n    provider: TimeoutProvider<TTimerId>,\n  ): void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (this.#providerCalled && provider !== this.#provider) {\n        // After changing providers, `clearTimeout` will not work as expected for\n        // timeouts from the previous provider.\n        //\n        // Since they may allocate the same timeout ID, clearTimeout may cancel an\n        // arbitrary different timeout, or unexpected no-op.\n        //\n        // We could protect against this by mixing the timeout ID bits\n        // deterministically with some per-provider bits.\n        //\n        // We could internally queue `setTimeout` calls to `TimeoutManager` until\n        // some API call to set the initial provider.\n        console.error(\n          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n          { previous: this.#provider, provider },\n        )\n      }\n    }\n\n    this.#provider = provider\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = false\n    }\n  }\n\n  /**\n   * `setTimeout` schedules a callback to run after approximately `delay`\n   * milliseconds, like the global `setTimeout` function. The callback can be\n   * canceled with `clearTimeout`.\n   *\n   * It returns a timer ID, which may be a number or an object that can be\n   * coerced to a number via `Symbol.toPrimitive`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const timeoutId = timeoutManager.setTimeout(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * const timeoutIdNumber: number = Number(timeoutId)\n   * ```\n   */\n  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setTimeout(callback, delay)\n  }\n\n  /**\n   * `clearTimeout` cancels a timeout callback scheduled with `setTimeout`,\n   * like the global `clearTimeout` function. It should be called with a\n   * timer ID returned by `setTimeout`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const timeoutId = timeoutManager.setTimeout(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * timeoutManager.clearTimeout(timeoutId)\n   * ```\n   */\n  clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n    this.#provider.clearTimeout(timeoutId)\n  }\n\n  /**\n   * `setInterval` schedules a callback to be called approximately every\n   * `delay` milliseconds, like the global `setInterval` function.\n   *\n   * Like `setTimeout`, it returns a timer ID, which may be a number or an\n   * object that can be coerced to a number via `Symbol.toPrimitive`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const intervalId = timeoutManager.setInterval(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   * ```\n   */\n  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setInterval(callback, delay)\n  }\n\n  /**\n   * `clearInterval` can be used to cancel an interval, like the global\n   * `clearInterval` function. It should be called with an interval ID\n   * returned by `setInterval`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const intervalId = timeoutManager.setInterval(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * timeoutManager.clearInterval(intervalId)\n   * ```\n   */\n  clearInterval(intervalId: ManagedTimerId | undefined): void {\n    this.#provider.clearInterval(intervalId)\n  }\n}\n\n/**\n * Singleton instance of {@link TimeoutManager}, used throughout TanStack Query to schedule and cancel timers.\n */\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n  setTimeout(callback, 0)\n}\n"],"mappings":";;AAsCA,MAAa,yBAA0C;CAWrD,aAAa,UAAU,UAAU,WAAW,UAAU,KAAK;CAC3D,eAAe,cACb,aAAa,SAAsC;CAErD,cAAc,UAAU,UAAU,YAAY,UAAU,KAAK;CAC7D,gBAAgB,eACd,cAAc,UAAuC;AACzD;;;;;;;;;;;;AAaA,IAAa,iBAAb,MAAqE;CAQnE,YAAkC;CAClC,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,mBACE,UACM;EACN,IAAI,QAAQ,IAAI,aAAa,cACvB;OAAA,KAAKA,mBAAmB,aAAa,KAAKC,WAY5C,QAAQ,MACN,8GACA;IAAE,UAAU,KAAKA;IAAW;GAAS,CACvC;EAAA;EAIJ,KAAKA,YAAY;EACjB,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAKD,kBAAkB;CAE3B;;;;;;;;;;;;;;;;;;;;;CAsBA,WAAW,UAA2B,OAA+B;EACnE,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAKA,kBAAkB;EAEzB,OAAO,KAAKC,UAAU,WAAW,UAAU,KAAK;CAClD;;;;;;;;;;;;;;;;;;CAmBA,aAAa,WAA6C;EACxD,KAAKA,UAAU,aAAa,SAAS;CACvC;;;;;;;;;;;;;;;;;;CAmBA,YAAY,UAA2B,OAA+B;EACpE,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAKD,kBAAkB;EAEzB,OAAO,KAAKC,UAAU,YAAY,UAAU,KAAK;CACnD;;;;;;;;;;;;;;;;;;CAmBA,cAAc,YAA8C;EAC1D,KAAKA,UAAU,cAAc,UAAU;CACzC;AACF;;;;AAKA,MAAa,iBAAiB,IAAI,eAAe;;;;;;;;AASjD,SAAgB,qBAAqB,UAAiC;CACpE,WAAW,UAAU,CAAC;AACxB"}
+{"version":3,"file":"timeoutManager.cjs","names":[],"sources":["../../src/timeoutManager.ts"],"sourcesContent":["/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n *\n * Timers are performance-sensitive: short-lived timers (delays under a few seconds) tend to be\n * latency-sensitive, while long-lived ones may benefit more from coalescing — batching timers\n * with similar deadlines together — which the default provider (backed by the platform's global\n * `setTimeout`/`setInterval`) does not do. A custom provider can implement coalescing, and can\n * also support delays longer than the ~24-day maximum of the global `setTimeout`.\n */\nexport type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =\n  {\n    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearInterval: (intervalId: TTimerId | undefined) => void\n  }\n\ntype SystemTimerId = ReturnType<typeof setTimeout>\n\nexport const defaultTimeoutProvider: TimeoutProvider = {\n  // We need the wrapper function syntax below instead of direct references to\n  // global setTimeout etc.\n  //\n  // BAD: `setTimeout: setTimeout`\n  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n  //\n  // If we use direct references here, then anything that wants to spy on or\n  // replace the global setTimeout (like tests) won't work since we'll already\n  // have a hard reference to the original implementation at the time when this\n  // file was imported.\n  setTimeout: (callback, delay) => setTimeout(callback, delay),\n  clearTimeout: (timeoutId) =>\n    clearTimeout(timeoutId as SystemTimerId | undefined),\n\n  setInterval: (callback, delay) => setInterval(callback, delay),\n  clearInterval: (intervalId) =>\n    clearInterval(intervalId as SystemTimerId | undefined),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit<TimeoutProvider, 'name'> {\n  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete\n  // type at app boot; and if we leave that type, then any new timer provider\n  // would need to support the default provider's concrete timer ID, which is\n  // infeasible across environments.\n  //\n  // We settle for type safety for the TimeoutProvider type, and accept that\n  // this class is unsafe internally to allow for extension.\n  #provider: TimeoutProvider<any> = defaultTimeoutProvider\n  #providerCalled = false\n\n  /**\n   * `setTimeoutProvider` can be used to set a custom implementation of the\n   * `setTimeout`, `clearTimeout`, `setInterval`, `clearInterval` functions,\n   * called a `TimeoutProvider`.\n   *\n   * This may be useful if you notice event loop performance issues with\n   * thousands of queries. A custom TimeoutProvider could also support timer\n   * delays longer than the global `setTimeout` maximum delay value of about\n   * 24 days.\n   *\n   * It is important to call `setTimeoutProvider` before creating a\n   * QueryClient or queries, so that the same provider is used consistently\n   * for all timers in the application, since different TimeoutProviders\n   * cannot cancel each others' timers.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager, QueryClient } from '@tanstack/query-core'\n   * import { CustomTimeoutProvider } from './CustomTimeoutProvider'\n   *\n   * timeoutManager.setTimeoutProvider(new CustomTimeoutProvider())\n   *\n   * export const queryClient = new QueryClient()\n   * ```\n   */\n  setTimeoutProvider<TTimerId extends ManagedTimerId>(\n    provider: TimeoutProvider<TTimerId>,\n  ): void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (this.#providerCalled && provider !== this.#provider) {\n        // After changing providers, `clearTimeout` will not work as expected for\n        // timeouts from the previous provider.\n        //\n        // Since they may allocate the same timeout ID, clearTimeout may cancel an\n        // arbitrary different timeout, or unexpected no-op.\n        //\n        // We could protect against this by mixing the timeout ID bits\n        // deterministically with some per-provider bits.\n        //\n        // We could internally queue `setTimeout` calls to `TimeoutManager` until\n        // some API call to set the initial provider.\n        console.error(\n          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n          { previous: this.#provider, provider },\n        )\n      }\n    }\n\n    this.#provider = provider\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = false\n    }\n  }\n\n  /**\n   * `setTimeout` schedules a callback to run after approximately `delay`\n   * milliseconds, like the global `setTimeout` function. The callback can be\n   * canceled with `clearTimeout`.\n   *\n   * It returns a timer ID, which may be a number or an object that can be\n   * coerced to a number via `Symbol.toPrimitive`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const timeoutId = timeoutManager.setTimeout(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * const timeoutIdNumber: number = Number(timeoutId)\n   * ```\n   */\n  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setTimeout(callback, delay)\n  }\n\n  /**\n   * `clearTimeout` cancels a timeout callback scheduled with `setTimeout`,\n   * like the global `clearTimeout` function. It should be called with a\n   * timer ID returned by `setTimeout`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const timeoutId = timeoutManager.setTimeout(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * timeoutManager.clearTimeout(timeoutId)\n   * ```\n   */\n  clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n    this.#provider.clearTimeout(timeoutId)\n  }\n\n  /**\n   * `setInterval` schedules a callback to be called approximately every\n   * `delay` milliseconds, like the global `setInterval` function.\n   *\n   * Like `setTimeout`, it returns a timer ID, which may be a number or an\n   * object that can be coerced to a number via `Symbol.toPrimitive`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const intervalId = timeoutManager.setInterval(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   * ```\n   */\n  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setInterval(callback, delay)\n  }\n\n  /**\n   * `clearInterval` can be used to cancel an interval, like the global\n   * `clearInterval` function. It should be called with an interval ID\n   * returned by `setInterval`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const intervalId = timeoutManager.setInterval(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * timeoutManager.clearInterval(intervalId)\n   * ```\n   */\n  clearInterval(intervalId: ManagedTimerId | undefined): void {\n    this.#provider.clearInterval(intervalId)\n  }\n}\n\n/**\n * Singleton instance of {@link TimeoutManager}, used throughout TanStack Query to schedule and cancel timers.\n */\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n  setTimeout(callback, 0)\n}\n"],"mappings":";;AAsCA,MAAa,yBAA0C;CAWrD,aAAa,UAAU,UAAU,WAAW,UAAU,KAAK;CAC3D,eAAe,cACb,aAAa,SAAsC;CAErD,cAAc,UAAU,UAAU,YAAY,UAAU,KAAK;CAC7D,gBAAgB,eACd,cAAc,UAAuC;AACzD;;;;;;;;;;;;AAaA,IAAa,iBAAb,MAAqE;CAQnE,YAAkC;CAClC,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,mBACE,UACM;EACN,IAAI,QAAQ,IAAI,aAAa,cACvB;OAAA,KAAK,mBAAmB,aAAa,KAAK,WAY5C,QAAQ,MACN,8GACA;IAAE,UAAU,KAAK;IAAW;GAAS,CACvC;EAAA;EAIJ,KAAK,YAAY;EACjB,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAK,kBAAkB;CAE3B;;;;;;;;;;;;;;;;;;;;;CAsBA,WAAW,UAA2B,OAA+B;EACnE,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAK,kBAAkB;EAEzB,OAAO,KAAK,UAAU,WAAW,UAAU,KAAK;CAClD;;;;;;;;;;;;;;;;;;CAmBA,aAAa,WAA6C;EACxD,KAAK,UAAU,aAAa,SAAS;CACvC;;;;;;;;;;;;;;;;;;CAmBA,YAAY,UAA2B,OAA+B;EACpE,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAK,kBAAkB;EAEzB,OAAO,KAAK,UAAU,YAAY,UAAU,KAAK;CACnD;;;;;;;;;;;;;;;;;;CAmBA,cAAc,YAA8C;EAC1D,KAAK,UAAU,cAAc,UAAU;CACzC;AACF;;;;AAKA,MAAa,iBAAiB,IAAI,eAAe;;;;;;;;AASjD,SAAgB,qBAAqB,UAAiC;CACpE,WAAW,UAAU,CAAC;AACxB"}

package/build/modern/timeoutManager.d.cts

@@ -7,14 +7,14 @@
  * If we don't accept a single void argument, then
  * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.
  */
-type TimeoutCallback = (_: void) => void;
+export type TimeoutCallback = (_: void) => void;
 /**
  * Wrapping `setTimeout` is awkward from a typing perspective because platform
  * typings may extend the return type of `setTimeout`. For example, NodeJS
  * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be
  * able to return such a type.
  */
-type ManagedTimerId = number | {
+export type ManagedTimerId = number | {
   [Symbol.toPrimitive]: () => number;
 };
 /**
@@ -26,13 +26,13 @@ type ManagedTimerId = number | {
  * `setTimeout`/`setInterval`) does not do. A custom provider can implement coalescing, and can
  * also support delays longer than the ~24-day maximum of the global `setTimeout`.
  */
-type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> = {
+export type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> = {
   readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId;
   readonly clearTimeout: (timeoutId: TTimerId | undefined) => void;
   readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId;
   readonly clearInterval: (intervalId: TTimerId | undefined) => void;
 };
-declare const defaultTimeoutProvider: TimeoutProvider;
+export declare const defaultTimeoutProvider: TimeoutProvider;
 /**
  * Allows customization of how timeouts are created.
  *
@@ -44,7 +44,7 @@ declare const defaultTimeoutProvider: TimeoutProvider;
  * If you hit this limitation, consider providing a custom TimeoutProvider that
  * coalesces timeouts.
  */
-declare class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
+export declare class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
   #private;
   /**
    * `setTimeoutProvider` can be used to set a custom implementation of the
@@ -151,7 +151,7 @@ declare class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
 /**
  * Singleton instance of {@link TimeoutManager}, used throughout TanStack Query to schedule and cancel timers.
  */
-declare const timeoutManager: TimeoutManager;
+export declare const timeoutManager: TimeoutManager;
 /**
  * In many cases code wants to delay to the next event loop tick; this is not
  * mediated by {@link timeoutManager}.
@@ -159,7 +159,6 @@ declare const timeoutManager: TimeoutManager;
  * This function is provided to make auditing the `tanstack/query-core` for
  * incorrect use of system `setTimeout` easier.
  */
-declare function systemSetTimeoutZero(callback: TimeoutCallback): void;
+export declare function systemSetTimeoutZero(callback: TimeoutCallback): void;
 //#endregion
-export { ManagedTimerId, TimeoutCallback, TimeoutManager, TimeoutProvider, defaultTimeoutProvider, systemSetTimeoutZero, timeoutManager };
 //# sourceMappingURL=timeoutManager.d.cts.map

package/build/modern/timeoutManager.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"timeoutManager.d.cts","names":[],"sources":["../../src/timeoutManager.ts"],"mappings":";;;;;;;;;KAQY,mBAAmB;;;;;;;KAQnB;GAA6B,OAAO;;;;;;;;;;;KAWpC,gBAAgB,iBAAiB,iBAAiB;WAEjD,aAAa,UAAU,iBAAiB,kBAAkB;WAC1D,eAAe,WAAW;WAE1B,cAAc,UAAU,iBAAiB,kBAAkB;WAC3D,gBAAgB,YAAY;;cAK5B,wBAAwB;;;;;;;;;;;;cA+BxB,0BAA0B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC1C,mBAAmB,iBAAiB,gBAClC,UAAU,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAgD5B,WAAW,UAAU,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;EAwBtD,aAAa,WAAW;;;;;;;;;;;;;;;;;;EAqBxB,YAAY,UAAU,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;EAwBvD,cAAc,YAAY;;;;;cAQf,gBAAc;;;;;;;;iBASX,qBAAqB,UAAU"}
+{"version":3,"file":"timeoutManager.d.cts","names":[],"sources":["../../src/timeoutManager.ts"],"mappings":";;;;;;;;;YAQY,mBAAmB;;;;;;;YAQnB;GAA6B,OAAO;;;;;;;;;;;YAWpC,gBAAgB,iBAAiB,iBAAiB;WAEjD,aAAa,UAAU,iBAAiB,kBAAkB;WAC1D,eAAe,WAAW;WAE1B,cAAc,UAAU,iBAAiB,kBAAkB;WAC3D,gBAAgB,YAAY;;qBAK5B,wBAAwB;;;;;;;;;;;;qBA+BxB,0BAA0B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC1C,mBAAmB,iBAAiB,gBAClC,UAAU,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAgD5B,WAAW,UAAU,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;EAwBtD,aAAa,WAAW;;;;;;;;;;;;;;;;;;EAqBxB,YAAY,UAAU,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;EAwBvD,cAAc,YAAY;;;;;qBAQf,gBAAc;;;;;;;;wBASX,qBAAqB,UAAU"}

package/build/modern/timeoutManager.d.ts

@@ -7,14 +7,14 @@
  * If we don't accept a single void argument, then
  * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.
  */
-type TimeoutCallback = (_: void) => void;
+export type TimeoutCallback = (_: void) => void;
 /**
  * Wrapping `setTimeout` is awkward from a typing perspective because platform
  * typings may extend the return type of `setTimeout`. For example, NodeJS
  * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be
  * able to return such a type.
  */
-type ManagedTimerId = number | {
+export type ManagedTimerId = number | {
   [Symbol.toPrimitive]: () => number;
 };
 /**
@@ -26,13 +26,13 @@ type ManagedTimerId = number | {
  * `setTimeout`/`setInterval`) does not do. A custom provider can implement coalescing, and can
  * also support delays longer than the ~24-day maximum of the global `setTimeout`.
  */
-type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> = {
+export type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> = {
   readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId;
   readonly clearTimeout: (timeoutId: TTimerId | undefined) => void;
   readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId;
   readonly clearInterval: (intervalId: TTimerId | undefined) => void;
 };
-declare const defaultTimeoutProvider: TimeoutProvider;
+export declare const defaultTimeoutProvider: TimeoutProvider;
 /**
  * Allows customization of how timeouts are created.
  *
@@ -44,7 +44,7 @@ declare const defaultTimeoutProvider: TimeoutProvider;
  * If you hit this limitation, consider providing a custom TimeoutProvider that
  * coalesces timeouts.
  */
-declare class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
+export declare class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
   #private;
   /**
    * `setTimeoutProvider` can be used to set a custom implementation of the
@@ -151,7 +151,7 @@ declare class TimeoutManager implements Omit<TimeoutProvider, 'name'> {
 /**
  * Singleton instance of {@link TimeoutManager}, used throughout TanStack Query to schedule and cancel timers.
  */
-declare const timeoutManager: TimeoutManager;
+export declare const timeoutManager: TimeoutManager;
 /**
  * In many cases code wants to delay to the next event loop tick; this is not
  * mediated by {@link timeoutManager}.
@@ -159,7 +159,6 @@ declare const timeoutManager: TimeoutManager;
  * This function is provided to make auditing the `tanstack/query-core` for
  * incorrect use of system `setTimeout` easier.
  */
-declare function systemSetTimeoutZero(callback: TimeoutCallback): void;
+export declare function systemSetTimeoutZero(callback: TimeoutCallback): void;
 //#endregion
-export { ManagedTimerId, TimeoutCallback, TimeoutManager, TimeoutProvider, defaultTimeoutProvider, systemSetTimeoutZero, timeoutManager };
 //# sourceMappingURL=timeoutManager.d.ts.map

package/build/modern/timeoutManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timeoutManager.d.ts","names":[],"sources":["../../src/timeoutManager.ts"],"mappings":";;;;;;;;;KAQY,mBAAmB;;;;;;;KAQnB;GAA6B,OAAO;;;;;;;;;;;KAWpC,gBAAgB,iBAAiB,iBAAiB;WAEjD,aAAa,UAAU,iBAAiB,kBAAkB;WAC1D,eAAe,WAAW;WAE1B,cAAc,UAAU,iBAAiB,kBAAkB;WAC3D,gBAAgB,YAAY;;cAK5B,wBAAwB;;;;;;;;;;;;cA+BxB,0BAA0B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC1C,mBAAmB,iBAAiB,gBAClC,UAAU,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAgD5B,WAAW,UAAU,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;EAwBtD,aAAa,WAAW;;;;;;;;;;;;;;;;;;EAqBxB,YAAY,UAAU,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;EAwBvD,cAAc,YAAY;;;;;cAQf,gBAAc;;;;;;;;iBASX,qBAAqB,UAAU"}
+{"version":3,"file":"timeoutManager.d.ts","names":[],"sources":["../../src/timeoutManager.ts"],"mappings":";;;;;;;;;YAQY,mBAAmB;;;;;;;YAQnB;GAA6B,OAAO;;;;;;;;;;;YAWpC,gBAAgB,iBAAiB,iBAAiB;WAEjD,aAAa,UAAU,iBAAiB,kBAAkB;WAC1D,eAAe,WAAW;WAE1B,cAAc,UAAU,iBAAiB,kBAAkB;WAC3D,gBAAgB,YAAY;;qBAK5B,wBAAwB;;;;;;;;;;;;qBA+BxB,0BAA0B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoC1C,mBAAmB,iBAAiB,gBAClC,UAAU,gBAAgB;;;;;;;;;;;;;;;;;;;;;EAgD5B,WAAW,UAAU,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;EAwBtD,aAAa,WAAW;;;;;;;;;;;;;;;;;;EAqBxB,YAAY,UAAU,iBAAiB,gBAAgB;;;;;;;;;;;;;;;;;;EAwBvD,cAAc,YAAY;;;;;qBAQf,gBAAc;;;;;;;;wBASX,qBAAqB,UAAU"}

package/build/modern/timeoutManager.js.map

@@ -1 +1 @@
-{"version":3,"file":"timeoutManager.js","names":["#providerCalled","#provider"],"sources":["../../src/timeoutManager.ts"],"sourcesContent":["/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n *\n * Timers are performance-sensitive: short-lived timers (delays under a few seconds) tend to be\n * latency-sensitive, while long-lived ones may benefit more from coalescing — batching timers\n * with similar deadlines together — which the default provider (backed by the platform's global\n * `setTimeout`/`setInterval`) does not do. A custom provider can implement coalescing, and can\n * also support delays longer than the ~24-day maximum of the global `setTimeout`.\n */\nexport type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =\n  {\n    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearInterval: (intervalId: TTimerId | undefined) => void\n  }\n\ntype SystemTimerId = ReturnType<typeof setTimeout>\n\nexport const defaultTimeoutProvider: TimeoutProvider = {\n  // We need the wrapper function syntax below instead of direct references to\n  // global setTimeout etc.\n  //\n  // BAD: `setTimeout: setTimeout`\n  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n  //\n  // If we use direct references here, then anything that wants to spy on or\n  // replace the global setTimeout (like tests) won't work since we'll already\n  // have a hard reference to the original implementation at the time when this\n  // file was imported.\n  setTimeout: (callback, delay) => setTimeout(callback, delay),\n  clearTimeout: (timeoutId) =>\n    clearTimeout(timeoutId as SystemTimerId | undefined),\n\n  setInterval: (callback, delay) => setInterval(callback, delay),\n  clearInterval: (intervalId) =>\n    clearInterval(intervalId as SystemTimerId | undefined),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit<TimeoutProvider, 'name'> {\n  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete\n  // type at app boot; and if we leave that type, then any new timer provider\n  // would need to support the default provider's concrete timer ID, which is\n  // infeasible across environments.\n  //\n  // We settle for type safety for the TimeoutProvider type, and accept that\n  // this class is unsafe internally to allow for extension.\n  #provider: TimeoutProvider<any> = defaultTimeoutProvider\n  #providerCalled = false\n\n  /**\n   * `setTimeoutProvider` can be used to set a custom implementation of the\n   * `setTimeout`, `clearTimeout`, `setInterval`, `clearInterval` functions,\n   * called a `TimeoutProvider`.\n   *\n   * This may be useful if you notice event loop performance issues with\n   * thousands of queries. A custom TimeoutProvider could also support timer\n   * delays longer than the global `setTimeout` maximum delay value of about\n   * 24 days.\n   *\n   * It is important to call `setTimeoutProvider` before creating a\n   * QueryClient or queries, so that the same provider is used consistently\n   * for all timers in the application, since different TimeoutProviders\n   * cannot cancel each others' timers.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager, QueryClient } from '@tanstack/query-core'\n   * import { CustomTimeoutProvider } from './CustomTimeoutProvider'\n   *\n   * timeoutManager.setTimeoutProvider(new CustomTimeoutProvider())\n   *\n   * export const queryClient = new QueryClient()\n   * ```\n   */\n  setTimeoutProvider<TTimerId extends ManagedTimerId>(\n    provider: TimeoutProvider<TTimerId>,\n  ): void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (this.#providerCalled && provider !== this.#provider) {\n        // After changing providers, `clearTimeout` will not work as expected for\n        // timeouts from the previous provider.\n        //\n        // Since they may allocate the same timeout ID, clearTimeout may cancel an\n        // arbitrary different timeout, or unexpected no-op.\n        //\n        // We could protect against this by mixing the timeout ID bits\n        // deterministically with some per-provider bits.\n        //\n        // We could internally queue `setTimeout` calls to `TimeoutManager` until\n        // some API call to set the initial provider.\n        console.error(\n          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n          { previous: this.#provider, provider },\n        )\n      }\n    }\n\n    this.#provider = provider\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = false\n    }\n  }\n\n  /**\n   * `setTimeout` schedules a callback to run after approximately `delay`\n   * milliseconds, like the global `setTimeout` function. The callback can be\n   * canceled with `clearTimeout`.\n   *\n   * It returns a timer ID, which may be a number or an object that can be\n   * coerced to a number via `Symbol.toPrimitive`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const timeoutId = timeoutManager.setTimeout(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * const timeoutIdNumber: number = Number(timeoutId)\n   * ```\n   */\n  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setTimeout(callback, delay)\n  }\n\n  /**\n   * `clearTimeout` cancels a timeout callback scheduled with `setTimeout`,\n   * like the global `clearTimeout` function. It should be called with a\n   * timer ID returned by `setTimeout`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const timeoutId = timeoutManager.setTimeout(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * timeoutManager.clearTimeout(timeoutId)\n   * ```\n   */\n  clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n    this.#provider.clearTimeout(timeoutId)\n  }\n\n  /**\n   * `setInterval` schedules a callback to be called approximately every\n   * `delay` milliseconds, like the global `setInterval` function.\n   *\n   * Like `setTimeout`, it returns a timer ID, which may be a number or an\n   * object that can be coerced to a number via `Symbol.toPrimitive`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const intervalId = timeoutManager.setInterval(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   * ```\n   */\n  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setInterval(callback, delay)\n  }\n\n  /**\n   * `clearInterval` can be used to cancel an interval, like the global\n   * `clearInterval` function. It should be called with an interval ID\n   * returned by `setInterval`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const intervalId = timeoutManager.setInterval(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * timeoutManager.clearInterval(intervalId)\n   * ```\n   */\n  clearInterval(intervalId: ManagedTimerId | undefined): void {\n    this.#provider.clearInterval(intervalId)\n  }\n}\n\n/**\n * Singleton instance of {@link TimeoutManager}, used throughout TanStack Query to schedule and cancel timers.\n */\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n  setTimeout(callback, 0)\n}\n"],"mappings":";AAsCA,MAAa,yBAA0C;CAWrD,aAAa,UAAU,UAAU,WAAW,UAAU,KAAK;CAC3D,eAAe,cACb,aAAa,SAAsC;CAErD,cAAc,UAAU,UAAU,YAAY,UAAU,KAAK;CAC7D,gBAAgB,eACd,cAAc,UAAuC;AACzD;;;;;;;;;;;;AAaA,IAAa,iBAAb,MAAqE;CAQnE,YAAkC;CAClC,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,mBACE,UACM;EACN,IAAI,QAAQ,IAAI,aAAa,cACvB;OAAA,KAAKA,mBAAmB,aAAa,KAAKC,WAY5C,QAAQ,MACN,8GACA;IAAE,UAAU,KAAKA;IAAW;GAAS,CACvC;EAAA;EAIJ,KAAKA,YAAY;EACjB,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAKD,kBAAkB;CAE3B;;;;;;;;;;;;;;;;;;;;;CAsBA,WAAW,UAA2B,OAA+B;EACnE,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAKA,kBAAkB;EAEzB,OAAO,KAAKC,UAAU,WAAW,UAAU,KAAK;CAClD;;;;;;;;;;;;;;;;;;CAmBA,aAAa,WAA6C;EACxD,KAAKA,UAAU,aAAa,SAAS;CACvC;;;;;;;;;;;;;;;;;;CAmBA,YAAY,UAA2B,OAA+B;EACpE,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAKD,kBAAkB;EAEzB,OAAO,KAAKC,UAAU,YAAY,UAAU,KAAK;CACnD;;;;;;;;;;;;;;;;;;CAmBA,cAAc,YAA8C;EAC1D,KAAKA,UAAU,cAAc,UAAU;CACzC;AACF;;;;AAKA,MAAa,iBAAiB,IAAI,eAAe;;;;;;;;AASjD,SAAgB,qBAAqB,UAAiC;CACpE,WAAW,UAAU,CAAC;AACxB"}
+{"version":3,"file":"timeoutManager.js","names":[],"sources":["../../src/timeoutManager.ts"],"sourcesContent":["/**\n * {@link TimeoutManager} does not support passing arguments to the callback.\n *\n * `(_: void)` is the argument type inferred by TypeScript's default typings for\n * `setTimeout(cb, number)`.\n * If we don't accept a single void argument, then\n * `new Promise(resolve => timeoutManager.setTimeout(resolve, N))` is a type error.\n */\nexport type TimeoutCallback = (_: void) => void\n\n/**\n * Wrapping `setTimeout` is awkward from a typing perspective because platform\n * typings may extend the return type of `setTimeout`. For example, NodeJS\n * typings add `NodeJS.Timeout`; but a non-default `timeoutManager` may not be\n * able to return such a type.\n */\nexport type ManagedTimerId = number | { [Symbol.toPrimitive]: () => number }\n\n/**\n * Backend for timer functions.\n *\n * Timers are performance-sensitive: short-lived timers (delays under a few seconds) tend to be\n * latency-sensitive, while long-lived ones may benefit more from coalescing — batching timers\n * with similar deadlines together — which the default provider (backed by the platform's global\n * `setTimeout`/`setInterval`) does not do. A custom provider can implement coalescing, and can\n * also support delays longer than the ~24-day maximum of the global `setTimeout`.\n */\nexport type TimeoutProvider<TTimerId extends ManagedTimerId = ManagedTimerId> =\n  {\n    readonly setTimeout: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearTimeout: (timeoutId: TTimerId | undefined) => void\n\n    readonly setInterval: (callback: TimeoutCallback, delay: number) => TTimerId\n    readonly clearInterval: (intervalId: TTimerId | undefined) => void\n  }\n\ntype SystemTimerId = ReturnType<typeof setTimeout>\n\nexport const defaultTimeoutProvider: TimeoutProvider = {\n  // We need the wrapper function syntax below instead of direct references to\n  // global setTimeout etc.\n  //\n  // BAD: `setTimeout: setTimeout`\n  // GOOD: `setTimeout: (cb, delay) => setTimeout(cb, delay)`\n  //\n  // If we use direct references here, then anything that wants to spy on or\n  // replace the global setTimeout (like tests) won't work since we'll already\n  // have a hard reference to the original implementation at the time when this\n  // file was imported.\n  setTimeout: (callback, delay) => setTimeout(callback, delay),\n  clearTimeout: (timeoutId) =>\n    clearTimeout(timeoutId as SystemTimerId | undefined),\n\n  setInterval: (callback, delay) => setInterval(callback, delay),\n  clearInterval: (intervalId) =>\n    clearInterval(intervalId as SystemTimerId | undefined),\n}\n\n/**\n * Allows customization of how timeouts are created.\n *\n * @tanstack/query-core makes liberal use of timeouts to implement `staleTime`\n * and `gcTime`. The default TimeoutManager provider uses the platform's global\n * `setTimeout` implementation, which is known to have scalability issues with\n * thousands of timeouts on the event loop.\n *\n * If you hit this limitation, consider providing a custom TimeoutProvider that\n * coalesces timeouts.\n */\nexport class TimeoutManager implements Omit<TimeoutProvider, 'name'> {\n  // We cannot have TimeoutManager<T> as we must instantiate it with a concrete\n  // type at app boot; and if we leave that type, then any new timer provider\n  // would need to support the default provider's concrete timer ID, which is\n  // infeasible across environments.\n  //\n  // We settle for type safety for the TimeoutProvider type, and accept that\n  // this class is unsafe internally to allow for extension.\n  #provider: TimeoutProvider<any> = defaultTimeoutProvider\n  #providerCalled = false\n\n  /**\n   * `setTimeoutProvider` can be used to set a custom implementation of the\n   * `setTimeout`, `clearTimeout`, `setInterval`, `clearInterval` functions,\n   * called a `TimeoutProvider`.\n   *\n   * This may be useful if you notice event loop performance issues with\n   * thousands of queries. A custom TimeoutProvider could also support timer\n   * delays longer than the global `setTimeout` maximum delay value of about\n   * 24 days.\n   *\n   * It is important to call `setTimeoutProvider` before creating a\n   * QueryClient or queries, so that the same provider is used consistently\n   * for all timers in the application, since different TimeoutProviders\n   * cannot cancel each others' timers.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager, QueryClient } from '@tanstack/query-core'\n   * import { CustomTimeoutProvider } from './CustomTimeoutProvider'\n   *\n   * timeoutManager.setTimeoutProvider(new CustomTimeoutProvider())\n   *\n   * export const queryClient = new QueryClient()\n   * ```\n   */\n  setTimeoutProvider<TTimerId extends ManagedTimerId>(\n    provider: TimeoutProvider<TTimerId>,\n  ): void {\n    if (process.env.NODE_ENV !== 'production') {\n      if (this.#providerCalled && provider !== this.#provider) {\n        // After changing providers, `clearTimeout` will not work as expected for\n        // timeouts from the previous provider.\n        //\n        // Since they may allocate the same timeout ID, clearTimeout may cancel an\n        // arbitrary different timeout, or unexpected no-op.\n        //\n        // We could protect against this by mixing the timeout ID bits\n        // deterministically with some per-provider bits.\n        //\n        // We could internally queue `setTimeout` calls to `TimeoutManager` until\n        // some API call to set the initial provider.\n        console.error(\n          `[timeoutManager]: Switching provider after calls to previous provider might result in unexpected behavior.`,\n          { previous: this.#provider, provider },\n        )\n      }\n    }\n\n    this.#provider = provider\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = false\n    }\n  }\n\n  /**\n   * `setTimeout` schedules a callback to run after approximately `delay`\n   * milliseconds, like the global `setTimeout` function. The callback can be\n   * canceled with `clearTimeout`.\n   *\n   * It returns a timer ID, which may be a number or an object that can be\n   * coerced to a number via `Symbol.toPrimitive`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const timeoutId = timeoutManager.setTimeout(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * const timeoutIdNumber: number = Number(timeoutId)\n   * ```\n   */\n  setTimeout(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setTimeout(callback, delay)\n  }\n\n  /**\n   * `clearTimeout` cancels a timeout callback scheduled with `setTimeout`,\n   * like the global `clearTimeout` function. It should be called with a\n   * timer ID returned by `setTimeout`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const timeoutId = timeoutManager.setTimeout(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * timeoutManager.clearTimeout(timeoutId)\n   * ```\n   */\n  clearTimeout(timeoutId: ManagedTimerId | undefined): void {\n    this.#provider.clearTimeout(timeoutId)\n  }\n\n  /**\n   * `setInterval` schedules a callback to be called approximately every\n   * `delay` milliseconds, like the global `setInterval` function.\n   *\n   * Like `setTimeout`, it returns a timer ID, which may be a number or an\n   * object that can be coerced to a number via `Symbol.toPrimitive`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const intervalId = timeoutManager.setInterval(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   * ```\n   */\n  setInterval(callback: TimeoutCallback, delay: number): ManagedTimerId {\n    if (process.env.NODE_ENV !== 'production') {\n      this.#providerCalled = true\n    }\n    return this.#provider.setInterval(callback, delay)\n  }\n\n  /**\n   * `clearInterval` can be used to cancel an interval, like the global\n   * `clearInterval` function. It should be called with an interval ID\n   * returned by `setInterval`.\n   *\n   * @example\n   * ```ts\n   * import { timeoutManager } from '@tanstack/query-core'\n   *\n   * const intervalId = timeoutManager.setInterval(\n   *   () => console.log('ran at:', new Date()),\n   *   1000,\n   * )\n   *\n   * timeoutManager.clearInterval(intervalId)\n   * ```\n   */\n  clearInterval(intervalId: ManagedTimerId | undefined): void {\n    this.#provider.clearInterval(intervalId)\n  }\n}\n\n/**\n * Singleton instance of {@link TimeoutManager}, used throughout TanStack Query to schedule and cancel timers.\n */\nexport const timeoutManager = new TimeoutManager()\n\n/**\n * In many cases code wants to delay to the next event loop tick; this is not\n * mediated by {@link timeoutManager}.\n *\n * This function is provided to make auditing the `tanstack/query-core` for\n * incorrect use of system `setTimeout` easier.\n */\nexport function systemSetTimeoutZero(callback: TimeoutCallback): void {\n  setTimeout(callback, 0)\n}\n"],"mappings":";AAsCA,MAAa,yBAA0C;CAWrD,aAAa,UAAU,UAAU,WAAW,UAAU,KAAK;CAC3D,eAAe,cACb,aAAa,SAAsC;CAErD,cAAc,UAAU,UAAU,YAAY,UAAU,KAAK;CAC7D,gBAAgB,eACd,cAAc,UAAuC;AACzD;;;;;;;;;;;;AAaA,IAAa,iBAAb,MAAqE;CAQnE,YAAkC;CAClC,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BlB,mBACE,UACM;EACN,IAAI,QAAQ,IAAI,aAAa,cACvB;OAAA,KAAK,mBAAmB,aAAa,KAAK,WAY5C,QAAQ,MACN,8GACA;IAAE,UAAU,KAAK;IAAW;GAAS,CACvC;EAAA;EAIJ,KAAK,YAAY;EACjB,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAK,kBAAkB;CAE3B;;;;;;;;;;;;;;;;;;;;;CAsBA,WAAW,UAA2B,OAA+B;EACnE,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAK,kBAAkB;EAEzB,OAAO,KAAK,UAAU,WAAW,UAAU,KAAK;CAClD;;;;;;;;;;;;;;;;;;CAmBA,aAAa,WAA6C;EACxD,KAAK,UAAU,aAAa,SAAS;CACvC;;;;;;;;;;;;;;;;;;CAmBA,YAAY,UAA2B,OAA+B;EACpE,IAAI,QAAQ,IAAI,aAAa,cAC3B,KAAK,kBAAkB;EAEzB,OAAO,KAAK,UAAU,YAAY,UAAU,KAAK;CACnD;;;;;;;;;;;;;;;;;;CAmBA,cAAc,YAA8C;EAC1D,KAAK,UAAU,cAAc,UAAU;CACzC;AACF;;;;AAKA,MAAa,iBAAiB,IAAI,eAAe;;;;;;;;AASjD,SAAgB,qBAAqB,UAAiC;CACpE,WAAW,UAAU,CAAC;AACxB"}

package/build/modern/types.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.cjs","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/* istanbul ignore file */\n\nimport type { QueryClient } from './queryClient'\nimport type { DehydrateOptions, HydrateOptions } from './hydration'\nimport type { MutationState } from './mutation'\nimport type { FetchDirection, Query, QueryBehavior } from './query'\nimport type { RetryDelayValue, RetryValue } from './retryer'\nimport type { QueryFilters, QueryTypeFilter, SkipToken } from './utils'\nimport type { QueryCache } from './queryCache'\nimport type { MutationCache } from './mutationCache'\n\nexport type NonUndefinedGuard<T> = T extends undefined ? never : T\n\nexport type DistributiveOmit<\n  TObject,\n  TKey extends keyof TObject,\n> = TObject extends any ? Omit<TObject, TKey> : never\n\nexport type OmitKeyof<\n  TObject,\n  TKey extends TStrictly extends 'safely'\n    ?\n        | keyof TObject\n        | (string & Record<never, never>)\n        | (number & Record<never, never>)\n        | (symbol & Record<never, never>)\n    : keyof TObject,\n  TStrictly extends 'strictly' | 'safely' = 'strictly',\n> = Omit<TObject, TKey>\n\nexport type Override<TTargetA, TTargetB> = {\n  [AKey in keyof TTargetA]: AKey extends keyof TTargetB\n    ? TTargetB[AKey]\n    : TTargetA[AKey]\n}\n\n/**\n * The interface to augment via declaration merging to override Query's default types repository-wide.\n * Each field it declares replaces the default of the matching type: `defaultError` for {@link DefaultError},\n * `queryKey` for {@link QueryKey}, `mutationKey` for {@link MutationKey}, `queryMeta` for {@link QueryMeta} and\n * `mutationMeta` for {@link MutationMeta}. Leave a field out to keep that type's default.\n * Augment the module you install — `@tanstack/react-query`, `@tanstack/vue-query`,\n * `@tanstack/solid-query`, `@tanstack/svelte-query`, `@tanstack/preact-query`,\n * `@tanstack/angular-query-experimental` or `@tanstack/lit-query`. Augmenting `@tanstack/query-core`\n * works too and covers every adapter at once.\n * @example\n * ```ts\n * // Use the module you installed — here, the React adapter.\n * declare module '@tanstack/react-query' {\n *   interface Register {\n *     defaultError: AxiosError\n *   }\n * }\n * ```\n */\nexport interface Register {\n  // defaultError: Error\n  // queryMeta: Record<string, unknown>\n  // mutationMeta: Record<string, unknown>\n  // queryKey: ReadonlyArray<unknown>\n  // mutationKey: ReadonlyArray<unknown>\n}\n\n/**\n * The error type used wherever an error is not given an explicit type parameter.\n * Defaults to `Error`; declare `defaultError` on {@link Register} to change it everywhere at once.\n */\nexport type DefaultError = Register extends {\n  defaultError: infer TError\n}\n  ? TError\n  : Error\n\n/**\n * The type of a query key — the serializable array that identifies a query in the cache.\n * Defaults to `ReadonlyArray<unknown>`; declare `queryKey` on {@link Register} to narrow it repository-wide.\n */\nexport type QueryKey = Register extends {\n  queryKey: infer TQueryKey\n}\n  ? TQueryKey extends ReadonlyArray<unknown>\n    ? TQueryKey\n    : TQueryKey extends Array<unknown>\n      ? TQueryKey\n      : ReadonlyArray<unknown>\n  : ReadonlyArray<unknown>\n\nexport const dataTagSymbol = Symbol()\nexport type dataTagSymbol = typeof dataTagSymbol\nexport const dataTagErrorSymbol = Symbol()\nexport type dataTagErrorSymbol = typeof dataTagErrorSymbol\nexport const unsetMarker = Symbol()\nexport type UnsetMarker = typeof unsetMarker\nexport type AnyDataTag = {\n  [dataTagSymbol]: any\n  [dataTagErrorSymbol]: any\n}\nexport type DataTag<\n  TType,\n  TValue,\n  TError = UnsetMarker,\n> = TType extends AnyDataTag\n  ? TType\n  : TType & {\n      [dataTagSymbol]: TValue\n      [dataTagErrorSymbol]: TError\n    }\n\nexport type QueryKeyWithDataTag<\n  TQueryKey extends QueryKey = QueryKey,\n  TQueryFnData = unknown,\n  TError = DefaultError,\n> = {\n  queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport type InferDataFromTag<TQueryFnData, TTaggedQueryKey extends QueryKey> =\n  TTaggedQueryKey extends DataTag<unknown, infer TaggedValue, unknown>\n    ? TaggedValue\n    : TQueryFnData\n\nexport type InferErrorFromTag<TError, TTaggedQueryKey extends QueryKey> =\n  TTaggedQueryKey extends DataTag<unknown, unknown, infer TaggedError>\n    ? TaggedError extends UnsetMarker\n      ? TError\n      : TaggedError\n    : TError\n\n/** @inline */\nexport type QueryFunction<\n  T = unknown,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T>\n\n/** @inline */\nexport type StaleTime = number | 'static'\n\n/** @inline */\nexport type StaleTimeFunction<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> =\n  | StaleTime\n  | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => StaleTime)\n\n/** @inline */\nexport type QueryBooleanOption<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> =\n  | boolean\n  | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean)\n\n/** @inline */\nexport type QueryPersister<\n  T = unknown,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> = [TPageParam] extends [never]\n  ? (\n      queryFn: QueryFunction<T, TQueryKey, never>,\n      context: QueryFunctionContext<TQueryKey>,\n      query: Query,\n    ) => T | Promise<T>\n  : (\n      queryFn: QueryFunction<T, TQueryKey, TPageParam>,\n      context: QueryFunctionContext<TQueryKey>,\n      query: Query,\n    ) => T | Promise<T>\n\nexport type QueryFunctionContext<\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> = [TPageParam] extends [never]\n  ? {\n      client: QueryClient\n      queryKey: TQueryKey\n      signal: AbortSignal\n      meta: QueryMeta | undefined\n      pageParam?: unknown\n      /**\n       * @deprecated\n       * if you want access to the direction, you can add it to the pageParam\n       */\n      direction?: unknown\n    }\n  : {\n      client: QueryClient\n      queryKey: TQueryKey\n      signal: AbortSignal\n      pageParam: TPageParam\n      /**\n       * @deprecated\n       * if you want access to the direction, you can add it to the pageParam\n       */\n      direction: FetchDirection\n      meta: QueryMeta | undefined\n    }\n\n/** @inline */\nexport type InitialDataFunction<T> = () => T | undefined\n\ntype NonFunctionGuard<T> = T extends Function ? never : T\n\n/** @inline */\nexport type PlaceholderDataFunction<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = (\n  previousData: TQueryData | undefined,\n  previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined,\n) => TQueryData | undefined\n\nexport type QueriesPlaceholderDataFunction<TQueryData> = (\n  previousData: undefined,\n  previousQuery: undefined,\n) => TQueryData | undefined\n\n/** @inline */\nexport type QueryKeyHashFunction<TQueryKey extends QueryKey> = (\n  queryKey: TQueryKey,\n) => string\n\n/** @inline */\nexport type GetPreviousPageParamFunction<TPageParam, TQueryFnData = unknown> = (\n  firstPage: TQueryFnData,\n  allPages: Array<TQueryFnData>,\n  firstPageParam: TPageParam,\n  allPageParams: Array<TPageParam>,\n) => TPageParam | undefined | null\n\n/** @inline */\nexport type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (\n  lastPage: TQueryFnData,\n  allPages: Array<TQueryFnData>,\n  lastPageParam: TPageParam,\n  allPageParams: Array<TPageParam>,\n) => TPageParam | undefined | null\n\n/**\n * The data shape of an infinite query: every page fetched so far, plus the page param each one was fetched with.\n * `pages` and `pageParams` are index-aligned — `pageParams[i]` is the param that produced `pages[i]`.\n */\nexport interface InfiniteData<TData, TPageParam = unknown> {\n  pages: Array<TData>\n  pageParams: Array<TPageParam>\n}\n\n/**\n * The type of the `meta` object that can be attached to a query and read back from `queryFn`, callbacks and\n * cache-level handlers. Defaults to `Record<string, unknown>`; declare `queryMeta` on {@link Register} to narrow it.\n */\nexport type QueryMeta = Register extends {\n  queryMeta: infer TQueryMeta\n}\n  ? TQueryMeta extends Record<string, unknown>\n    ? TQueryMeta\n    : Record<string, unknown>\n  : Record<string, unknown>\n\n/** @inline */\nexport type NetworkMode = 'online' | 'always' | 'offlineFirst'\n\n/** @inline */\nexport type NotifyOnChangeProps =\n  | Array<keyof InfiniteQueryObserverResult>\n  | 'all'\n  | undefined\n  | (() => Array<keyof InfiniteQueryObserverResult> | 'all' | undefined)\n\nexport interface QueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> {\n  /**\n   * If `false`, failed queries will not retry by default.\n   * If `true`, failed queries will retry infinitely.\n   * If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.\n   * If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.\n   *\n   * Defaults to `3` on the client and `0` on the server.\n   */\n  retry?: RetryValue<TError>\n  /**\n   * This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the\n   * next attempt in milliseconds.\n   *\n   * A function like `attempt => Math.min(attempt > 1 ? 2 ** attempt * 1000 : 1000, 30 * 1000)` applies exponential\n   * backoff.\n   *\n   * A function like `attempt => attempt * 1000` applies linear backoff.\n   *\n   * Defaults to a function that applies exponential backoff, capped at 30 seconds.\n   */\n  retryDelay?: RetryDelayValue<TError>\n  /**\n   * Controls whether a query is allowed to run based on the current network connectivity.\n   *\n   * @defaultValue 'online'\n   * @see [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.\n   */\n  networkMode?: NetworkMode\n  /**\n   * The time in milliseconds that unused/inactive cache data remains in memory.\n   * When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.\n   * When different garbage collection times are specified, the longest one will be used.\n   * Setting it to `Infinity` will disable garbage collection.\n   *\n   * Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.\n   *\n   * Note: the maximum allowed time is about 24 days, imposed by `setTimeout`'s 32-bit signed integer delay — see\n   * `timeoutManager.setTimeoutProvider` for a workaround.\n   */\n  gcTime?: number\n  /**\n   * The function that the query will use to request data.\n   * Required, unless a default query function has been set via `queryClient.setQueryDefaults` or\n   * `queryClient.setDefaultOptions`.\n   * Receives a {@link QueryFunctionContext}.\n   * Must return a promise that will either resolve data or throw an error. The data cannot be `undefined`.\n   */\n  queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | SkipToken\n  /**\n   * This option can be used to persist the result of a query to an external storage, bypassing the need to actually\n   * call the `queryFn`. Useful for persisting a query's data across e.g. server/client boundaries.\n   */\n  persister?: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>\n  /**\n   * The hashed form of `queryKey`, computed with `queryKeyHashFn` (or the default hashing function otherwise). Used\n   * as the actual cache key internally.\n   */\n  queryHash?: string\n  /**\n   * The query key to use for this query.\n   *\n   * The query key will be hashed into a stable hash. See [Query Keys](https://tanstack.com/query/latest/docs/framework/react/guides/query-keys)\n   * for more information.\n   *\n   * The query will automatically update when this key changes (as long as `enabled` is not set to `false`).\n   */\n  queryKey?: TQueryKey\n  /**\n   * If specified, this function is used to hash the `queryKey` to a string.\n   */\n  queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>\n  /**\n   * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been\n   * created or cached yet).\n   * If set to a function, the function will be called **once** during the shared/root query initialization, and be\n   * expected to synchronously return the initial data.\n   * Initial data is considered stale by default unless a `staleTime` has been set.\n   * `initialData` **is persisted** to the cache.\n   */\n  initialData?: TData | InitialDataFunction<TData>\n  /**\n   * If set, this value will be used as the time (in milliseconds) of when the `initialData` itself was last updated.\n   */\n  initialDataUpdatedAt?: number | (() => number | undefined)\n  /** @internal */\n  behavior?: QueryBehavior<TQueryFnData, TError, TData, TQueryKey>\n  /**\n   * Set this to `false` to disable structural sharing between query results.\n   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.\n   *\n   * @defaultValue true\n   */\n  structuralSharing?:\n    | boolean\n    | ((oldData: unknown | undefined, newData: unknown) => unknown)\n  /** @internal */\n  _defaulted?: boolean\n  /** @internal */\n  _type?: 'infinite'\n  /**\n   * Additional payload to be stored on each query.\n   * Use this property to pass information that can be used in other places.\n   */\n  meta?: QueryMeta\n  /**\n   * Maximum number of pages to store in the data of an infinite query.\n   */\n  maxPages?: number\n}\n\nexport interface InitialPageParam<TPageParam = unknown> {\n  /**\n   * The page param to start from when an infinite query has no pages yet.\n   * It is passed to `queryFn` as `pageParam` for the first page; every page after that gets the\n   * value returned by `getNextPageParam` or `getPreviousPageParam`.\n   * It only applies while the query has no pages: once a first page exists, refetching starts from\n   * that page's own param instead.\n   */\n  initialPageParam: TPageParam\n}\n\nexport interface InfiniteQueryPageParamsOptions<\n  TQueryFnData = unknown,\n  TPageParam = unknown,\n> extends InitialPageParam<TPageParam> {\n  /**\n   * This function can be set to automatically get the previous cursor for infinite queries.\n   * The result will also be used to determine the value of `hasPreviousPage`.\n   */\n  getPreviousPageParam?: GetPreviousPageParamFunction<TPageParam, TQueryFnData>\n  /**\n   * This function can be set to automatically get the next cursor for infinite queries.\n   * The result will also be used to determine the value of `hasNextPage`.\n   */\n  getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>\n}\n\n/** @inline */\nexport type ThrowOnError<\n  TQueryFnData,\n  TError,\n  TQueryData,\n  TQueryKey extends QueryKey,\n> =\n  | boolean\n  | ((\n      error: TError,\n      query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n    ) => boolean)\n\nexport interface QueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends WithRequired<\n  QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>,\n  'queryKey'\n> {\n  /**\n   * Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.\n   * To refetch the query, use the `refetch` method returned from the `useQuery` instance.\n   * Accepts a boolean or function that returns a boolean.\n   *\n   * @defaultValue true\n   */\n  enabled?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>\n  /**\n   * The time in milliseconds after data is considered stale.\n   * If set to `Infinity`, the data will never be considered stale.\n   * If set to `'static'`, the data will never be considered stale.\n   * If set to a function, the function will be executed with the query to compute a `staleTime`.\n   *\n   * @defaultValue 0\n   */\n  staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>\n  /**\n   * If set to a number, the query will continuously refetch at this frequency in milliseconds.\n   * If set to a function, the function will be executed with the latest data and query to compute a frequency\n   *\n   * @defaultValue false\n   */\n  refetchInterval?:\n    | number\n    | false\n    | ((\n        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n      ) => number | false | undefined)\n  /**\n   * If set to `true`, the query will continue to refetch while their tab/window is in the background.\n   *\n   * @defaultValue false\n   */\n  refetchIntervalInBackground?: boolean\n  /**\n   * If set to `true`, the query will refetch on window focus if the data is stale.\n   * If set to `false`, the query will not refetch on window focus.\n   * If set to `'always'`, the query will always refetch on window focus (except when `staleTime: 'static'` is used).\n   * If set to a function, the function will be executed with the latest data and query to compute the value.\n   *\n   * @defaultValue true\n   */\n  refetchOnWindowFocus?:\n    | boolean\n    | 'always'\n    | ((\n        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n      ) => boolean | 'always')\n  /**\n   * If set to `true`, the query will refetch on reconnect if the data is stale.\n   * If set to `false`, the query will not refetch on reconnect.\n   * If set to `'always'`, the query will always refetch on reconnect (except when `staleTime: 'static'` is used).\n   * If set to a function, the function will be executed with the latest data and query to compute the value.\n   *\n   * Defaults to `true` unless `networkMode` is `'always'`.\n   */\n  refetchOnReconnect?:\n    | boolean\n    | 'always'\n    | ((\n        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n      ) => boolean | 'always')\n  /**\n   * If set to `true`, the query will refetch on mount if the data is stale.\n   * If set to `false`, will disable additional instances of a query to trigger background refetch.\n   * If set to `'always'`, the query will always refetch on mount (except when `staleTime: 'static'` is used).\n   * If set to a function, the function will be executed with the latest data and query to compute the value\n   *\n   * @defaultValue true\n   */\n  refetchOnMount?:\n    | boolean\n    | 'always'\n    | ((\n        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n      ) => boolean | 'always')\n  /**\n   * If set to `false`, the query will not be retried on mount if it contains an error.\n   * If set to a function, the function will be executed with the query to compute the value.\n   *\n   * @defaultValue true\n   */\n  retryOnMount?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>\n  /**\n   * If set, the component will only re-render if any of the listed properties change.\n   * When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.\n   * When set to `'all'`, the component will re-render whenever a query is updated.\n   * When set to a function, the function will be executed to compute the list of properties.\n   *\n   * Defaults to `undefined`, in which case property access is tracked automatically, and the\n   * component only re-renders when one of the tracked properties changes.\n   */\n  notifyOnChangeProps?: NotifyOnChangeProps\n  /**\n   * Whether errors should be thrown instead of setting the `error` property.\n   * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.\n   * If set to `false` and `suspense` is `false`, errors are returned as state.\n   * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).\n   *\n   * @defaultValue false\n   */\n  throwOnError?: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n  /**\n   * This option can be used to transform or select a part of the data returned by the query function. It affects\n   * the returned `data` value, but does not affect what gets stored in the query cache.\n   * The `select` function will only run if `data` changed, or if the reference to the `select` function itself\n   * changes. To optimize, memoize the function so its reference stays stable across calls.\n   */\n  select?: (data: TQueryData) => TData\n  /**\n   * If set to `true`, the query will suspend when `status === 'pending'`\n   * and throw errors when `status === 'error'`.\n   *\n   * @defaultValue false\n   */\n  suspense?: boolean\n  /**\n   * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.\n   */\n  placeholderData?:\n    | NonFunctionGuard<TQueryData>\n    | PlaceholderDataFunction<\n        NonFunctionGuard<TQueryData>,\n        TError,\n        NonFunctionGuard<TQueryData>,\n        TQueryKey\n      >\n\n  /** @internal */\n  _optimisticResults?: 'optimistic' | 'isRestoring'\n}\n\nexport type WithRequired<TTarget, TKey extends keyof TTarget> = TTarget & {\n  [_ in TKey]: {}\n}\n\nexport type DefaultedQueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = WithRequired<\n  QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n  'throwOnError' | 'refetchOnReconnect' | 'queryHash'\n>\n\nexport interface InfiniteQueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>\n  extends\n    QueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey,\n      TPageParam\n    >,\n    InfiniteQueryPageParamsOptions<TQueryFnData, TPageParam> {}\n\nexport type DefaultedInfiniteQueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = WithRequired<\n  InfiniteQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  'throwOnError' | 'refetchOnReconnect' | 'queryHash'\n>\n\nexport interface QueryExecuteOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends WithRequired<\n  QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>,\n  'queryKey'\n> {\n  initialPageParam?: never\n  /**\n   * This option can be used to transform or select a part of the data returned by the query function. It affects\n   * the value this call resolves with, but does not affect what gets stored in the query cache.\n   */\n  select?: (data: TQueryData) => TData\n  /**\n   * The time in milliseconds after data is considered stale.\n   * If the data is fresh it will be returned from the cache.\n   */\n  staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>\n}\n\n/** @deprecated */\nexport interface FetchQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends WithRequired<\n  QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n  'queryKey'\n> {\n  initialPageParam?: never\n  /**\n   * The time in milliseconds after data is considered stale.\n   * If the data is fresh it will be returned from the cache.\n   */\n  staleTime?: StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>\n}\n\n/** @deprecated */\nexport interface EnsureQueryDataOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends FetchQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> {\n  revalidateIfStale?: boolean\n}\n\n/** @deprecated */\nexport type EnsureInfiniteQueryDataOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = FetchInfiniteQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> & {\n  revalidateIfStale?: boolean\n}\n\ntype InfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> =\n  | { pages?: never }\n  | {\n      pages: number\n      getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>\n    }\n\nexport type InfiniteQueryExecuteOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = Omit<\n  QueryExecuteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    InfiniteData<TQueryFnData, TPageParam>,\n    TQueryKey,\n    TPageParam\n  >,\n  'initialPageParam'\n> &\n  InitialPageParam<TPageParam> &\n  InfiniteQueryPages<TQueryFnData, TPageParam>\n\n/** @deprecated */\nexport type FetchInfiniteQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = Omit<\n  FetchQueryOptions<\n    TQueryFnData,\n    TError,\n    InfiniteData<TData, TPageParam>,\n    TQueryKey,\n    TPageParam\n  >,\n  'initialPageParam'\n> &\n  InitialPageParam<TPageParam> &\n  InfiniteQueryPages<TQueryFnData, TPageParam>\n\nexport interface ResultOptions {\n  /**\n   * If set to `true`, the method throws if any of the underlying query refetch tasks fail.\n   * If set to `false`, failed refetches are swallowed and not surfaced to the caller.\n   *\n   * @defaultValue false\n   */\n  throwOnError?: boolean\n}\n\nexport interface RefetchOptions extends ResultOptions {\n  /**\n   * If set to `true`, a currently running request will be cancelled before a new request is made\n   *\n   * If set to `false`, no refetch will be made if there is already a request running.\n   *\n   * @defaultValue true\n   */\n  cancelRefetch?: boolean\n}\n\nexport interface InvalidateQueryFilters<\n  TQueryKey extends QueryKey = QueryKey,\n> extends QueryFilters<TQueryKey> {\n  /**\n   * Controls which of the matched (now-invalidated) queries are refetched in the background.\n   *\n   * - `'active'`: only queries with at least one active observer are refetched.\n   * - `'inactive'`: only queries with no active observer are refetched.\n   * - `'all'`: every matched query is refetched, active or not.\n   * - `'none'`: no query is refetched; matched queries are only marked as invalidated.\n   *\n   * @defaultValue 'active'\n   */\n  refetchType?: QueryTypeFilter | 'none'\n}\n\nexport interface RefetchQueryFilters<\n  TQueryKey extends QueryKey = QueryKey,\n> extends QueryFilters<TQueryKey> {}\n\nexport interface InvalidateOptions extends RefetchOptions {}\nexport interface ResetOptions extends RefetchOptions {}\n\nexport interface FetchNextPageOptions extends ResultOptions {\n  /**\n   * If set to `true`, calling `fetchNextPage` repeatedly will invoke `queryFn` every time,\n   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.\n   *\n   * If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.\n   *\n   * @defaultValue true\n   */\n  cancelRefetch?: boolean\n}\n\nexport interface FetchPreviousPageOptions extends ResultOptions {\n  /**\n   * If set to `true`, calling `fetchPreviousPage` repeatedly will invoke `queryFn` every time,\n   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.\n   *\n   * If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.\n   *\n   * @defaultValue true\n   */\n  cancelRefetch?: boolean\n}\n\n/** @inline */\nexport type QueryStatus = 'pending' | 'error' | 'success'\n/** @inline */\nexport type FetchStatus = 'fetching' | 'paused' | 'idle'\n\nexport interface QueryObserverBaseResult<\n  TData = unknown,\n  TError = DefaultError,\n> {\n  /**\n   * The last successfully resolved data for the query.\n   */\n  data: TData | undefined\n  /**\n   * The timestamp for when the query most recently returned the `status` as `\"success\"`.\n   */\n  dataUpdatedAt: number\n  /**\n   * The error object for the query, if an error was thrown.\n   * - Defaults to `null`.\n   */\n  error: TError | null\n  /**\n   * The timestamp for when the query most recently returned the `status` as `\"error\"`.\n   */\n  errorUpdatedAt: number\n  /**\n   * The failure count for the query.\n   * - Incremented every time the query fails.\n   * - Reset to `0` when the query succeeds.\n   */\n  failureCount: number\n  /**\n   * The failure reason for the query retry.\n   * - Reset to `null` when the query succeeds.\n   */\n  failureReason: TError | null\n  /**\n   * The sum of all errors.\n   */\n  errorUpdateCount: number\n  /**\n   * A derived boolean from the `status` variable, provided for convenience.\n   * - `true` if the query attempt resulted in an error.\n   */\n  isError: boolean\n  /**\n   * Will be `true` if the query has been fetched.\n   */\n  isFetched: boolean\n  /**\n   * Will be `true` if the query has been fetched after the component mounted.\n   * - This property can be used to not show any previously cached data.\n   */\n  isFetchedAfterMount: boolean\n  /**\n   * A derived boolean from the `fetchStatus` variable, provided for convenience.\n   * - `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.\n   */\n  isFetching: boolean\n  /**\n   * Is `true` whenever the first fetch for a query is in-flight.\n   * - Is the same as `isFetching && isPending`.\n   */\n  isLoading: boolean\n  /**\n   * Will be `pending` if there's no cached data and no query attempt was finished yet.\n   */\n  isPending: boolean\n  /**\n   * Will be `true` if the query failed while fetching for the first time.\n   */\n  isLoadingError: boolean\n  /**\n   * @deprecated `isInitialLoading` is being deprecated in favor of `isLoading`\n   * and will be removed in the next major version.\n   */\n  isInitialLoading: boolean\n  /**\n   * A derived boolean from the `fetchStatus` variable, provided for convenience.\n   * - The query wanted to fetch, but has been `paused`.\n   */\n  isPaused: boolean\n  /**\n   * Will be `true` if the data shown is the placeholder data.\n   */\n  isPlaceholderData: boolean\n  /**\n   * Will be `true` if the query failed while refetching.\n   */\n  isRefetchError: boolean\n  /**\n   * Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.\n   * - Is the same as `isFetching && !isPending`.\n   */\n  isRefetching: boolean\n  /**\n   * Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.\n   */\n  isStale: boolean\n  /**\n   * A derived boolean from the `status` variable, provided for convenience.\n   * - `true` if the query has received a response with no errors and is ready to display its data.\n   */\n  isSuccess: boolean\n  /**\n   * `true` if this observer is enabled, `false` otherwise.\n   */\n  isEnabled: boolean\n  /**\n   * A function to manually refetch the query.\n   */\n  refetch: (\n    options?: RefetchOptions,\n  ) => Promise<QueryObserverResult<TData, TError>>\n  /**\n   * The status of the query.\n   * - Will be:\n   *   - `pending` if there's no cached data and no query attempt was finished yet.\n   *   - `error` if the query attempt resulted in an error.\n   *   - `success` if the query has received a response with no errors and is ready to display its data.\n   */\n  status: QueryStatus\n  /**\n   * The fetch status of the query.\n   * - `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.\n   * - `paused`: The query wanted to fetch, but has been `paused`.\n   * - `idle`: The query is not fetching.\n   * - See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.\n   */\n  fetchStatus: FetchStatus\n}\n\nexport interface QueryObserverPendingResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: null\n  isError: false\n  isPending: true\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'pending'\n}\n\nexport interface QueryObserverLoadingResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: null\n  isError: false\n  isPending: true\n  isLoading: true\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'pending'\n}\n\nexport interface QueryObserverLoadingErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: TError\n  isError: true\n  isPending: false\n  isLoading: false\n  isLoadingError: true\n  isRefetchError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'error'\n}\n\nexport interface QueryObserverRefetchErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: TData\n  error: TError\n  isError: true\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: true\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'error'\n}\n\nexport interface QueryObserverSuccessResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: TData\n  error: null\n  isError: false\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: true\n  isPlaceholderData: false\n  status: 'success'\n}\n\nexport interface QueryObserverPlaceholderResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: TData\n  isError: false\n  error: null\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: true\n  isPlaceholderData: true\n  status: 'success'\n}\n\nexport type DefinedQueryObserverResult<\n  TData = unknown,\n  TError = DefaultError,\n> =\n  | QueryObserverRefetchErrorResult<TData, TError>\n  | QueryObserverSuccessResult<TData, TError>\n\nexport type QueryObserverResult<TData = unknown, TError = DefaultError> =\n  | DefinedQueryObserverResult<TData, TError>\n  | QueryObserverLoadingErrorResult<TData, TError>\n  | QueryObserverLoadingResult<TData, TError>\n  | QueryObserverPendingResult<TData, TError>\n  | QueryObserverPlaceholderResult<TData, TError>\n\nexport interface InfiniteQueryObserverBaseResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  /**\n   * This function allows you to fetch the next \"page\" of results.\n   */\n  fetchNextPage: (\n    options?: FetchNextPageOptions,\n  ) => Promise<InfiniteQueryObserverResult<TData, TError>>\n  /**\n   * This function allows you to fetch the previous \"page\" of results.\n   */\n  fetchPreviousPage: (\n    options?: FetchPreviousPageOptions,\n  ) => Promise<InfiniteQueryObserverResult<TData, TError>>\n  /**\n   * Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).\n   */\n  hasNextPage: boolean\n  /**\n   * Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).\n   */\n  hasPreviousPage: boolean\n  /**\n   * Will be `true` if the query failed while fetching the next page.\n   */\n  isFetchNextPageError: boolean\n  /**\n   * Will be `true` while fetching the next page with `fetchNextPage`.\n   */\n  isFetchingNextPage: boolean\n  /**\n   * Will be `true` if the query failed while fetching the previous page.\n   */\n  isFetchPreviousPageError: boolean\n  /**\n   * Will be `true` while fetching the previous page with `fetchPreviousPage`.\n   */\n  isFetchingPreviousPage: boolean\n}\n\nexport interface InfiniteQueryObserverPendingResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: null\n  isError: false\n  isPending: true\n  isLoadingError: false\n  isRefetchError: false\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'pending'\n}\n\nexport interface InfiniteQueryObserverLoadingResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: null\n  isError: false\n  isPending: true\n  isLoading: true\n  isLoadingError: false\n  isRefetchError: false\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'pending'\n}\n\nexport interface InfiniteQueryObserverLoadingErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: TError\n  isError: true\n  isPending: false\n  isLoading: false\n  isLoadingError: true\n  isRefetchError: false\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'error'\n}\n\nexport interface InfiniteQueryObserverRefetchErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: TData\n  error: TError\n  isError: true\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: true\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'error'\n}\n\nexport interface InfiniteQueryObserverSuccessResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: TData\n  error: null\n  isError: false\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: false\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  isSuccess: true\n  isPlaceholderData: false\n  status: 'success'\n}\n\nexport interface InfiniteQueryObserverPlaceholderResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: TData\n  isError: false\n  error: null\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: true\n  isPlaceholderData: true\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  status: 'success'\n}\n\nexport type DefinedInfiniteQueryObserverResult<\n  TData = unknown,\n  TError = DefaultError,\n> =\n  | InfiniteQueryObserverRefetchErrorResult<TData, TError>\n  | InfiniteQueryObserverSuccessResult<TData, TError>\n\nexport type InfiniteQueryObserverResult<\n  TData = unknown,\n  TError = DefaultError,\n> =\n  | DefinedInfiniteQueryObserverResult<TData, TError>\n  | InfiniteQueryObserverLoadingErrorResult<TData, TError>\n  | InfiniteQueryObserverLoadingResult<TData, TError>\n  | InfiniteQueryObserverPendingResult<TData, TError>\n  | InfiniteQueryObserverPlaceholderResult<TData, TError>\n\n/**\n * The type of a mutation key — the serializable array used to identify and filter mutations.\n * Defaults to `ReadonlyArray<unknown>`; declare `mutationKey` on {@link Register} to narrow it repository-wide.\n */\nexport type MutationKey = Register extends {\n  mutationKey: infer TMutationKey\n}\n  ? TMutationKey extends ReadonlyArray<unknown>\n    ? TMutationKey\n    : TMutationKey extends Array<unknown>\n      ? TMutationKey\n      : ReadonlyArray<unknown>\n  : ReadonlyArray<unknown>\n\n/** @inline */\nexport type MutationStatus = 'idle' | 'pending' | 'success' | 'error'\n\n/**\n * Groups mutations so they run one after another instead of in parallel.\n * Mutations that share the same `id` form a queue: while one is running, the others wait in `isPaused: true`\n * state and resume automatically when their turn comes. Mutations with no scope always run in parallel.\n */\nexport type MutationScope = {\n  id: string\n}\n\n/**\n * The type of the `meta` object that can be attached to a mutation and read back from `mutationFn`, callbacks and\n * cache-level handlers. Defaults to `Record<string, unknown>`; declare `mutationMeta` on {@link Register} to narrow it.\n */\nexport type MutationMeta = Register extends {\n  mutationMeta: infer TMutationMeta\n}\n  ? TMutationMeta extends Record<string, unknown>\n    ? TMutationMeta\n    : Record<string, unknown>\n  : Record<string, unknown>\n\nexport type MutationFunctionContext = {\n  client: QueryClient\n  meta: MutationMeta | undefined\n  mutationKey?: MutationKey\n}\n\n/** @inline */\nexport type MutationFunction<TData = unknown, TVariables = unknown> = (\n  variables: TVariables,\n  context: MutationFunctionContext,\n) => Promise<TData>\n\nexport interface MutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> {\n  /**\n   * The function that performs the asynchronous task this mutation runs.\n   * Required, unless a default mutation function has been set for the matching `mutationKey` via\n   * `queryClient.setMutationDefaults`.\n   * Receives the `variables` passed to `mutate`, and a {@link MutationFunctionContext} holding the\n   * `QueryClient`, the `mutationKey` and `meta`.\n   * Must return a promise that resolves the mutation's data.\n   */\n  mutationFn?: MutationFunction<TData, TVariables>\n  /**\n   * The key to use for this mutation. Optional, but required to inherit defaults registered with\n   * `queryClient.setMutationDefaults`, and to match this mutation with `useMutationState` or\n   * `queryClient.isMutating`.\n   */\n  mutationKey?: MutationKey\n  /**\n   * This function fires before the mutation function runs, and receives the same variables.\n   * Useful for optimistic updates applied in the hope that the mutation succeeds.\n   * The value it returns is passed to `onSuccess`, `onError` and `onSettled` as `onMutateResult`,\n   * which is where an optimistic update is usually rolled back.\n   * If a promise is returned, it is awaited before the mutation function runs.\n   */\n  onMutate?: (\n    variables: TVariables,\n    context: MutationFunctionContext,\n  ) => Promise<TOnMutateResult> | TOnMutateResult\n  /**\n   * This function fires when the mutation succeeds, and is passed the mutation's result.\n   * If a promise is returned, it is awaited before `onSettled` runs.\n   */\n  onSuccess?: (\n    data: TData,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /**\n   * This function fires when the mutation encounters an error, and is passed the error.\n   * If a promise is returned, it is awaited before `onSettled` runs.\n   */\n  onError?: (\n    error: TError,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /**\n   * This function fires when the mutation either succeeds or errors, and is passed either the data\n   * or the error.\n   * If a promise is returned, it is awaited before the mutation settles.\n   */\n  onSettled?: (\n    data: TData | undefined,\n    error: TError | null,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /**\n   * If `false`, failed mutations will not retry by default.\n   * If `true`, failed mutations will retry infinitely.\n   * If set to an integer number, e.g. 3, failed mutations will retry until the failed mutation count meets that number.\n   * If set to a function `(failureCount, error) => boolean` failed mutations will retry until the function returns false.\n   *\n   * @defaultValue 0\n   */\n  retry?: RetryValue<TError>\n  /**\n   * This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the\n   * next attempt in milliseconds.\n   *\n   * Defaults to a function that applies exponential backoff, capped at 30 seconds.\n   */\n  retryDelay?: RetryDelayValue<TError>\n  /**\n   * Controls whether a mutation is allowed to run based on the current network connectivity.\n   *\n   * @defaultValue 'online'\n   * @see [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.\n   */\n  networkMode?: NetworkMode\n  /**\n   * The time in milliseconds that an unused/inactive mutation remains in memory before it is\n   * garbage collected.\n   *\n   * Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.\n   */\n  gcTime?: number\n  /** @internal */\n  _defaulted?: boolean\n  /**\n   * Additional payload to be stored on the mutation cache entry.\n   * Use it to pass information that can be read wherever the `mutation` is available, such as the\n   * `onError` and `onSuccess` callbacks of the `MutationCache`.\n   */\n  meta?: MutationMeta\n  /**\n   * Controls whether this mutation runs alongside others or waits its turn.\n   * Mutations sharing the same `scope.id` run serially, in the order they were started.\n   * Without a scope, a mutation runs as soon as it is triggered.\n   */\n  scope?: MutationScope\n}\n\nexport interface MutationObserverOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationOptions<TData, TError, TVariables, TOnMutateResult> {\n  /**\n   * Whether errors should be thrown instead of setting the `error` property.\n   * If set to `true`, all errors will be thrown to the nearest error boundary.\n   * If set to a function, it will be passed the error and should return a boolean indicating whether to throw the\n   * error (`true`) or return it as state (`false`).\n   *\n   * @defaultValue false\n   */\n  throwOnError?: boolean | ((error: TError) => boolean)\n}\n\nexport interface MutateOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> {\n  onSuccess?: (\n    data: TData,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => void\n  onError?: (\n    error: TError,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => void\n  onSettled?: (\n    data: TData | undefined,\n    error: TError | null,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => void\n}\n\nexport type MutateFunctionRest<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> = undefined extends TVariables\n  ? [\n      variables?: TVariables,\n      options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>,\n    ]\n  : [\n      variables: TVariables,\n      options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>,\n    ]\n\nexport type MutateFunction<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> = (\n  ...rest: MutateFunctionRest<TData, TError, TVariables, TOnMutateResult>\n) => Promise<TData>\n\nexport interface MutationObserverBaseResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationState<TData, TError, TVariables, TOnMutateResult> {\n  /**\n   * The last successfully resolved data for the mutation.\n   */\n  data: TData | undefined\n  /**\n   * The variables object passed to the `mutationFn`.\n   */\n  variables: TVariables | undefined\n  /**\n   * The error object for the mutation, if an error was encountered.\n   * - Defaults to `null`.\n   */\n  error: TError | null\n  /**\n   * A boolean variable derived from `status`.\n   * - `true` if the last mutation attempt resulted in an error.\n   */\n  isError: boolean\n  /**\n   * A boolean variable derived from `status`.\n   * - `true` if the mutation is in its initial state prior to executing.\n   */\n  isIdle: boolean\n  /**\n   * A boolean variable derived from `status`.\n   * - `true` if the mutation is currently executing.\n   */\n  isPending: boolean\n  /**\n   * A boolean variable derived from `status`.\n   * - `true` if the last mutation attempt was successful.\n   */\n  isSuccess: boolean\n  /**\n   * The status of the mutation.\n   * - Will be:\n   *   - `idle` initial status prior to the mutation function executing.\n   *   - `pending` if the mutation is currently executing.\n   *   - `error` if the last mutation attempt resulted in an error.\n   *   - `success` if the last mutation attempt was successful.\n   */\n  status: MutationStatus\n  /**\n   * The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.\n   * @param variables - The variables object to pass to the `mutationFn`.\n   * @param options.onSuccess - This function will fire when the mutation is successful and will be passed the mutation's result.\n   * @param options.onError - This function will fire if the mutation encounters an error and will be passed the error.\n   * @param options.onSettled - This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.\n   * @remarks\n   * - If you make multiple requests, `onSuccess` will fire only after the latest call you've made.\n   * - All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.\n   */\n  mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>\n  /**\n   * A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).\n   */\n  reset: () => void\n}\n\nexport interface MutationObserverIdleResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult\n> {\n  data: undefined\n  variables: undefined\n  error: null\n  isError: false\n  isIdle: true\n  isPending: false\n  isSuccess: false\n  status: 'idle'\n}\n\nexport interface MutationObserverLoadingResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult\n> {\n  data: undefined\n  variables: TVariables\n  error: null\n  isError: false\n  isIdle: false\n  isPending: true\n  isSuccess: false\n  status: 'pending'\n}\n\nexport interface MutationObserverErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult\n> {\n  data: undefined\n  error: TError\n  variables: TVariables\n  isError: true\n  isIdle: false\n  isPending: false\n  isSuccess: false\n  status: 'error'\n}\n\nexport interface MutationObserverSuccessResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult\n> {\n  data: TData\n  error: null\n  variables: TVariables\n  isError: false\n  isIdle: false\n  isPending: false\n  isSuccess: true\n  status: 'success'\n}\n\nexport type MutationObserverResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> =\n  | MutationObserverIdleResult<TData, TError, TVariables, TOnMutateResult>\n  | MutationObserverLoadingResult<TData, TError, TVariables, TOnMutateResult>\n  | MutationObserverErrorResult<TData, TError, TVariables, TOnMutateResult>\n  | MutationObserverSuccessResult<TData, TError, TVariables, TOnMutateResult>\n\nexport interface QueryClientConfig {\n  /** The query cache this client is connected to. A new `QueryCache` is created if not provided. */\n  queryCache?: QueryCache\n  /**\n   * The mutation cache this client is connected to. A new `MutationCache` is created if not\n   * provided.\n   */\n  mutationCache?: MutationCache\n  /** Default options for all queries and mutations created through this client. */\n  defaultOptions?: DefaultOptions\n}\n\nexport interface DefaultOptions<TError = DefaultError> {\n  /** Default options applied to every query, unless overridden per-query. */\n  queries?: OmitKeyof<\n    QueryObserverOptions<unknown, TError>,\n    'suspense' | 'queryKey'\n  >\n  /** Default options applied to every mutation, unless overridden per-mutation. */\n  mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>\n  /** Default options used when hydrating queries; see {@link HydrateOptions}. */\n  hydrate?: HydrateOptions['defaultOptions']\n  /** Default options used when dehydrating the client's caches; see {@link DehydrateOptions}. */\n  dehydrate?: DehydrateOptions\n}\n\n/**\n * Options for cancelling an in-flight fetch, e.g. via `query.cancel()`.\n * They are carried on the {@link CancelledError} that the cancelled fetch rejects with.\n */\nexport interface CancelOptions {\n  revert?: boolean\n  silent?: boolean\n}\n\n/**\n * Options for writing data into the cache, e.g. via `queryClient.setQueryData()`.\n * `updatedAt` overrides the timestamp the data is recorded with, which is what staleness is measured from;\n * omit it to use the current time.\n */\nexport interface SetDataOptions {\n  updatedAt?: number\n}\n\n/** @inline */\nexport type NotifyEventType =\n  | 'added'\n  | 'removed'\n  | 'updated'\n  | 'observerAdded'\n  | 'observerRemoved'\n  | 'observerResultsUpdated'\n  | 'observerOptionsUpdated'\n\nexport interface NotifyEvent {\n  type: NotifyEventType\n}\n"],"mappings":";;;AAuFA,MAAa,gBAAgB,OAAO;AAEpC,MAAa,qBAAqB,OAAO;AAEzC,MAAa,cAAc,OAAO"}
+{"version":3,"file":"types.cjs","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/* istanbul ignore file */\n\nimport type { QueryClient } from './queryClient'\nimport type { DehydrateOptions, HydrateOptions } from './hydration'\nimport type { MutationState } from './mutation'\nimport type { FetchDirection, Query, QueryBehavior } from './query'\nimport type { RetryDelayValue, RetryValue } from './retryer'\nimport type { QueryFilters, QueryTypeFilter, SkipToken } from './utils'\nimport type { QueryCache } from './queryCache'\nimport type { MutationCache } from './mutationCache'\n\nexport type NonUndefinedGuard<T> = T extends undefined ? never : T\n\nexport type DistributiveOmit<\n  TObject,\n  TKey extends keyof TObject,\n> = TObject extends any ? Omit<TObject, TKey> : never\n\nexport type OmitKeyof<\n  TObject,\n  TKey extends (TStrictly extends 'safely'\n    ? | keyof TObject\n      | (string & Record<never, never>)\n      | (number & Record<never, never>)\n      | (symbol & Record<never, never>)\n    : keyof TObject),\n  TStrictly extends 'strictly' | 'safely' = 'strictly',\n> = Omit<TObject, TKey>\n\nexport type Override<TTargetA, TTargetB> = {\n  [AKey in keyof TTargetA]: AKey extends keyof TTargetB\n    ? TTargetB[AKey]\n    : TTargetA[AKey]\n}\n\n/**\n * The interface to augment via declaration merging to override Query's default types repository-wide.\n * Each field it declares replaces the default of the matching type: `defaultError` for {@link DefaultError},\n * `queryKey` for {@link QueryKey}, `mutationKey` for {@link MutationKey}, `queryMeta` for {@link QueryMeta} and\n * `mutationMeta` for {@link MutationMeta}. Leave a field out to keep that type's default.\n * Augment the module you install — `@tanstack/react-query`, `@tanstack/vue-query`,\n * `@tanstack/solid-query`, `@tanstack/svelte-query`, `@tanstack/preact-query`,\n * `@tanstack/angular-query-experimental` or `@tanstack/lit-query`. Augmenting `@tanstack/query-core`\n * works too and covers every adapter at once.\n * @example\n * ```ts\n * // Use the module you installed — here, the React adapter.\n * declare module '@tanstack/react-query' {\n *   interface Register {\n *     defaultError: AxiosError\n *   }\n * }\n * ```\n */\nexport interface Register {\n  // defaultError: Error\n  // queryMeta: Record<string, unknown>\n  // mutationMeta: Record<string, unknown>\n  // queryKey: ReadonlyArray<unknown>\n  // mutationKey: ReadonlyArray<unknown>\n}\n\n/**\n * The error type used wherever an error is not given an explicit type parameter.\n * Defaults to `Error`; declare `defaultError` on {@link Register} to change it everywhere at once.\n */\nexport type DefaultError = Register extends {\n  defaultError: infer TError\n}\n  ? TError\n  : Error\n\n/**\n * The type of a query key — the serializable array that identifies a query in the cache.\n * Defaults to `ReadonlyArray<unknown>`; declare `queryKey` on {@link Register} to narrow it repository-wide.\n */\nexport type QueryKey = Register extends {\n  queryKey: infer TQueryKey\n}\n  ? TQueryKey extends ReadonlyArray<unknown>\n    ? TQueryKey\n    : TQueryKey extends Array<unknown>\n      ? TQueryKey\n      : ReadonlyArray<unknown>\n  : ReadonlyArray<unknown>\n\nexport const dataTagSymbol = Symbol()\nexport type dataTagSymbol = typeof dataTagSymbol\nexport const dataTagErrorSymbol = Symbol()\nexport type dataTagErrorSymbol = typeof dataTagErrorSymbol\nexport const unsetMarker = Symbol()\nexport type UnsetMarker = typeof unsetMarker\nexport type AnyDataTag = {\n  [dataTagSymbol]: any\n  [dataTagErrorSymbol]: any\n}\nexport type DataTag<\n  TType,\n  TValue,\n  TError = UnsetMarker,\n> = TType extends AnyDataTag\n  ? TType\n  : TType & {\n      [dataTagSymbol]: TValue\n      [dataTagErrorSymbol]: TError\n    }\n\nexport type QueryKeyWithDataTag<\n  TQueryKey extends QueryKey = QueryKey,\n  TQueryFnData = unknown,\n  TError = DefaultError,\n> = {\n  queryKey: DataTag<TQueryKey, TQueryFnData, TError>\n}\n\nexport type InferDataFromTag<TQueryFnData, TTaggedQueryKey extends QueryKey> =\n  TTaggedQueryKey extends DataTag<unknown, infer TaggedValue, unknown>\n    ? TaggedValue\n    : TQueryFnData\n\nexport type InferErrorFromTag<TError, TTaggedQueryKey extends QueryKey> =\n  TTaggedQueryKey extends DataTag<unknown, unknown, infer TaggedError>\n    ? TaggedError extends UnsetMarker\n      ? TError\n      : TaggedError\n    : TError\n\n/** @inline */\nexport type QueryFunction<\n  T = unknown,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> = (context: QueryFunctionContext<TQueryKey, TPageParam>) => T | Promise<T>\n\n/** @inline */\nexport type StaleTime = number | 'static'\n\n/** @inline */\nexport type StaleTimeFunction<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> =\n  | StaleTime\n  | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => StaleTime)\n\n/** @inline */\nexport type QueryBooleanOption<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> =\n  boolean | ((query: Query<TQueryFnData, TError, TData, TQueryKey>) => boolean)\n\n/** @inline */\nexport type QueryPersister<\n  T = unknown,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> = [TPageParam] extends [never]\n  ? (\n      queryFn: QueryFunction<T, TQueryKey, never>,\n      context: QueryFunctionContext<TQueryKey>,\n      query: Query,\n    ) => T | Promise<T>\n  : (\n      queryFn: QueryFunction<T, TQueryKey, TPageParam>,\n      context: QueryFunctionContext<TQueryKey>,\n      query: Query,\n    ) => T | Promise<T>\n\nexport type QueryFunctionContext<\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> = [TPageParam] extends [never]\n  ? {\n      client: QueryClient\n      queryKey: TQueryKey\n      signal: AbortSignal\n      meta: QueryMeta | undefined\n      pageParam?: unknown\n      /**\n       * @deprecated\n       * if you want access to the direction, you can add it to the pageParam\n       */\n      direction?: unknown\n    }\n  : {\n      client: QueryClient\n      queryKey: TQueryKey\n      signal: AbortSignal\n      pageParam: TPageParam\n      /**\n       * @deprecated\n       * if you want access to the direction, you can add it to the pageParam\n       */\n      direction: FetchDirection\n      meta: QueryMeta | undefined\n    }\n\n/** @inline */\nexport type InitialDataFunction<T> = () => T | undefined\n\ntype NonFunctionGuard<T> = T extends Function ? never : T\n\n/** @inline */\nexport type PlaceholderDataFunction<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = (\n  previousData: TQueryData | undefined,\n  previousQuery: Query<TQueryFnData, TError, TQueryData, TQueryKey> | undefined,\n) => TQueryData | undefined\n\nexport type QueriesPlaceholderDataFunction<TQueryData> = (\n  previousData: undefined,\n  previousQuery: undefined,\n) => TQueryData | undefined\n\n/** @inline */\nexport type QueryKeyHashFunction<TQueryKey extends QueryKey> = (\n  queryKey: TQueryKey,\n) => string\n\n/** @inline */\nexport type GetPreviousPageParamFunction<TPageParam, TQueryFnData = unknown> = (\n  firstPage: TQueryFnData,\n  allPages: Array<TQueryFnData>,\n  firstPageParam: TPageParam,\n  allPageParams: Array<TPageParam>,\n) => TPageParam | undefined | null\n\n/** @inline */\nexport type GetNextPageParamFunction<TPageParam, TQueryFnData = unknown> = (\n  lastPage: TQueryFnData,\n  allPages: Array<TQueryFnData>,\n  lastPageParam: TPageParam,\n  allPageParams: Array<TPageParam>,\n) => TPageParam | undefined | null\n\n/**\n * The data shape of an infinite query: every page fetched so far, plus the page param each one was fetched with.\n * `pages` and `pageParams` are index-aligned — `pageParams[i]` is the param that produced `pages[i]`.\n */\nexport interface InfiniteData<TData, TPageParam = unknown> {\n  pages: Array<TData>\n  pageParams: Array<TPageParam>\n}\n\n/**\n * The type of the `meta` object that can be attached to a query and read back from `queryFn`, callbacks and\n * cache-level handlers. Defaults to `Record<string, unknown>`; declare `queryMeta` on {@link Register} to narrow it.\n */\nexport type QueryMeta = Register extends {\n  queryMeta: infer TQueryMeta\n}\n  ? TQueryMeta extends Record<string, unknown>\n    ? TQueryMeta\n    : Record<string, unknown>\n  : Record<string, unknown>\n\n/** @inline */\nexport type NetworkMode = 'online' | 'always' | 'offlineFirst'\n\n/** @inline */\nexport type NotifyOnChangeProps =\n  | Array<keyof InfiniteQueryObserverResult>\n  | 'all'\n  | undefined\n  | (() => Array<keyof InfiniteQueryObserverResult> | 'all' | undefined)\n\nexport interface QueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> {\n  /**\n   * If `false`, failed queries will not retry by default.\n   * If `true`, failed queries will retry infinitely.\n   * If set to an integer number, e.g. 3, failed queries will retry until the failed query count meets that number.\n   * If set to a function `(failureCount, error) => boolean` failed queries will retry until the function returns false.\n   *\n   * Defaults to `3` on the client and `0` on the server.\n   */\n  retry?: RetryValue<TError>\n  /**\n   * This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the\n   * next attempt in milliseconds.\n   *\n   * A function like `attempt => Math.min(attempt > 1 ? 2 ** attempt * 1000 : 1000, 30 * 1000)` applies exponential\n   * backoff.\n   *\n   * A function like `attempt => attempt * 1000` applies linear backoff.\n   *\n   * Defaults to a function that applies exponential backoff, capped at 30 seconds.\n   */\n  retryDelay?: RetryDelayValue<TError>\n  /**\n   * Controls whether a query is allowed to run based on the current network connectivity.\n   *\n   * @defaultValue 'online'\n   * @see [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.\n   */\n  networkMode?: NetworkMode\n  /**\n   * The time in milliseconds that unused/inactive cache data remains in memory.\n   * When a query's cache becomes unused or inactive, that cache data will be garbage collected after this duration.\n   * When different garbage collection times are specified, the longest one will be used.\n   * Setting it to `Infinity` will disable garbage collection.\n   *\n   * Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.\n   *\n   * Note: the maximum allowed time is about 24 days, imposed by `setTimeout`'s 32-bit signed integer delay — see\n   * `timeoutManager.setTimeoutProvider` for a workaround.\n   */\n  gcTime?: number\n  /**\n   * The function that the query will use to request data.\n   * Required, unless a default query function has been set via `queryClient.setQueryDefaults` or\n   * `queryClient.setDefaultOptions`.\n   * Receives a {@link QueryFunctionContext}.\n   * Must return a promise that will either resolve data or throw an error. The data cannot be `undefined`.\n   */\n  queryFn?: QueryFunction<TQueryFnData, TQueryKey, TPageParam> | SkipToken\n  /**\n   * This option can be used to persist the result of a query to an external storage, bypassing the need to actually\n   * call the `queryFn`. Useful for persisting a query's data across e.g. server/client boundaries.\n   */\n  persister?: QueryPersister<TQueryFnData, NoInfer<TQueryKey>, TPageParam>\n  /**\n   * The hashed form of `queryKey`, computed with `queryKeyHashFn` (or the default hashing function otherwise). Used\n   * as the actual cache key internally.\n   */\n  queryHash?: string\n  /**\n   * The query key to use for this query.\n   *\n   * The query key will be hashed into a stable hash. See [Query Keys](https://tanstack.com/query/latest/docs/framework/react/guides/query-keys)\n   * for more information.\n   *\n   * The query will automatically update when this key changes (as long as `enabled` is not set to `false`).\n   */\n  queryKey?: TQueryKey\n  /**\n   * If specified, this function is used to hash the `queryKey` to a string.\n   */\n  queryKeyHashFn?: QueryKeyHashFunction<TQueryKey>\n  /**\n   * If set, this value will be used as the initial data for the query cache (as long as the query hasn't been\n   * created or cached yet).\n   * If set to a function, the function will be called **once** during the shared/root query initialization, and be\n   * expected to synchronously return the initial data.\n   * Initial data is considered stale by default unless a `staleTime` has been set.\n   * `initialData` **is persisted** to the cache.\n   */\n  initialData?: TData | InitialDataFunction<TData>\n  /**\n   * If set, this value will be used as the time (in milliseconds) of when the `initialData` itself was last updated.\n   */\n  initialDataUpdatedAt?: number | (() => number | undefined)\n  /** @internal */\n  behavior?: QueryBehavior<TQueryFnData, TError, TData, TQueryKey>\n  /**\n   * Set this to `false` to disable structural sharing between query results.\n   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom structural sharing logic.\n   *\n   * @defaultValue true\n   */\n  structuralSharing?:\n    boolean | ((oldData: unknown | undefined, newData: unknown) => unknown)\n  /** @internal */\n  _defaulted?: boolean\n  /** @internal */\n  _type?: 'infinite'\n  /**\n   * Additional payload to be stored on each query.\n   * Use this property to pass information that can be used in other places.\n   */\n  meta?: QueryMeta\n  /**\n   * Maximum number of pages to store in the data of an infinite query.\n   */\n  maxPages?: number\n}\n\nexport interface InitialPageParam<TPageParam = unknown> {\n  /**\n   * The page param to start from when an infinite query has no pages yet.\n   * It is passed to `queryFn` as `pageParam` for the first page; every page after that gets the\n   * value returned by `getNextPageParam` or `getPreviousPageParam`.\n   * It only applies while the query has no pages: once a first page exists, refetching starts from\n   * that page's own param instead.\n   */\n  initialPageParam: TPageParam\n}\n\nexport interface InfiniteQueryPageParamsOptions<\n  TQueryFnData = unknown,\n  TPageParam = unknown,\n> extends InitialPageParam<TPageParam> {\n  /**\n   * This function can be set to automatically get the previous cursor for infinite queries.\n   * The result will also be used to determine the value of `hasPreviousPage`.\n   */\n  getPreviousPageParam?: GetPreviousPageParamFunction<TPageParam, TQueryFnData>\n  /**\n   * This function can be set to automatically get the next cursor for infinite queries.\n   * The result will also be used to determine the value of `hasNextPage`.\n   */\n  getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>\n}\n\n/** @inline */\nexport type ThrowOnError<\n  TQueryFnData,\n  TError,\n  TQueryData,\n  TQueryKey extends QueryKey,\n> =\n  | boolean\n  | ((\n      error: TError,\n      query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n    ) => boolean)\n\nexport interface QueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends WithRequired<\n  QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>,\n  'queryKey'\n> {\n  /**\n   * Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.\n   * To refetch the query, use the `refetch` method returned from the `useQuery` instance.\n   * Accepts a boolean or function that returns a boolean.\n   *\n   * @defaultValue true\n   */\n  enabled?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>\n  /**\n   * The time in milliseconds after data is considered stale.\n   * If set to `Infinity`, the data will never be considered stale.\n   * If set to `'static'`, the data will never be considered stale.\n   * If set to a function, the function will be executed with the query to compute a `staleTime`.\n   *\n   * @defaultValue 0\n   */\n  staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>\n  /**\n   * If set to a number, the query will continuously refetch at this frequency in milliseconds.\n   * If set to a function, the function will be executed with the latest data and query to compute a frequency\n   *\n   * @defaultValue false\n   */\n  refetchInterval?:\n    | number\n    | false\n    | ((\n        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n      ) => number | false | undefined)\n  /**\n   * If set to `true`, the query will continue to refetch while their tab/window is in the background.\n   *\n   * @defaultValue false\n   */\n  refetchIntervalInBackground?: boolean\n  /**\n   * If set to `true`, the query will refetch on window focus if the data is stale.\n   * If set to `false`, the query will not refetch on window focus.\n   * If set to `'always'`, the query will always refetch on window focus (except when `staleTime: 'static'` is used).\n   * If set to a function, the function will be executed with the latest data and query to compute the value.\n   *\n   * @defaultValue true\n   */\n  refetchOnWindowFocus?:\n    | boolean\n    | 'always'\n    | ((\n        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n      ) => boolean | 'always')\n  /**\n   * If set to `true`, the query will refetch on reconnect if the data is stale.\n   * If set to `false`, the query will not refetch on reconnect.\n   * If set to `'always'`, the query will always refetch on reconnect (except when `staleTime: 'static'` is used).\n   * If set to a function, the function will be executed with the latest data and query to compute the value.\n   *\n   * Defaults to `true` unless `networkMode` is `'always'`.\n   */\n  refetchOnReconnect?:\n    | boolean\n    | 'always'\n    | ((\n        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n      ) => boolean | 'always')\n  /**\n   * If set to `true`, the query will refetch on mount if the data is stale.\n   * If set to `false`, will disable additional instances of a query to trigger background refetch.\n   * If set to `'always'`, the query will always refetch on mount (except when `staleTime: 'static'` is used).\n   * If set to a function, the function will be executed with the latest data and query to compute the value\n   *\n   * @defaultValue true\n   */\n  refetchOnMount?:\n    | boolean\n    | 'always'\n    | ((\n        query: Query<TQueryFnData, TError, TQueryData, TQueryKey>,\n      ) => boolean | 'always')\n  /**\n   * If set to `false`, the query will not be retried on mount if it contains an error.\n   * If set to a function, the function will be executed with the query to compute the value.\n   *\n   * @defaultValue true\n   */\n  retryOnMount?: QueryBooleanOption<TQueryFnData, TError, TQueryData, TQueryKey>\n  /**\n   * If set, the component will only re-render if any of the listed properties change.\n   * When set to `['data', 'error']`, the component will only re-render when the `data` or `error` properties change.\n   * When set to `'all'`, the component will re-render whenever a query is updated.\n   * When set to a function, the function will be executed to compute the list of properties.\n   *\n   * Defaults to `undefined`, in which case property access is tracked automatically, and the\n   * component only re-renders when one of the tracked properties changes.\n   */\n  notifyOnChangeProps?: NotifyOnChangeProps\n  /**\n   * Whether errors should be thrown instead of setting the `error` property.\n   * If set to `true` or `suspense` is `true`, all errors will be thrown to the error boundary.\n   * If set to `false` and `suspense` is `false`, errors are returned as state.\n   * If set to a function, it will be passed the error and the query, and it should return a boolean indicating whether to show the error in an error boundary (`true`) or return the error as state (`false`).\n   *\n   * @defaultValue false\n   */\n  throwOnError?: ThrowOnError<TQueryFnData, TError, TQueryData, TQueryKey>\n  /**\n   * This option can be used to transform or select a part of the data returned by the query function. It affects\n   * the returned `data` value, but does not affect what gets stored in the query cache.\n   * The `select` function will only run if `data` changed, or if the reference to the `select` function itself\n   * changes. To optimize, memoize the function so its reference stays stable across calls.\n   */\n  select?: (data: TQueryData) => TData\n  /**\n   * If set to `true`, the query will suspend when `status === 'pending'`\n   * and throw errors when `status === 'error'`.\n   *\n   * @defaultValue false\n   */\n  suspense?: boolean\n  /**\n   * If set, this value will be used as the placeholder data for this particular query observer while the query is still in the `loading` data and no initialData has been provided.\n   */\n  placeholderData?:\n    | NonFunctionGuard<TQueryData>\n    | PlaceholderDataFunction<\n        NonFunctionGuard<TQueryData>,\n        TError,\n        NonFunctionGuard<TQueryData>,\n        TQueryKey\n      >\n\n  /** @internal */\n  _optimisticResults?: 'optimistic' | 'isRestoring'\n}\n\nexport type WithRequired<TTarget, TKey extends keyof TTarget> = TTarget & {\n  [_ in TKey]: {}\n}\n\nexport type DefaultedQueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n> = WithRequired<\n  QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,\n  'throwOnError' | 'refetchOnReconnect' | 'queryHash'\n>\n\nexport interface InfiniteQueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n>\n  extends\n    QueryObserverOptions<\n      TQueryFnData,\n      TError,\n      TData,\n      InfiniteData<TQueryFnData, TPageParam>,\n      TQueryKey,\n      TPageParam\n    >,\n    InfiniteQueryPageParamsOptions<TQueryFnData, TPageParam> {}\n\nexport type DefaultedInfiniteQueryObserverOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = WithRequired<\n  InfiniteQueryObserverOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    TQueryKey,\n    TPageParam\n  >,\n  'throwOnError' | 'refetchOnReconnect' | 'queryHash'\n>\n\nexport interface QueryExecuteOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends WithRequired<\n  QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>,\n  'queryKey'\n> {\n  initialPageParam?: never\n  /**\n   * This option can be used to transform or select a part of the data returned by the query function. It affects\n   * the value this call resolves with, but does not affect what gets stored in the query cache.\n   */\n  select?: (data: TQueryData) => TData\n  /**\n   * The time in milliseconds after data is considered stale.\n   * If the data is fresh it will be returned from the cache.\n   */\n  staleTime?: StaleTimeFunction<TQueryFnData, TError, TQueryData, TQueryKey>\n}\n\n/** @deprecated */\nexport interface FetchQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends WithRequired<\n  QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,\n  'queryKey'\n> {\n  initialPageParam?: never\n  /**\n   * The time in milliseconds after data is considered stale.\n   * If the data is fresh it will be returned from the cache.\n   */\n  staleTime?: StaleTimeFunction<TQueryFnData, TError, TData, TQueryKey>\n}\n\n/** @deprecated */\nexport interface EnsureQueryDataOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = never,\n> extends FetchQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> {\n  revalidateIfStale?: boolean\n}\n\n/** @deprecated */\nexport type EnsureInfiniteQueryDataOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = FetchInfiniteQueryOptions<\n  TQueryFnData,\n  TError,\n  TData,\n  TQueryKey,\n  TPageParam\n> & {\n  revalidateIfStale?: boolean\n}\n\ntype InfiniteQueryPages<TQueryFnData = unknown, TPageParam = unknown> =\n  | { pages?: never }\n  | {\n      pages: number\n      getNextPageParam: GetNextPageParamFunction<TPageParam, TQueryFnData>\n    }\n\nexport type InfiniteQueryExecuteOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = InfiniteData<TQueryFnData>,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = Omit<\n  QueryExecuteOptions<\n    TQueryFnData,\n    TError,\n    TData,\n    InfiniteData<TQueryFnData, TPageParam>,\n    TQueryKey,\n    TPageParam\n  >,\n  'initialPageParam'\n> &\n  InitialPageParam<TPageParam> &\n  InfiniteQueryPages<TQueryFnData, TPageParam>\n\n/** @deprecated */\nexport type FetchInfiniteQueryOptions<\n  TQueryFnData = unknown,\n  TError = DefaultError,\n  TData = TQueryFnData,\n  TQueryKey extends QueryKey = QueryKey,\n  TPageParam = unknown,\n> = Omit<\n  FetchQueryOptions<\n    TQueryFnData,\n    TError,\n    InfiniteData<TData, TPageParam>,\n    TQueryKey,\n    TPageParam\n  >,\n  'initialPageParam'\n> &\n  InitialPageParam<TPageParam> &\n  InfiniteQueryPages<TQueryFnData, TPageParam>\n\nexport interface ResultOptions {\n  /**\n   * If set to `true`, the method throws if any of the underlying query refetch tasks fail.\n   * If set to `false`, failed refetches are swallowed and not surfaced to the caller.\n   *\n   * @defaultValue false\n   */\n  throwOnError?: boolean\n}\n\nexport interface RefetchOptions extends ResultOptions {\n  /**\n   * If set to `true`, a currently running request will be cancelled before a new request is made\n   *\n   * If set to `false`, no refetch will be made if there is already a request running.\n   *\n   * @defaultValue true\n   */\n  cancelRefetch?: boolean\n}\n\nexport interface InvalidateQueryFilters<\n  TQueryKey extends QueryKey = QueryKey,\n> extends QueryFilters<TQueryKey> {\n  /**\n   * Controls which of the matched (now-invalidated) queries are refetched in the background.\n   *\n   * - `'active'`: only queries with at least one active observer are refetched.\n   * - `'inactive'`: only queries with no active observer are refetched.\n   * - `'all'`: every matched query is refetched, active or not.\n   * - `'none'`: no query is refetched; matched queries are only marked as invalidated.\n   *\n   * @defaultValue 'active'\n   */\n  refetchType?: QueryTypeFilter | 'none'\n}\n\nexport interface RefetchQueryFilters<\n  TQueryKey extends QueryKey = QueryKey,\n> extends QueryFilters<TQueryKey> {}\n\nexport interface InvalidateOptions extends RefetchOptions {}\nexport interface ResetOptions extends RefetchOptions {}\n\nexport interface FetchNextPageOptions extends ResultOptions {\n  /**\n   * If set to `true`, calling `fetchNextPage` repeatedly will invoke `queryFn` every time,\n   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.\n   *\n   * If set to `false`, calling `fetchNextPage` repeatedly won't have any effect until the first invocation has resolved.\n   *\n   * @defaultValue true\n   */\n  cancelRefetch?: boolean\n}\n\nexport interface FetchPreviousPageOptions extends ResultOptions {\n  /**\n   * If set to `true`, calling `fetchPreviousPage` repeatedly will invoke `queryFn` every time,\n   * whether the previous invocation has resolved or not. Also, the result from previous invocations will be ignored.\n   *\n   * If set to `false`, calling `fetchPreviousPage` repeatedly won't have any effect until the first invocation has resolved.\n   *\n   * @defaultValue true\n   */\n  cancelRefetch?: boolean\n}\n\n/** @inline */\nexport type QueryStatus = 'pending' | 'error' | 'success'\n/** @inline */\nexport type FetchStatus = 'fetching' | 'paused' | 'idle'\n\nexport interface QueryObserverBaseResult<\n  TData = unknown,\n  TError = DefaultError,\n> {\n  /**\n   * The last successfully resolved data for the query.\n   */\n  data: TData | undefined\n  /**\n   * The timestamp for when the query most recently returned the `status` as `\"success\"`.\n   */\n  dataUpdatedAt: number\n  /**\n   * The error object for the query, if an error was thrown.\n   * - Defaults to `null`.\n   */\n  error: TError | null\n  /**\n   * The timestamp for when the query most recently returned the `status` as `\"error\"`.\n   */\n  errorUpdatedAt: number\n  /**\n   * The failure count for the query.\n   * - Incremented every time the query fails.\n   * - Reset to `0` when the query succeeds.\n   */\n  failureCount: number\n  /**\n   * The failure reason for the query retry.\n   * - Reset to `null` when the query succeeds.\n   */\n  failureReason: TError | null\n  /**\n   * The sum of all errors.\n   */\n  errorUpdateCount: number\n  /**\n   * A derived boolean from the `status` variable, provided for convenience.\n   * - `true` if the query attempt resulted in an error.\n   */\n  isError: boolean\n  /**\n   * Will be `true` if the query has been fetched.\n   */\n  isFetched: boolean\n  /**\n   * Will be `true` if the query has been fetched after the component mounted.\n   * - This property can be used to not show any previously cached data.\n   */\n  isFetchedAfterMount: boolean\n  /**\n   * A derived boolean from the `fetchStatus` variable, provided for convenience.\n   * - `true` whenever the `queryFn` is executing, which includes initial `pending` as well as background refetch.\n   */\n  isFetching: boolean\n  /**\n   * Is `true` whenever the first fetch for a query is in-flight.\n   * - Is the same as `isFetching && isPending`.\n   */\n  isLoading: boolean\n  /**\n   * Will be `pending` if there's no cached data and no query attempt was finished yet.\n   */\n  isPending: boolean\n  /**\n   * Will be `true` if the query failed while fetching for the first time.\n   */\n  isLoadingError: boolean\n  /**\n   * @deprecated `isInitialLoading` is being deprecated in favor of `isLoading`\n   * and will be removed in the next major version.\n   */\n  isInitialLoading: boolean\n  /**\n   * A derived boolean from the `fetchStatus` variable, provided for convenience.\n   * - The query wanted to fetch, but has been `paused`.\n   */\n  isPaused: boolean\n  /**\n   * Will be `true` if the data shown is the placeholder data.\n   */\n  isPlaceholderData: boolean\n  /**\n   * Will be `true` if the query failed while refetching.\n   */\n  isRefetchError: boolean\n  /**\n   * Is `true` whenever a background refetch is in-flight, which _does not_ include initial `pending`.\n   * - Is the same as `isFetching && !isPending`.\n   */\n  isRefetching: boolean\n  /**\n   * Will be `true` if the data in the cache is invalidated or if the data is older than the given `staleTime`.\n   */\n  isStale: boolean\n  /**\n   * A derived boolean from the `status` variable, provided for convenience.\n   * - `true` if the query has received a response with no errors and is ready to display its data.\n   */\n  isSuccess: boolean\n  /**\n   * `true` if this observer is enabled, `false` otherwise.\n   */\n  isEnabled: boolean\n  /**\n   * A function to manually refetch the query.\n   */\n  refetch: (\n    options?: RefetchOptions,\n  ) => Promise<QueryObserverResult<TData, TError>>\n  /**\n   * The status of the query.\n   * - Will be:\n   *   - `pending` if there's no cached data and no query attempt was finished yet.\n   *   - `error` if the query attempt resulted in an error.\n   *   - `success` if the query has received a response with no errors and is ready to display its data.\n   */\n  status: QueryStatus\n  /**\n   * The fetch status of the query.\n   * - `fetching`: Is `true` whenever the queryFn is executing, which includes initial `pending` as well as background refetch.\n   * - `paused`: The query wanted to fetch, but has been `paused`.\n   * - `idle`: The query is not fetching.\n   * - See [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.\n   */\n  fetchStatus: FetchStatus\n}\n\nexport interface QueryObserverPendingResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: null\n  isError: false\n  isPending: true\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'pending'\n}\n\nexport interface QueryObserverLoadingResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: null\n  isError: false\n  isPending: true\n  isLoading: true\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'pending'\n}\n\nexport interface QueryObserverLoadingErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: TError\n  isError: true\n  isPending: false\n  isLoading: false\n  isLoadingError: true\n  isRefetchError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'error'\n}\n\nexport interface QueryObserverRefetchErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: TData\n  error: TError\n  isError: true\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: true\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'error'\n}\n\nexport interface QueryObserverSuccessResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: TData\n  error: null\n  isError: false\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: true\n  isPlaceholderData: false\n  status: 'success'\n}\n\nexport interface QueryObserverPlaceholderResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  data: TData\n  isError: false\n  error: null\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: true\n  isPlaceholderData: true\n  status: 'success'\n}\n\nexport type DefinedQueryObserverResult<TData = unknown, TError = DefaultError> =\n  | QueryObserverRefetchErrorResult<TData, TError>\n  | QueryObserverSuccessResult<TData, TError>\n\nexport type QueryObserverResult<TData = unknown, TError = DefaultError> =\n  | DefinedQueryObserverResult<TData, TError>\n  | QueryObserverLoadingErrorResult<TData, TError>\n  | QueryObserverLoadingResult<TData, TError>\n  | QueryObserverPendingResult<TData, TError>\n  | QueryObserverPlaceholderResult<TData, TError>\n\nexport interface InfiniteQueryObserverBaseResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends QueryObserverBaseResult<TData, TError> {\n  /**\n   * This function allows you to fetch the next \"page\" of results.\n   */\n  fetchNextPage: (\n    options?: FetchNextPageOptions,\n  ) => Promise<InfiniteQueryObserverResult<TData, TError>>\n  /**\n   * This function allows you to fetch the previous \"page\" of results.\n   */\n  fetchPreviousPage: (\n    options?: FetchPreviousPageOptions,\n  ) => Promise<InfiniteQueryObserverResult<TData, TError>>\n  /**\n   * Will be `true` if there is a next page to be fetched (known via the `getNextPageParam` option).\n   */\n  hasNextPage: boolean\n  /**\n   * Will be `true` if there is a previous page to be fetched (known via the `getPreviousPageParam` option).\n   */\n  hasPreviousPage: boolean\n  /**\n   * Will be `true` if the query failed while fetching the next page.\n   */\n  isFetchNextPageError: boolean\n  /**\n   * Will be `true` while fetching the next page with `fetchNextPage`.\n   */\n  isFetchingNextPage: boolean\n  /**\n   * Will be `true` if the query failed while fetching the previous page.\n   */\n  isFetchPreviousPageError: boolean\n  /**\n   * Will be `true` while fetching the previous page with `fetchPreviousPage`.\n   */\n  isFetchingPreviousPage: boolean\n}\n\nexport interface InfiniteQueryObserverPendingResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: null\n  isError: false\n  isPending: true\n  isLoadingError: false\n  isRefetchError: false\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'pending'\n}\n\nexport interface InfiniteQueryObserverLoadingResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: null\n  isError: false\n  isPending: true\n  isLoading: true\n  isLoadingError: false\n  isRefetchError: false\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'pending'\n}\n\nexport interface InfiniteQueryObserverLoadingErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: undefined\n  error: TError\n  isError: true\n  isPending: false\n  isLoading: false\n  isLoadingError: true\n  isRefetchError: false\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'error'\n}\n\nexport interface InfiniteQueryObserverRefetchErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: TData\n  error: TError\n  isError: true\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: true\n  isSuccess: false\n  isPlaceholderData: false\n  status: 'error'\n}\n\nexport interface InfiniteQueryObserverSuccessResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: TData\n  error: null\n  isError: false\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: false\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  isSuccess: true\n  isPlaceholderData: false\n  status: 'success'\n}\n\nexport interface InfiniteQueryObserverPlaceholderResult<\n  TData = unknown,\n  TError = DefaultError,\n> extends InfiniteQueryObserverBaseResult<TData, TError> {\n  data: TData\n  isError: false\n  error: null\n  isPending: false\n  isLoading: false\n  isLoadingError: false\n  isRefetchError: false\n  isSuccess: true\n  isPlaceholderData: true\n  isFetchNextPageError: false\n  isFetchPreviousPageError: false\n  status: 'success'\n}\n\nexport type DefinedInfiniteQueryObserverResult<\n  TData = unknown,\n  TError = DefaultError,\n> =\n  | InfiniteQueryObserverRefetchErrorResult<TData, TError>\n  | InfiniteQueryObserverSuccessResult<TData, TError>\n\nexport type InfiniteQueryObserverResult<\n  TData = unknown,\n  TError = DefaultError,\n> =\n  | DefinedInfiniteQueryObserverResult<TData, TError>\n  | InfiniteQueryObserverLoadingErrorResult<TData, TError>\n  | InfiniteQueryObserverLoadingResult<TData, TError>\n  | InfiniteQueryObserverPendingResult<TData, TError>\n  | InfiniteQueryObserverPlaceholderResult<TData, TError>\n\n/**\n * The type of a mutation key — the serializable array used to identify and filter mutations.\n * Defaults to `ReadonlyArray<unknown>`; declare `mutationKey` on {@link Register} to narrow it repository-wide.\n */\nexport type MutationKey = Register extends {\n  mutationKey: infer TMutationKey\n}\n  ? TMutationKey extends ReadonlyArray<unknown>\n    ? TMutationKey\n    : TMutationKey extends Array<unknown>\n      ? TMutationKey\n      : ReadonlyArray<unknown>\n  : ReadonlyArray<unknown>\n\n/** @inline */\nexport type MutationStatus = 'idle' | 'pending' | 'success' | 'error'\n\n/**\n * Groups mutations so they run one after another instead of in parallel.\n * Mutations that share the same `id` form a queue: while one is running, the others wait in `isPaused: true`\n * state and resume automatically when their turn comes. Mutations with no scope always run in parallel.\n */\nexport type MutationScope = {\n  id: string\n}\n\n/**\n * The type of the `meta` object that can be attached to a mutation and read back from `mutationFn`, callbacks and\n * cache-level handlers. Defaults to `Record<string, unknown>`; declare `mutationMeta` on {@link Register} to narrow it.\n */\nexport type MutationMeta = Register extends {\n  mutationMeta: infer TMutationMeta\n}\n  ? TMutationMeta extends Record<string, unknown>\n    ? TMutationMeta\n    : Record<string, unknown>\n  : Record<string, unknown>\n\nexport type MutationFunctionContext = {\n  client: QueryClient\n  meta: MutationMeta | undefined\n  mutationKey?: MutationKey\n}\n\n/** @inline */\nexport type MutationFunction<TData = unknown, TVariables = unknown> = (\n  variables: TVariables,\n  context: MutationFunctionContext,\n) => Promise<TData>\n\nexport interface MutationOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> {\n  /**\n   * The function that performs the asynchronous task this mutation runs.\n   * Required, unless a default mutation function has been set for the matching `mutationKey` via\n   * `queryClient.setMutationDefaults`.\n   * Receives the `variables` passed to `mutate`, and a {@link MutationFunctionContext} holding the\n   * `QueryClient`, the `mutationKey` and `meta`.\n   * Must return a promise that resolves the mutation's data.\n   */\n  mutationFn?: MutationFunction<TData, TVariables>\n  /**\n   * The key to use for this mutation. Optional, but required to inherit defaults registered with\n   * `queryClient.setMutationDefaults`, and to match this mutation with `useMutationState` or\n   * `queryClient.isMutating`.\n   */\n  mutationKey?: MutationKey\n  /**\n   * This function fires before the mutation function runs, and receives the same variables.\n   * Useful for optimistic updates applied in the hope that the mutation succeeds.\n   * The value it returns is passed to `onSuccess`, `onError` and `onSettled` as `onMutateResult`,\n   * which is where an optimistic update is usually rolled back.\n   * If a promise is returned, it is awaited before the mutation function runs.\n   */\n  onMutate?: (\n    variables: TVariables,\n    context: MutationFunctionContext,\n  ) => Promise<TOnMutateResult> | TOnMutateResult\n  /**\n   * This function fires when the mutation succeeds, and is passed the mutation's result.\n   * If a promise is returned, it is awaited before `onSettled` runs.\n   */\n  onSuccess?: (\n    data: TData,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /**\n   * This function fires when the mutation encounters an error, and is passed the error.\n   * If a promise is returned, it is awaited before `onSettled` runs.\n   */\n  onError?: (\n    error: TError,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /**\n   * This function fires when the mutation either succeeds or errors, and is passed either the data\n   * or the error.\n   * If a promise is returned, it is awaited before the mutation settles.\n   */\n  onSettled?: (\n    data: TData | undefined,\n    error: TError | null,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => Promise<unknown> | unknown\n  /**\n   * If `false`, failed mutations will not retry by default.\n   * If `true`, failed mutations will retry infinitely.\n   * If set to an integer number, e.g. 3, failed mutations will retry until the failed mutation count meets that number.\n   * If set to a function `(failureCount, error) => boolean` failed mutations will retry until the function returns false.\n   *\n   * @defaultValue 0\n   */\n  retry?: RetryValue<TError>\n  /**\n   * This function receives a `retryAttempt` integer and the actual Error and returns the delay to apply before the\n   * next attempt in milliseconds.\n   *\n   * Defaults to a function that applies exponential backoff, capped at 30 seconds.\n   */\n  retryDelay?: RetryDelayValue<TError>\n  /**\n   * Controls whether a mutation is allowed to run based on the current network connectivity.\n   *\n   * @defaultValue 'online'\n   * @see [Network Mode](https://tanstack.com/query/latest/docs/framework/react/guides/network-mode) for more information.\n   */\n  networkMode?: NetworkMode\n  /**\n   * The time in milliseconds that an unused/inactive mutation remains in memory before it is\n   * garbage collected.\n   *\n   * Defaults to `5 * 60 * 1000` (5 minutes), or `Infinity` during SSR.\n   */\n  gcTime?: number\n  /** @internal */\n  _defaulted?: boolean\n  /**\n   * Additional payload to be stored on the mutation cache entry.\n   * Use it to pass information that can be read wherever the `mutation` is available, such as the\n   * `onError` and `onSuccess` callbacks of the `MutationCache`.\n   */\n  meta?: MutationMeta\n  /**\n   * Controls whether this mutation runs alongside others or waits its turn.\n   * Mutations sharing the same `scope.id` run serially, in the order they were started.\n   * Without a scope, a mutation runs as soon as it is triggered.\n   */\n  scope?: MutationScope\n}\n\nexport interface MutationObserverOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationOptions<TData, TError, TVariables, TOnMutateResult> {\n  /**\n   * Whether errors should be thrown instead of setting the `error` property.\n   * If set to `true`, all errors will be thrown to the nearest error boundary.\n   * If set to a function, it will be passed the error and should return a boolean indicating whether to throw the\n   * error (`true`) or return it as state (`false`).\n   *\n   * @defaultValue false\n   */\n  throwOnError?: boolean | ((error: TError) => boolean)\n}\n\nexport interface MutateOptions<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> {\n  onSuccess?: (\n    data: TData,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => void\n  onError?: (\n    error: TError,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => void\n  onSettled?: (\n    data: TData | undefined,\n    error: TError | null,\n    variables: TVariables,\n    onMutateResult: TOnMutateResult | undefined,\n    context: MutationFunctionContext,\n  ) => void\n}\n\nexport type MutateFunctionRest<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> = undefined extends TVariables\n  ? [\n      variables?: TVariables,\n      options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>,\n    ]\n  : [\n      variables: TVariables,\n      options?: MutateOptions<TData, TError, TVariables, TOnMutateResult>,\n    ]\n\nexport type MutateFunction<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> = (\n  ...rest: MutateFunctionRest<TData, TError, TVariables, TOnMutateResult>\n) => Promise<TData>\n\nexport interface MutationObserverBaseResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationState<TData, TError, TVariables, TOnMutateResult> {\n  /**\n   * The last successfully resolved data for the mutation.\n   */\n  data: TData | undefined\n  /**\n   * The variables object passed to the `mutationFn`.\n   */\n  variables: TVariables | undefined\n  /**\n   * The error object for the mutation, if an error was encountered.\n   * - Defaults to `null`.\n   */\n  error: TError | null\n  /**\n   * A boolean variable derived from `status`.\n   * - `true` if the last mutation attempt resulted in an error.\n   */\n  isError: boolean\n  /**\n   * A boolean variable derived from `status`.\n   * - `true` if the mutation is in its initial state prior to executing.\n   */\n  isIdle: boolean\n  /**\n   * A boolean variable derived from `status`.\n   * - `true` if the mutation is currently executing.\n   */\n  isPending: boolean\n  /**\n   * A boolean variable derived from `status`.\n   * - `true` if the last mutation attempt was successful.\n   */\n  isSuccess: boolean\n  /**\n   * The status of the mutation.\n   * - Will be:\n   *   - `idle` initial status prior to the mutation function executing.\n   *   - `pending` if the mutation is currently executing.\n   *   - `error` if the last mutation attempt resulted in an error.\n   *   - `success` if the last mutation attempt was successful.\n   */\n  status: MutationStatus\n  /**\n   * The mutation function you can call with variables to trigger the mutation and optionally hooks on additional callback options.\n   * @param variables - The variables object to pass to the `mutationFn`.\n   * @param options.onSuccess - This function will fire when the mutation is successful and will be passed the mutation's result.\n   * @param options.onError - This function will fire if the mutation encounters an error and will be passed the error.\n   * @param options.onSettled - This function will fire when the mutation is either successfully fetched or encounters an error and be passed either the data or error.\n   * @remarks\n   * - If you make multiple requests, `onSuccess` will fire only after the latest call you've made.\n   * - All the callback functions (`onSuccess`, `onError`, `onSettled`) are void functions, and the returned value will be ignored.\n   */\n  mutate: MutateFunction<TData, TError, TVariables, TOnMutateResult>\n  /**\n   * A function to clean the mutation internal state (i.e., it resets the mutation to its initial state).\n   */\n  reset: () => void\n}\n\nexport interface MutationObserverIdleResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult\n> {\n  data: undefined\n  variables: undefined\n  error: null\n  isError: false\n  isIdle: true\n  isPending: false\n  isSuccess: false\n  status: 'idle'\n}\n\nexport interface MutationObserverLoadingResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult\n> {\n  data: undefined\n  variables: TVariables\n  error: null\n  isError: false\n  isIdle: false\n  isPending: true\n  isSuccess: false\n  status: 'pending'\n}\n\nexport interface MutationObserverErrorResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult\n> {\n  data: undefined\n  error: TError\n  variables: TVariables\n  isError: true\n  isIdle: false\n  isPending: false\n  isSuccess: false\n  status: 'error'\n}\n\nexport interface MutationObserverSuccessResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> extends MutationObserverBaseResult<\n  TData,\n  TError,\n  TVariables,\n  TOnMutateResult\n> {\n  data: TData\n  error: null\n  variables: TVariables\n  isError: false\n  isIdle: false\n  isPending: false\n  isSuccess: true\n  status: 'success'\n}\n\nexport type MutationObserverResult<\n  TData = unknown,\n  TError = DefaultError,\n  TVariables = void,\n  TOnMutateResult = unknown,\n> =\n  | MutationObserverIdleResult<TData, TError, TVariables, TOnMutateResult>\n  | MutationObserverLoadingResult<TData, TError, TVariables, TOnMutateResult>\n  | MutationObserverErrorResult<TData, TError, TVariables, TOnMutateResult>\n  | MutationObserverSuccessResult<TData, TError, TVariables, TOnMutateResult>\n\nexport interface QueryClientConfig {\n  /** The query cache this client is connected to. A new `QueryCache` is created if not provided. */\n  queryCache?: QueryCache\n  /**\n   * The mutation cache this client is connected to. A new `MutationCache` is created if not\n   * provided.\n   */\n  mutationCache?: MutationCache\n  /** Default options for all queries and mutations created through this client. */\n  defaultOptions?: DefaultOptions\n}\n\nexport interface DefaultOptions<TError = DefaultError> {\n  /** Default options applied to every query, unless overridden per-query. */\n  queries?: OmitKeyof<\n    QueryObserverOptions<unknown, TError>,\n    'suspense' | 'queryKey'\n  >\n  /** Default options applied to every mutation, unless overridden per-mutation. */\n  mutations?: MutationObserverOptions<unknown, TError, unknown, unknown>\n  /** Default options used when hydrating queries; see {@link HydrateOptions}. */\n  hydrate?: HydrateOptions['defaultOptions']\n  /** Default options used when dehydrating the client's caches; see {@link DehydrateOptions}. */\n  dehydrate?: DehydrateOptions\n}\n\n/**\n * Options for cancelling an in-flight fetch, e.g. via `query.cancel()`.\n * They are carried on the {@link CancelledError} that the cancelled fetch rejects with.\n */\nexport interface CancelOptions {\n  revert?: boolean\n  silent?: boolean\n}\n\n/**\n * Options for writing data into the cache, e.g. via `queryClient.setQueryData()`.\n * `updatedAt` overrides the timestamp the data is recorded with, which is what staleness is measured from;\n * omit it to use the current time.\n */\nexport interface SetDataOptions {\n  updatedAt?: number\n}\n\n/** @inline */\nexport type NotifyEventType =\n  | 'added'\n  | 'removed'\n  | 'updated'\n  | 'observerAdded'\n  | 'observerRemoved'\n  | 'observerResultsUpdated'\n  | 'observerOptionsUpdated'\n\nexport interface NotifyEvent {\n  type: NotifyEventType\n}\n"],"mappings":";;;AAsFA,MAAa,gBAAgB,OAAO;AAEpC,MAAa,qBAAqB,OAAO;AAEzC,MAAa,cAAc,OAAO"}